private void interpretQueryFilter(InterpretationContext context, ObjectQuery query)
throws QueryException {
if (query != null && query.getFilter() != null) {
Condition c = interpretFilter(context, query.getFilter(), null);
context.getHibernateQuery().addCondition(c);
}
}
/**
* Loads the list of resources assumed to implement the given concept. The concept must be a named
* concept and cannot be mapped to rdfs:Resource.
*/
public synchronized <T> Result<T> getObjects(final Class<T> concept, Resource... resources)
throws RepositoryException, QueryEvaluationException {
try {
int size = resources.length;
ObjectQuery query = getObjectQuery(concept, size);
if (size == 1) {
query.setBinding(ObjectFactory.VAR_PREFIX, resources[0]);
} else if (size > 1) {
for (int i = 0; i < size; i++) {
query.setBinding(ObjectFactory.VAR_PREFIX + i, resources[i]);
}
}
final List<Resource> list = new ArrayList<Resource>(size);
list.addAll(Arrays.asList(resources));
CloseableIteration<T, QueryEvaluationException> iter;
final Result<T> result = query.evaluate(concept);
iter =
new LookAheadIteration<T, QueryEvaluationException>() {
@Override
protected T getNextElement() throws QueryEvaluationException {
T next = result.next();
if (next != null) {
list.remove(((RDFObject) next).getResource());
return next;
}
if (!list.isEmpty()) return (T) cache(of.createObject(list.remove(0)));
return null;
}
};
return new ResultImpl<T>(iter);
} catch (MalformedQueryException e) {
throw new AssertionError(e);
}
}
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;
}
private ObjectQuery getAssociationsSearchQuery(
PrismContext prismContext,
PrismObject resource,
QName objectClass,
ShadowKindType kind,
String intent) {
try {
ObjectFilter andFilter =
AndFilter.createAnd(
EqualFilter.createEqual(
ShadowType.F_OBJECT_CLASS, ShadowType.class, prismContext, objectClass),
EqualFilter.createEqual(ShadowType.F_KIND, ShadowType.class, prismContext, kind),
// EqualFilter.createEqual(ShadowType.F_INTENT, ShadowType.class,
// prismContext, intent),
RefFilter.createReferenceEqual(
new ItemPath(ShadowType.F_RESOURCE_REF),
ShadowType.class,
prismContext,
resource.getOid()));
ObjectQuery query = ObjectQuery.createObjectQuery(andFilter);
return query;
} catch (SchemaException ex) {
LoggingUtils.logUnexpectedException(LOGGER, "Unable to create associations search query", ex);
return null;
}
}
private ObjectQuery createQuery() {
ReportOutputSearchDto dto = searchModel.getObject();
try {
List<ObjectFilter> ands = new ArrayList<>();
if (StringUtils.isNotEmpty(dto.getText())) {
PolyStringNormalizer normalizer = getPrismContext().getDefaultPolyStringNormalizer();
String normalizedString = normalizer.normalize(dto.getText());
SubstringFilter substring =
SubstringFilter.createSubstring(
ReportOutputType.F_NAME,
ReportOutputType.class,
getPrismContext(),
PolyStringNormMatchingRule.NAME,
normalizedString);
ands.add(substring);
}
String oid = dto.getReportTypeMap().get(dto.getReportType());
if (StringUtils.isNotEmpty(oid)) {
RefFilter ref =
RefFilter.createReferenceEqual(
ReportOutputType.F_REPORT_REF, ReportOutputType.class, getPrismContext(), oid);
ands.add(ref);
}
switch (ands.size()) {
case 0:
return null;
case 1:
return ObjectQuery.createObjectQuery(ands.get(0));
default:
AndFilter and = AndFilter.createAnd(ands);
return ObjectQuery.createObjectQuery(and);
}
} catch (Exception e) {
error(getString("pageCreatedReports.message.queryError") + " " + e.getMessage());
LoggingUtils.logException(LOGGER, "Couldn't create query filter.", e);
return null;
}
}
private void interpretPagingAndSorting(
InterpretationContext context, ObjectQuery query, boolean countingObjects)
throws QueryException {
RootHibernateQuery hibernateQuery = context.getHibernateQuery();
String rootAlias = hibernateQuery.getPrimaryEntityAlias();
if (query != null && query.getPaging() instanceof ObjectPagingAfterOid) {
ObjectPagingAfterOid paging = (ObjectPagingAfterOid) query.getPaging();
if (paging.getOidGreaterThan() != null) {
Condition c =
hibernateQuery.createSimpleComparisonCondition(
rootAlias + ".oid", paging.getOidGreaterThan(), ">");
hibernateQuery.addCondition(c);
}
}
if (!countingObjects && query != null && query.getPaging() != null) {
if (query.getPaging() instanceof ObjectPagingAfterOid) {
updatePagingAndSortingByOid(
hibernateQuery,
(ObjectPagingAfterOid)
query.getPaging()); // very special case - ascending ordering by OID (nothing more)
} else {
updatePagingAndSorting(context, query.getPaging());
}
}
}
