private Filter buildExpressionFilter(final List<String> path, Object expression) {
if (OR.equals(path.get(0))) {
@SuppressWarnings("unchecked")
Collection<DBObject> queryList = typecast(path + " operator", expression, Collection.class);
OrFilter orFilter = new OrFilter();
for (DBObject query : queryList) {
orFilter.addFilter(buildFilter(query));
}
return orFilter;
} else if (AND.equals(path.get(0))) {
Collection<DBObject> queryList = typecast(path + " operator", expression, Collection.class);
AndFilter andFilter = new AndFilter();
for (DBObject query : queryList) {
andFilter.addFilter(buildFilter(query));
}
return andFilter;
} else if (WHERE.equals(path.get(0))) {
return new WhereFilter((String) expression);
} else if (expression instanceof DBObject || expression instanceof Map) {
DBObject ref =
expression instanceof DBObject
? (DBObject) expression
: new BasicDBObject((Map) expression);
if (ref.containsField(NOT)) {
return new NotFilter(buildExpressionFilter(path, ref.get(NOT)));
} else {
AndFilter andFilter = new AndFilter();
int matchCount = 0;
for (FilterFactory filterFactory : filterFactories) {
if (filterFactory.matchesCommand(ref)) {
matchCount++;
andFilter.addFilter(filterFactory.createFilter(path, ref));
}
}
if (matchCount == 0) {
return simpleFilter(path, expression);
}
if (matchCount > 2) {
throw new FongoException("Invalid expression for key " + path + ": " + expression);
}
return andFilter;
}
} else if (expression instanceof Pattern) {
return createPatternFilter(path, (Pattern) expression);
} else {
return simpleFilter(path, expression);
}
}
private ObjectQuery createQuery() {
AccountContentSearchDto dto = searchModel.getObject();
if (StringUtils.isEmpty(dto.getSearchText())) {
return null;
}
try {
ObjectQuery query = null;
List<ObjectFilter> conditions = new ArrayList<>();
ObjectClassComplexTypeDefinition def = getAccountDefinition();
if (dto.isIdentifiers()) {
List<ResourceAttributeDefinition> identifiers = new ArrayList<>();
if (def.getIdentifiers() != null) {
identifiers.addAll(def.getIdentifiers());
}
// TODO set matching rule instead fo null
for (ResourceAttributeDefinition attrDef : identifiers) {
conditions.add(
EqualFilter.createEqual(
new ItemPath(ShadowType.F_ATTRIBUTES, attrDef.getName()),
attrDef,
dto.getSearchText()));
}
}
if (dto.isName()) {
List<ResourceAttributeDefinition> secondaryIdentifiers = new ArrayList<>();
if (def.getNamingAttribute() != null) {
secondaryIdentifiers.add(def.getNamingAttribute());
} else if (def.getSecondaryIdentifiers() != null) {
secondaryIdentifiers.addAll(def.getSecondaryIdentifiers());
}
for (ResourceAttributeDefinition attrDef : secondaryIdentifiers) {
conditions.add(
SubstringFilter.createSubstring(
new ItemPath(ShadowType.F_ATTRIBUTES, attrDef.getName()),
attrDef,
dto.getSearchText()));
}
}
if (!conditions.isEmpty()) {
if (conditions.size() > 1) {
query = ObjectQuery.createObjectQuery(OrFilter.createOr(conditions));
} else {
query = ObjectQuery.createObjectQuery(conditions.get(0));
}
}
return query;
} catch (Exception ex) {
error(getString("pageUsers.message.queryError") + " " + ex.getMessage());
LoggingUtils.logException(LOGGER, "Couldn't create query filter.", ex);
}
return null;
}
