public static ObjectFilter createResourceAndObjectClassFilter(String resourceOid, QName objectClass, PrismContext prismContext) throws SchemaException { Validate.notNull(resourceOid, "Resource where to search must not be null."); Validate.notNull(objectClass, "Object class to search must not be null."); Validate.notNull(prismContext, "Prism context must not be null."); AndFilter and = prismContext.queryFactory().createAnd( createResourceFilter(resourceOid, prismContext), createObjectClassFilter(objectClass, prismContext)); return and; }
private <C extends Containerable> AndFilter parseAndFilter(MapXNodeImpl clauseXMap, PrismContainerDefinition<C> pcd, boolean preliminaryParsingOnly, ParsingContext pc) throws SchemaException { List<ObjectFilter> subfilters = parseLogicalFilter(clauseXMap, pcd, preliminaryParsingOnly, pc); if (preliminaryParsingOnly) { return null; } else { return prismContext.queryFactory().createAnd(subfilters); } }
public AccessCertificationCaseType getCase(String campaignOid, long caseId, @SuppressWarnings("unused") Task task, OperationResult result) throws SchemaException { QueryFactory queryFactory = prismContext.queryFactory(); ObjectFilter filter = queryFactory.createAnd( queryFactory.createOwnerHasOidIn(campaignOid), queryFactory.createInOid(String.valueOf(caseId)) ); ObjectQuery query = queryFactory.createQuery(filter); List<AccessCertificationCaseType> caseList = repositoryService.searchContainers(AccessCertificationCaseType.class, query, null, result); if (caseList.isEmpty()) { return null; } else if (caseList.size() == 1) { return caseList.get(0); } else { throw new IllegalStateException("More than one certification case with ID " + caseId + " in campaign " + campaignOid); } }
return prismContext.queryFactory().createAnd(origFilter, additionalFilter);
public ObjectQuery narrowQueryForWorkBucket(Task workerTask, ObjectQuery query, Class<? extends ObjectType> type, Function<ItemPath, ItemDefinition<?>> itemDefinitionProvider, WorkBucketType workBucket, OperationResult result) throws SchemaException, ObjectNotFoundException { Context ctx = createContext(workerTask.getOid(), () -> true, result); TaskWorkManagementType config = ctx.getWorkStateConfiguration(); AbstractWorkSegmentationType bucketsConfig = TaskWorkStateTypeUtil.getWorkSegmentationConfiguration(config); WorkBucketContentHandler handler = handlerFactory.getHandler(workBucket.getContent()); List<ObjectFilter> conjunctionMembers = new ArrayList<>( handler.createSpecificFilters(workBucket, bucketsConfig, type, itemDefinitionProvider)); if (conjunctionMembers.isEmpty()) { return query; } ObjectFilter existingFilter = query != null ? query.getFilter() : null; if (existingFilter != null) { conjunctionMembers.add(existingFilter); } ObjectFilter updatedFilter; if (conjunctionMembers.isEmpty()) { updatedFilter = null; } else if (conjunctionMembers.size() == 1) { updatedFilter = conjunctionMembers.get(0); } else { updatedFilter = prismContext.queryFactory().createAnd(conjunctionMembers); } ObjectQuery updatedQuery = query != null ? query.clone() : prismContext.queryFactory().createQuery(); updatedQuery.setFilter(updatedFilter); // TODO update sorting criteria return updatedQuery; }
@Test public void test120AndEmpty() throws Exception { System.out.println("===[ test120AndEmpty ]==="); // GIVEN PrismContext prismContext = PrismTestUtil.getPrismContext(); // WHEN ObjectFilter filter = prismContext.queryFactory().createAnd(); System.out.println("Original filter:\n" + filter.debugDump()); // THEN ObjectFilter simplified = ObjectQueryUtil.simplify(filter, prismContext); System.out.println("Simplified filter:\n" + DebugUtil.debugDump(simplified)); assertTrue("Wrong simplified filter: " + simplified, simplified == null || simplified instanceof AllFilter); }
attributeFilter.add(prismContext.queryFactory().createOr(subFilters)); } else if (f instanceof AndFilter) { attributeFilter.add(prismContext.queryFactory().createAnd(subFilters)); } else { throw new IllegalArgumentException(
private ObjectQuery addFilter(ObjectQuery query, ObjectFilter additionalFilter) { ObjectQuery newQuery; QueryFactory queryFactory = prismContext.queryFactory(); if (query == null) { newQuery = queryFactory.createQuery(additionalFilter); } else { newQuery = query.clone(); if (query.getFilter() == null) { newQuery.setFilter(additionalFilter); } else { newQuery.setFilter(queryFactory.createAnd(query.getFilter(), additionalFilter)); } } return newQuery; }
private ObjectQuery createQueryForOpenWorkItems(ObjectQuery baseWorkItemsQuery, MidPointPrincipal principal, boolean notDecidedOnly) throws SchemaException { ObjectFilter reviewerAndEnabledFilter = getReviewerAndEnabledFilterForWI(principal); ObjectFilter filter; if (notDecidedOnly) { ObjectFilter noResponseFilter = prismContext.queryFor(AccessCertificationWorkItemType.class) .item(F_OUTPUT, F_OUTCOME).isNull() .buildFilter(); filter = prismContext.queryFactory().createAnd(reviewerAndEnabledFilter, noResponseFilter); } else { filter = reviewerAndEnabledFilter; } return addFilter(baseWorkItemsQuery, filter); }
List<ObjectFilter> attributeFilter = createAttributeQueryInternal(conditions); if (attributeFilter.size() > 1) { attributeQuery = queryFactory.createQuery(queryFactory.createAnd(attributeFilter)); } else if (attributeFilter.size() < 1) { LOGGER.trace("No attribute filter defined in the query.");
private <C extends Containerable, O extends ObjectType> ObjectQuery preProcessSubobjectQuerySecurity(Class<C> containerType, Class<O> objectType, ObjectQuery origQuery, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { // Search containers is an operation on one object. Therefore even if it works with a search filter, it requires GET authorizations ObjectFilter secParentFilter = securityEnforcer.preProcessObjectFilter(ModelAuthorizationAction.AUTZ_ACTIONS_URLS_GET, null, objectType, null, null, null, null, task, result); if (secParentFilter == null || secParentFilter instanceof AllFilter) { return origQuery; // no need to update the query } ObjectFilter secChildFilter; if (secParentFilter instanceof NoneFilter) { secChildFilter = FilterCreationUtil.createNone(prismContext); } else { ObjectFilter origChildFilter = origQuery != null ? origQuery.getFilter() : null; ObjectFilter secChildFilterParentPart = prismContext.queryFactory().createExists(ItemName.fromQName(PrismConstants.T_PARENT), // fixme containerType, prismContext, secParentFilter); if (origChildFilter == null) { secChildFilter = secChildFilterParentPart; } else { secChildFilter = prismContext.queryFactory().createAnd(origChildFilter, secChildFilterParentPart); } } return updateObjectQuery(origQuery, secChildFilter); }
@Override protected ObjectQuery extendQuery(ObjectQuery query, ExpressionEvaluationContext params) throws SchemaException, ExpressionEvaluationException { RefinedObjectClassDefinition rAssocTargetDef = (RefinedObjectClassDefinition) params.getVariables().get(ExpressionConstants.VAR_ASSOCIATION_TARGET_OBJECT_CLASS_DEFINITION); if (rAssocTargetDef == null) { throw new ExpressionEvaluationException("No association target object class definition variable in "+ params.getContextDescription()+"; the expression may be used in a wrong place. It is only supposed to create an association."); } ObjectFilter resourceFilter = ObjectQueryUtil.createResourceFilter(rAssocTargetDef.getResourceOid(), getPrismContext()); ObjectFilter objectClassFilter = ObjectQueryUtil.createObjectClassFilter(rAssocTargetDef.getObjectClassDefinition().getTypeName(), getPrismContext()); ObjectFilter extendedFilter = getPrismContext().queryFactory().createAnd(resourceFilter, objectClassFilter, query.getFilter()); query.setFilter(extendedFilter); return query; }
@Test public void test020QueryByExecutionStatus() throws Exception { final String TEST_NAME = "test020QueryByExecutionStatus"; final OperationResult result = createResult(TEST_NAME, LOGGER); taskManager.createTaskInstance((PrismObject<TaskType>) (PrismObject) addObjectFromFile(taskFilename(TEST_NAME)), result); ObjectFilter filter1 = prismContext.queryFor(TaskType.class).item(TaskType.F_EXECUTION_STATUS).eq(TaskExecutionStatusType.WAITING).buildFilter(); ObjectFilter filter2 = prismContext.queryFor(TaskType.class).item(TaskType.F_WAITING_REASON).eq(TaskWaitingReasonType.OTHER).buildFilter(); ObjectFilter filter3 = prismContext.queryFactory().createAnd(filter1, filter2); List<PrismObject<TaskType>> prisms1 = repositoryService.searchObjects(TaskType.class, prismContext.queryFactory().createQuery(filter1), null, result); List<PrismObject<TaskType>> prisms2 = repositoryService.searchObjects(TaskType.class, prismContext.queryFactory().createQuery(filter2), null, result); List<PrismObject<TaskType>> prisms3 = repositoryService.searchObjects(TaskType.class, prismContext.queryFactory().createQuery(filter3), null, result); assertFalse("There were no tasks with executionStatus == WAITING found", prisms1.isEmpty()); assertFalse("There were no tasks with waitingReason == OTHER found", prisms2.isEmpty()); assertFalse("There were no tasks with executionStatus == WAITING and waitingReason == OTHER found", prisms3.isEmpty()); }
ObjectQuery evaluatedRefQuery = ExpressionUtil.evaluateQueryExpressions(refQuery, variables, expressionFactory, prismContext, desc, ctx.getTask(), result); ObjectFilter baseFilter = ObjectQueryUtil.createResourceAndObjectClassFilter(ctx.getResource().getOid(), objectClass, prismContext); ObjectFilter filter = prismContext.queryFactory().createAnd(baseFilter, evaluatedRefQuery.getFilter()); ObjectQuery query = prismContext.queryFactory().createQuery(filter);
query = ObjectQueryUtil.createResourceQuery(RESOURCE_DUMMY_OID, prismContext); if (attrFilter != null) { query.setFilter(prismContext.queryFactory().createAnd(query.getFilter(), attrFilter));