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

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

Introduction

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

Prototype

public Criteria lt(Object o) 

Source Link

Document

Creates a criterion using the $lt operator.

Usage

From source file:com.seajas.search.profiler.service.repository.RepositoryService.java

/**
 * Create a query given any or all of the provided parameters.
 *
 * @param allStates// w  w w.  j a va  2s . c o  m
 * @param collection
 * @param sourceId
 * @param taxonomyMatch
 * @param startDate
 * @param endDate
 * @param url
 * @return Query
 */
private Query createQuery(final Boolean allStates, final String collection, final Integer sourceId,
        final String taxonomyMatch, final Date startDate, final Date endDate, final String url,
        final Map<String, String> parameters) {
    Query query = new Query();

    if (!allStates)
        query.addCriteria(
                new Criteria().orOperator(where("currentState").is(CompositeState.CompletedDocument.name()),
                        where("currentState").is(CompositeState.InitialDocument.name())));

    if (collection != null)
        query.addCriteria(where("source.collection").is(collection));
    if (sourceId != null)
        query.addCriteria(where("source.id").is(sourceId));
    if (taxonomyMatch != null)
        query.addCriteria(where("originalContent.hostname").is(taxonomyMatch));

    if (startDate != null || endDate != null) {
        Criteria dateCriteria = where("originalContent.dateSubmitted");

        if (startDate != null)
            dateCriteria = dateCriteria.gte(startDate);
        if (endDate != null)
            dateCriteria = dateCriteria.lt(endDate);

        query.addCriteria(dateCriteria);
    }

    if (parameters != null && parameters.size() > 0)
        for (Map.Entry<String, String> parameter : parameters.entrySet()) {
            if (parameter.getKey().contains(".") || parameter.getKey().contains("$"))
                throw new IllegalStateException("Can't add criteria for parameter '" + parameter.getKey()
                        + "' because it contains invalid characters");

            query.addCriteria(
                    where("source.resultParameters." + StringEscapeUtils.escapeJavaScript(parameter.getKey()))
                            .is(parameter.getValue()));
        }

    if (url != null)
        query.addCriteria(where("originalContent.uri").is(url));

    return query;
}

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());
            }// w  ww  .ja  v  a 2 s  . co  m
        }

        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  a2s .  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   ww w.  j  a va 2s .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 {/*  w ww . j av a2s . c  o m*/
        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;
}