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

Introduction

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

Prototype

public Criteria ne(@Nullable Object o) 

Source Link

Document

Creates a criterion using the $ne operator.

Usage

From source file:com.comcast.video.dawg.controller.house.filter.FieldCondition.java

/**
 * {@inheritDoc}/*w w w . j av  a2 s.c om*/
 */
@Override
public Criteria toCriteria(boolean negate) {
    boolean notToUse = negate ? !not : not;
    Criteria crit = Criteria.where("data." + field);
    switch (this.op) {
    case equals:
        return notToUse ? crit.ne(value) : crit.is(value);
    case contains:
        crit = notToUse ? crit.not() : crit;
        if (array) {
            return crit.in(value);
        } else {
            return crit.regex(".*" + value + ".*");
        }
    case matches:
        crit = notToUse ? crit.not() : crit;
        return crit.regex(value);
    default:
        return null;
    }
}

---

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  av  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.
 * /*  w ww  .j ava2 s  .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!");
}

---