Example usage for org.springframework.data.mongodb.core.query Criteria gt

List of usage examples for org.springframework.data.mongodb.core.query Criteria gt

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.data.mongodb.core.query.*
  5. Criteria
  6. gt

Introduction

In this page you can find the example usage for org.springframework.data.mongodb.core.query Criteria gt.

Prototype

public Criteria gt(Object o)

Source Link

Document

Creates a criterion using the $gt operator.

Usage

From source file:io.smalldata.ohmageomh.data.repository.MongoDataPointRepositoryImpl.java

void addCreationTimestampCriteria(Query query, Range<OffsetDateTime> timestampRange) {

    if (timestampRange.hasLowerBound() || timestampRange.hasUpperBound()) {

        Criteria timestampCriteria = where("header.creation_date_time");

        if (timestampRange.hasLowerBound()) {
            if (timestampRange.lowerBoundType() == CLOSED) {
                timestampCriteria = timestampCriteria.gte(timestampRange.lowerEndpoint());
            } else {
                timestampCriteria = timestampCriteria.gt(timestampRange.lowerEndpoint());
            }//from w ww  .j a va 2  s.  c om
        }

        if (timestampRange.hasUpperBound()) {
            if (timestampRange.upperBoundType() == CLOSED) {
                timestampCriteria = timestampCriteria.lte(timestampRange.upperEndpoint());
            } else {
                timestampCriteria = timestampCriteria.lt(timestampRange.upperEndpoint());
            }
        }

        query.addCriteria(timestampCriteria);
    }
}

From source file:org.opentestsystem.shared.search.domain.AbstractSearchRequest.java

protected Map<String, Criteria> buildCriteria() {

    final Map<String, Criteria> criteriaMap = new HashMap<>();

    for (final String searchKey : searchCriteria.keySet()) {
        final SearchFilter filter = searchFilterMap.get(searchKey);
        final String[] searchValues = searchCriteria.get(searchKey);
        if (hasAValue(searchValues)) {

            final Object[] queryValues = filter.getSearchValue(searchValues);
            final String domainName = filter.getDomainName();
            Criteria criteria = criteriaMap.get(filter.getDomainName());

            if (criteria == null) {
                criteria = Criteria.where(domainName);
            }//from   w w w  .j a  v a 2  s  . c o  m

            switch (filter.getOperator()) {
            case EQ:
                if (queryValues.length == ONE) {
                    criteria = criteria.is(queryValues[0]);
                } else {
                    criteria = criteria.in(queryValues);
                }
                break;
            case GTH:
                criteria = criteria.gt(queryValues[0]);
                break;
            case LTH:
                criteria = criteria.lt(queryValues[0]);
                break;
            case GEQ:
                criteria = criteria.gte(queryValues[0]);
                break;
            case LEQ:
                criteria = criteria.lte(queryValues[0]);
                break;
            case NOTNULL:
                criteria = criteria.ne(null);
                break;
            case CASE_INSENSITIVE:
                if (queryValues.length == ONE) {
                    criteria = buildCaseInsensitiveRegex(criteria, queryValues[0]);
                } else {
                    final Criteria[] critList = new Criteria[queryValues.length];
                    for (int i = 0; i < queryValues.length; i++) {
                        critList[i] = buildCaseInsensitiveRegex(Criteria.where(domainName), queryValues[i]);
                    }
                    criteria = new Criteria().orOperator(critList);
                }
                break;
            case WLD_REG:
                if (queryValues.length == ONE) {
                    criteria = buildRegex(criteria, queryValues[0]);
                } else {
                    final Criteria[] critList = new Criteria[queryValues.length];
                    for (int i = 0; i < queryValues.length; i++) {
                        critList[i] = buildRegex(Criteria.where(domainName), queryValues[i]);
                    }
                    criteria = new Criteria().orOperator(critList);
                }
                break;
            case DYNAMIC_ELEMENT_NAME:
                // modifying domain name, recreate the where
                criteria = Criteria.where(
                        domainName + (searchValues[0] == null ? "" : replaceEscapeChars(searchValues[0])));
                if (searchValues.length == ONE) {
                    // if only the first searchValue is specified (the element name)
                    // match any element (with the searchValue name that has a value
                    criteria = buildRegex(criteria, ".");
                } else if (searchValues.length == TWO) {
                    criteria = criteria.is(searchValues[1]);
                } else {
                    criteria = criteria.in((Object[]) Arrays.copyOfRange(searchValues, 1, searchValues.length));
                }
                break;
            default:
                break;
            }
            criteriaMap.put(domainName, criteria);
        }
    }
    final Map<String, Criteria> returnMap = new HashMap<String, Criteria>();
    for (final Criteria crit : criteriaMap.values()) {
        returnMap.put(crit.getKey(), crit);
    }
    return returnMap;
}

