use of io.jans.orm.search.filter.Filter in project jans by JanssenProject.
the class CouchbaseEntryManager method removeImpl.
protected <T> int removeImpl(String dn, Class<T> entryClass, Filter filter, int count) {
// Check entry class
checkEntryClass(entryClass, false);
String[] objectClasses = getTypeObjectClasses(entryClass);
Filter searchFilter;
if (objectClasses.length > 0) {
LOG.trace("Filter: {}", filter);
searchFilter = addObjectClassFilter(filter, objectClasses);
} else {
searchFilter = filter;
}
// Find entries
LOG.trace("-------------------------------------------------------");
LOG.trace("Filter: {}", filter);
LOG.trace("objectClasses count: {} ", objectClasses.length);
LOG.trace("objectClasses: {}", objectClasses.toString());
LOG.trace("Search filter: {}", searchFilter);
// Prepare properties types to allow build filter properly
List<PropertyAnnotation> propertiesAnnotations = getEntryPropertyAnnotations(entryClass);
Map<String, PropertyAnnotation> propertiesAnnotationsMap = prepareEntryPropertiesTypes(entryClass, propertiesAnnotations);
ParsedKey keyWithInum = toCouchbaseKey(dn);
ConvertedExpression convertedExpression;
try {
convertedExpression = toCouchbaseFilter(searchFilter, propertiesAnnotationsMap);
} catch (SearchException ex) {
throw new EntryDeleteException(String.format("Failed to convert filter %s to expression", searchFilter), ex);
}
try {
int processed = getOperationService().delete(keyWithInum.getKey(), getScanConsistency(convertedExpression), convertedExpression.expression(), count);
return processed;
} catch (Exception ex) {
throw new EntryDeleteException(String.format("Failed to delete entries with key: %s, expression: %s", keyWithInum.getKey(), convertedExpression), ex);
}
}
use of io.jans.orm.search.filter.Filter in project jans by JanssenProject.
the class CouchbaseFilterConverter method convertToCouchbaseFilter.
public ConvertedExpression convertToCouchbaseFilter(Filter genericFilter, Map<String, PropertyAnnotation> propertiesAnnotationsMap, Function<? super Filter, Boolean> processor) throws SearchException {
Filter currentGenericFilter = genericFilter;
FilterType type = currentGenericFilter.getType();
if (FilterType.RAW == type) {
LOG.warn("RAW Ldap filter to Couchbase convertion will be removed in new version!!!");
currentGenericFilter = ldapFilterConverter.convertRawLdapFilterToFilter(currentGenericFilter.getFilterString());
type = currentGenericFilter.getType();
}
boolean requiredConsistency = isRequiredConsistency(currentGenericFilter, propertiesAnnotationsMap);
if (processor != null) {
processor.apply(currentGenericFilter);
}
if ((FilterType.NOT == type) || (FilterType.AND == type) || (FilterType.OR == type)) {
Filter[] genericFilters = currentGenericFilter.getFilters();
ConvertedExpression[] expFilters = new ConvertedExpression[genericFilters.length];
if (genericFilters != null) {
// We can replace only multiple OR with IN
boolean canJoinOrFilters = FilterType.OR == type;
List<Filter> joinOrFilters = new ArrayList<Filter>();
String joinOrAttributeName = null;
for (int i = 0; i < genericFilters.length; i++) {
Filter tmpFilter = genericFilters[i];
expFilters[i] = convertToCouchbaseFilter(tmpFilter, propertiesAnnotationsMap, processor);
// Check if we can replace OR with IN
if (!canJoinOrFilters) {
continue;
}
if (tmpFilter.getMultiValued() != null) {
canJoinOrFilters = false;
continue;
}
if ((FilterType.EQUALITY != tmpFilter.getType()) || (tmpFilter.getFilters() != null)) {
canJoinOrFilters = false;
continue;
}
Boolean isMultiValuedDetected = determineMultiValuedByType(tmpFilter.getAttributeName(), propertiesAnnotationsMap);
if (!Boolean.FALSE.equals(isMultiValuedDetected) && !Boolean.FALSE.equals(currentGenericFilter.getMultiValued())) {
canJoinOrFilters = false;
continue;
}
if (joinOrAttributeName == null) {
joinOrAttributeName = tmpFilter.getAttributeName();
joinOrFilters.add(tmpFilter);
continue;
}
if (!joinOrAttributeName.equals(tmpFilter.getAttributeName())) {
canJoinOrFilters = false;
continue;
}
joinOrFilters.add(tmpFilter);
}
if (FilterType.NOT == type) {
return ConvertedExpression.build(Expression.par(expFilters[0].expression().not()), expFilters[0].consistency());
} else if (FilterType.AND == type) {
for (int i = 0; i < expFilters.length; i++) {
requiredConsistency |= expFilters[i].consistency();
}
Expression result = expFilters[0].expression();
for (int i = 1; i < expFilters.length; i++) {
result = result.and(expFilters[i].expression());
}
return ConvertedExpression.build(Expression.par(result), requiredConsistency);
} else if (FilterType.OR == type) {
for (int i = 0; i < expFilters.length; i++) {
requiredConsistency |= expFilters[i].consistency();
}
if (canJoinOrFilters) {
JsonArray jsonArrayValues = JsonArray.create();
Filter lastEqFilter = null;
for (Filter eqFilter : joinOrFilters) {
lastEqFilter = eqFilter;
jsonArrayValues.add(eqFilter.getAssertionValue());
}
Expression exp = Expression.par(buildPath(lastEqFilter, propertiesAnnotationsMap, processor).getFirst().in(jsonArrayValues));
return ConvertedExpression.build(exp, requiredConsistency);
} else {
Expression result = expFilters[0].expression();
for (int i = 1; i < expFilters.length; i++) {
result = result.or(expFilters[i].expression());
}
return ConvertedExpression.build(Expression.par(result), requiredConsistency);
}
}
}
}
if (FilterType.EQUALITY == type) {
boolean hasSubFilters = ArrayHelper.isNotEmpty(currentGenericFilter.getFilters());
Boolean isMultiValuedDetected = determineMultiValuedByType(currentGenericFilter.getAttributeName(), propertiesAnnotationsMap);
String internalAttribute = toInternalAttribute(currentGenericFilter);
Pair<Expression, Expression> pairExpression = buildPath(currentGenericFilter, propertiesAnnotationsMap, processor);
if (Boolean.TRUE.equals(currentGenericFilter.getMultiValued()) || Boolean.TRUE.equals(isMultiValuedDetected)) {
return ConvertedExpression.build(Collections.anyIn(internalAttribute + "_", pairExpression.getFirst()).satisfies(pairExpression.getSecond().eq(buildTypedExpression(currentGenericFilter))), requiredConsistency);
} else if (Boolean.FALSE.equals(currentGenericFilter.getMultiValued()) || Boolean.FALSE.equals(isMultiValuedDetected) || (hasSubFilters && (isMultiValuedDetected == null))) {
return ConvertedExpression.build(pairExpression.getSecond().eq(buildTypedExpression(currentGenericFilter)), requiredConsistency);
} else {
Expression nameExpression = pairExpression.getSecond();
Expression exp1 = Expression.par(Expression.path(nameExpression).eq(buildTypedExpression(currentGenericFilter)));
Expression exp2 = Expression.par(Expression.path(buildTypedExpression(currentGenericFilter)).in(nameExpression));
return ConvertedExpression.build(Expression.par(exp1.or(exp2)), requiredConsistency);
}
}
if (FilterType.LESS_OR_EQUAL == type) {
String internalAttribute = toInternalAttribute(currentGenericFilter);
Pair<Expression, Expression> pairExpression = buildPath(currentGenericFilter, propertiesAnnotationsMap, processor);
if (isMultiValue(currentGenericFilter, propertiesAnnotationsMap)) {
return ConvertedExpression.build(Collections.anyIn(internalAttribute + "_", pairExpression.getFirst()).satisfies(pairExpression.getSecond().lte(buildTypedExpression(currentGenericFilter))), requiredConsistency);
} else {
return ConvertedExpression.build(pairExpression.getSecond().lte(buildTypedExpression(currentGenericFilter)), requiredConsistency);
}
}
if (FilterType.GREATER_OR_EQUAL == type) {
String internalAttribute = toInternalAttribute(currentGenericFilter);
Pair<Expression, Expression> pairExpression = buildPath(currentGenericFilter, propertiesAnnotationsMap, processor);
if (isMultiValue(currentGenericFilter, propertiesAnnotationsMap)) {
return ConvertedExpression.build(Collections.anyIn(internalAttribute + "_", pairExpression.getFirst()).satisfies(pairExpression.getSecond().gte(buildTypedExpression(currentGenericFilter))), requiredConsistency);
} else {
return ConvertedExpression.build(pairExpression.getSecond().gte(buildTypedExpression(currentGenericFilter)), requiredConsistency);
}
}
if (FilterType.PRESENCE == type) {
String internalAttribute = toInternalAttribute(currentGenericFilter);
Pair<Expression, Expression> pairExpression = buildPath(currentGenericFilter, propertiesAnnotationsMap, processor);
if (isMultiValue(currentGenericFilter, propertiesAnnotationsMap)) {
return ConvertedExpression.build(Collections.anyIn(internalAttribute + "_", pairExpression.getFirst()).satisfies(pairExpression.getSecond().isNotMissing()), requiredConsistency);
} else {
return ConvertedExpression.build(pairExpression.getSecond().isNotMissing(), requiredConsistency);
}
}
if (FilterType.APPROXIMATE_MATCH == type) {
throw new SearchException("Convertion from APPROXIMATE_MATCH LDAP filter to Couchbase filter is not implemented");
}
if (FilterType.SUBSTRING == type) {
StringBuilder like = new StringBuilder();
if (currentGenericFilter.getSubInitial() != null) {
like.append(currentGenericFilter.getSubInitial());
}
like.append("%");
String[] subAny = currentGenericFilter.getSubAny();
if ((subAny != null) && (subAny.length > 0)) {
for (String any : subAny) {
like.append(any);
like.append("%");
}
}
if (currentGenericFilter.getSubFinal() != null) {
like.append(currentGenericFilter.getSubFinal());
}
String internalAttribute = toInternalAttribute(currentGenericFilter);
Pair<Expression, Expression> pairExpression = buildPath(currentGenericFilter, propertiesAnnotationsMap, processor);
if (isMultiValue(currentGenericFilter, propertiesAnnotationsMap)) {
return ConvertedExpression.build(Collections.anyIn(internalAttribute + "_", pairExpression.getFirst()).satisfies(pairExpression.getSecond().like(Expression.s(escapeValue(like.toString())))), requiredConsistency);
} else {
return ConvertedExpression.build(pairExpression.getSecond().like(Expression.s(escapeValue(like.toString()))), requiredConsistency);
}
}
if (FilterType.LOWERCASE == type) {
return ConvertedExpression.build(StringFunctions.lower(currentGenericFilter.getAttributeName()), requiredConsistency);
}
throw new SearchException(String.format("Unknown filter type '%s'", type));
}
use of io.jans.orm.search.filter.Filter in project jans by JanssenProject.
the class BaseEntryManager method countEntries.
@SuppressWarnings("unchecked")
public <T> int countEntries(Object entry) {
if (entry == null) {
throw new MappingException("Entry to count is null");
}
// Check entry class
Class<T> entryClass = (Class<T>) entry.getClass();
checkEntryClass(entryClass, false);
List<PropertyAnnotation> propertiesAnnotations = getEntryPropertyAnnotations(entryClass);
Object dnValue = getDNValue(entry, entryClass);
List<AttributeData> attributes = getAttributesListForPersist(entry, propertiesAnnotations);
Filter searchFilter = createFilterByEntry(entry, entryClass, attributes);
return countEntries(dnValue.toString(), entryClass, searchFilter);
}
use of io.jans.orm.search.filter.Filter in project jans by JanssenProject.
the class BaseEntryManager method createFilterByEntry.
protected <T> Filter createFilterByEntry(Object entry, Class<T> entryClass, List<AttributeData> attributes) {
Filter[] attributesFilters = createAttributesFilter(attributes);
Filter attributesFilter = null;
if (attributesFilters != null) {
attributesFilter = Filter.createANDFilter(attributesFilters);
}
String[] objectClasses = getObjectClasses(entry, entryClass);
return addObjectClassFilter(attributesFilter, objectClasses);
}
use of io.jans.orm.search.filter.Filter in project jans by JanssenProject.
the class BaseEntryManager method contains.
protected <T> boolean contains(String baseDN, Class<T> entryClass, List<PropertyAnnotation> propertiesAnnotations, List<AttributeData> attributes, String[] objectClasses, String... ldapReturnAttributes) {
Filter[] attributesFilters = createAttributesFilter(attributes);
Filter attributesFilter = null;
if (attributesFilters != null) {
attributesFilter = Filter.createANDFilter(attributesFilters);
}
return contains(baseDN, objectClasses, entryClass, propertiesAnnotations, attributesFilter, ldapReturnAttributes);
}
Aggregations