/** * Create a new Filter using the > operator. */ public static Filter greaterThan(String property, Object value) { return new Filter(property, value, OP_GREATER_THAN); }
@Override public Filter visitAfter(Filter filter) { if (filter.isTakesSingleValue() || filter.isTakesListOfValues()) { return Filter.and(filter, Filter.isNotNull(filter.getProperty())); } else { return filter; } } }, false);
private Criterion getCriterionListOfValues(final Filter filter) { final int operator = filter.getOperator(); switch (operator) { case Filter.OP_IN: return Restrictions.in(filter.getProperty(), filter.getValuesAsCollection()); case Filter.OP_NOT_IN: return Restrictions.not(Restrictions.in(filter.getProperty(), filter.getValuesAsCollection())); default: return null; } }
/** * Create a new Filter using the AND operator. * * <p> * This takes a variable number of parameters. Any number of * <code>Filter</code>s can be specified. */ public static Filter and(Filter... filters) { Filter filter = new Filter("AND", null, OP_AND); for (Filter f : filters) { filter.add(f); } return filter; }
@Override public List<SecurityRule> findGroupSecurityRule(List<String> userGroups, long categoryId) { Search searchCriteria = new Search(Category.class); searchCriteria.addField("security"); Filter securityFilter = Filter.some( "security", Filter.and(Filter.equal("category.id", categoryId), Filter.equal("user.groups.groupName", userGroups))); searchCriteria.addFilter(securityFilter); return super.search(searchCriteria); }
if (filter.isTakesSingleSubFilter()) { if (filter.getValue() instanceof Filter) { Filter result = walkFilter((Filter) filter.getValue(), visitor, removeNulls); if (result != filter.getValue()) { filter = new Filter(filter.getProperty(), result, filter.getOperator()); } else if (filter.isTakesListOfSubFilters()) { if (filter.getValue() instanceof List) { List<Filter> result = walkFilters((List<Filter>) filter.getValue(), visitor, removeNulls); if (result != filter.getValue()) { filter = new Filter(filter.getProperty(), result, filter.getOperator());
private Criterion getCriterionSingleValue(final Filter filter) { final int operator = filter.getOperator(); switch (operator) { case Filter.OP_EQUAL: return Restrictions.eq(filter.getProperty(), filter.getValue()); case Filter.OP_NOT_EQUAL: return Restrictions.ne(filter.getProperty(), filter.getValue()); case Filter.OP_LESS_THAN: return Restrictions.lt(filter.getProperty(), filter.getValue()); case Filter.OP_GREATER_THAN: return Restrictions.gt(filter.getProperty(), filter.getValue()); case Filter.OP_LESS_OR_EQUAL: return Restrictions.le(filter.getProperty(), filter.getValue()); case Filter.OP_GREATER_OR_EQUAL: return Restrictions.ge(filter.getProperty(), filter.getValue()); case Filter.OP_LIKE: return Restrictions.like(filter.getProperty(), String.format(LIKE_FORMAT, filter.getValue())); case Filter.OP_ILIKE: return Restrictions.ilike(filter.getProperty(), filter.getValue()); default: return null; } }
/** * Add security filtering in order to filter out resources the user has not read access to */ public void addReadSecurityConstraints(Search searchCriteria, User user) { // no further constraints for admin user if(user.getRole() == Role.ADMIN) { return; } Filter userFiltering = Filter.equal("user.name", user.getName()); if(! user.getGroups().isEmpty()) { List<Long> groupsId = new ArrayList<>(); for (UserGroup group : user.getGroups()) { groupsId.add(group.getId()); } userFiltering = Filter.or( userFiltering, Filter.in("group.id", groupsId)); } Filter securityFilter = Filter.some( "security", Filter.and( Filter.equal("canRead", true), userFiltering ) ); searchCriteria.addFilter(securityFilter); }
String property = filter.getProperty(); Object value = filter.getValue(); int operator = filter.getOperator(); if (filter.isTakesListOfValues()) { value = prepareValue(ctx.rootClass, property, value, true); } else if (filter.isTakesSingleValue()) { value = prepareValue(ctx.rootClass, property, value, false); String op = filter.getOperator() == Filter.OP_AND ? " and " : " or "; List<?> values = filter.getValuesAsList(); if (values == null) { values = Collections.singletonList(null); appendCustomExpression(sbCustom, ctx, filter.getProperty(), values); return sbCustom.toString(); default:
/** * @param resourceId * @return List<Attribute> */ @Override public List<Attribute> findAttributes(long resourceId) { Search searchCriteria = new Search(Resource.class); searchCriteria.addField("attribute"); Filter securityFilter = Filter.some("attribute", Filter.equal("resource.id", resourceId)); searchCriteria.addFilter(securityFilter); return super.search(searchCriteria); }
/** * Add a filter that uses the == operator. */ public static void addFilterEqual(IMutableSearch search, String property, Object value) { addFilter(search, Filter.equal(property, value)); }
private void addCriteria(Search searchCriteria, String fieldName, IdNameFilter filter) { switch (filter.getType()) { case ANY: break; // no filtering case DEFAULT: searchCriteria.addFilterNull(fieldName); break; case IDVALUE: searchCriteria.addFilterOr( Filter.isNull(fieldName), Filter.equal(fieldName + ".id", filter.getId())); break; case NAMEVALUE: searchCriteria.addFilterOr( Filter.isNull(fieldName), Filter.equal(fieldName + ".name", filter.getName())); break; default: throw new AssertionError(); } }
/** * This is a leaf filter. * * @throws InternalErrorServiceEx */ @Override public void visit(CategoryFilter filter) throws InternalErrorServiceEx { CategoryFilter.checkOperator(filter.getOperator()); Integer op = ops_rest_trg.get(filter.getOperator()); if (op == null) { throw new IllegalStateException("Unknown op " + filter.getOperator()); } Filter f = new Filter(); f.setOperator(op); f.setProperty("category.name"); f.setValue(filter.getName()); trgFilter = f; }
Object id = metadata.getIdValue(example); if (id != null) { filters.add(Filter.equal(listToPath(path, "id"), id)); return; if (value == null) { if (!options.isExcludeNulls()) { filters.add(Filter.isNull(listToPath(path, property))); break; filters.add(new Filter(listToPath(path, property), val, options.isIgnoreCase() ? Filter.OP_ILIKE : Filter.OP_LIKE)); } else { filters.add(Filter.equal(listToPath(path, property), value));
private Criterion getCriterionTakesNoValue(final Filter filter) { final int operator = filter.getOperator(); switch (operator) { case Filter.OP_NULL: return Restrictions.isNull(filter.getProperty()); case Filter.OP_NOT_NULL: return Restrictions.isNotNull(filter.getProperty()); case Filter.OP_EMPTY: return Restrictions.isEmpty(filter.getProperty()); case Filter.OP_NOT_EMPTY: return Restrictions.isNotEmpty(filter.getProperty()); default: return null; } }
@SuppressWarnings("unchecked") private Criterion getCriterionTakesListOfSubFilters(final Filter filter) { final int operator = filter.getOperator(); switch (operator) { case Filter.OP_AND: final List<Filter> filtersAnd = (List<Filter>) filter.getValuesAsList(); final List<Criterion> criterionsAnd = getCriterions(filtersAnd); if (criterionsAnd.size() == TWO_ARGS) { return Restrictions.and(criterionsAnd.get(IDX_0), criterionsAnd.get(IDX_1)); } case Filter.OP_OR: final List<Filter> filtersOr = (List<Filter>) filter.getValuesAsList(); final List<Criterion> criterionsOr = getCriterions(filtersOr); if (criterionsOr.size() == TWO_ARGS) { return Restrictions.or(criterionsOr.get(IDX_0), criterionsOr.get(IDX_1)); } default: return null; } }
/** * Modify the search by adding the given filters using OR semantics */ public static void mergeFiltersOr(IMutableSearch search, List<Filter> filters) { List<Filter> list = search.getFilters(); if (list == null) { list = new ArrayList<Filter>(); search.setFilters(list); } if (list.size() == 0 || search.isDisjunction()) { search.setDisjunction(true); list.addAll(filters); } else { search.setFilters(new ArrayList<Filter>()); // add the previous filters with an AND Filter orFilter = Filter.and(); orFilter.setValue(list); addFilter(search, orFilter); // add the new filters with or search.setDisjunction(true); search.getFilters().addAll(filters); } }