From source file:org.springframework.data.mongodb.repository.query.MongoQueryCreator.java

/**
 * Populates the given {@link CriteriaDefinition} depending on the {@link Type} given.
 * /*from  w  w  w .j  a v  a2s.  c  o  m*/
 * @param type
 * @param criteria
 * @param parameters
 * @return
 */
private Criteria from(Type type, Criteria criteria, PotentiallyConvertingIterator parameters) {

    switch (type) {
    case GREATER_THAN:
        return criteria.gt(parameters.nextConverted());
    case GREATER_THAN_EQUAL:
        return criteria.gte(parameters.nextConverted());
    case LESS_THAN:
        return criteria.lt(parameters.nextConverted());
    case LESS_THAN_EQUAL:
        return criteria.lte(parameters.nextConverted());
    case BETWEEN:
        return criteria.gt(parameters.nextConverted()).lt(parameters.nextConverted());
    case IS_NOT_NULL:
        return criteria.ne(null);
    case IS_NULL:
        return criteria.is(null);
    case NOT_IN:
        return criteria.nin(nextAsArray(parameters));
    case IN:
        return criteria.in(nextAsArray(parameters));
    case LIKE:
        String value = parameters.next().toString();
        return criteria.regex(toLikeRegex(value));
    case REGEX:
        return criteria.regex(parameters.next().toString());
    case EXISTS:
        return criteria.exists((Boolean) parameters.next());
    case TRUE:
        return criteria.is(true);
    case FALSE:
        return criteria.is(false);
    case NEAR:

        Distance distance = accessor.getMaxDistance();
        Point point = accessor.getGeoNearLocation();
        point = point == null ? nextAs(parameters, Point.class) : point;

        if (distance == null) {
            return criteria.near(point);
        } else {
            if (distance.getMetric() != null) {
                criteria.nearSphere(point);
            } else {
                criteria.near(point);
            }
            criteria.maxDistance(distance.getNormalizedValue());
        }
        return criteria;

    case WITHIN:
        Object parameter = parameters.next();
        return criteria.within((Shape) parameter);
    case SIMPLE_PROPERTY:
        return criteria.is(parameters.nextConverted());
    case NEGATING_SIMPLE_PROPERTY:
        return criteria.not().is(parameters.nextConverted());
    }

    throw new IllegalArgumentException("Unsupported keyword!");
}

From source file:piecework.model.DateSearchFacet.java

public Criteria criteria(DateRange value) {
    Criteria criteria = where(query);
    DateTimeFormatter dateTimeFormatter = ISODateTimeFormat.dateTimeParser();
    try {/*from  www.j  a v a  2 s . c om*/
        if (StringUtils.isNotEmpty(value.getAfter())) {
            DateTime dateTime = dateTimeFormatter.parseDateTime(value.getAfter());
            criteria.gt(dateTime.toDate());
        }
        if (StringUtils.isNotEmpty(value.getBefore())) {
            DateTime dateTime = dateTimeFormatter.parseDateTime(value.getBefore());
            criteria.lt(dateTime.toDate());
        }
    } catch (Exception e) {
        LOG.warn("Unable to parse " + value + " as a datetime object", e);
    }

    return criteria;
}