ObjectQuery query = prismContext.queryFactory().createQuery(); if (searchFilter != null) { query.setFilter(getQueryConverter().parseFilter(searchFilter, objectClass));
public static ObjectQuery createObjectQuery(FileReference ref, NinjaContext context, Class<? extends ObjectType> objectClass) throws IOException, SchemaException { if (ref == null) { return null; } String filterStr = ref.getValue(); if (ref.getReference() != null) { File file = ref.getReference(); filterStr = FileUtils.readFileToString(file, context.getCharset()); } PrismContext prismContext = context.getPrismContext(); PrismParserNoIO parser = prismContext.parserFor(filterStr); RootXNode root = parser.parseToXNode(); ObjectFilter filter = context.getQueryConverter().parseFilter(root.toMapXNode(), objectClass); return prismContext.queryFactory().createQuery(filter); }
LOGGER.info("Expression variables for filter evaluation: {}", variables); ObjectFilter origFilter = getPrismContext().getQueryConverter().parseFilter(getConstructionType().getResourceRef().getFilter(), ResourceType.class); LOGGER.info("Orig filter {}", origFilter);
private <O extends ObjectType, F extends ObjectType> List<ObjectReferenceType> resolveReferenceFromFilter(Class<O> clazz, SearchFilterType filter, String sourceDescription, LensContext<F> lensContext, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { ExpressionEnvironment<F> env = new ExpressionEnvironment<>(); env.setLensContext(lensContext); env.setCurrentResult(result); env.setCurrentTask(task); ModelExpressionThreadLocalHolder.pushExpressionEnvironment(env); try { PrismObject<SystemConfigurationType> systemConfiguration = systemObjectCache.getSystemConfiguration(result); ExpressionVariables variables = ModelImplUtils.getDefaultExpressionVariables(getFocusObjectable(lensContext), null, null, systemConfiguration.asObjectable()); ObjectFilter origFilter = prismContext.getQueryConverter().parseFilter(filter, clazz); ObjectFilter evaluatedFilter = ExpressionUtil .evaluateFilterExpressions(origFilter, variables, mappingFactory.getExpressionFactory(), prismContext, " evaluating approverRef filter expression ", task, result); if (evaluatedFilter == null) { throw new SchemaException("Filter could not be evaluated in approverRef in "+sourceDescription+"; original filter = "+origFilter); } SearchResultList<PrismObject<O>> targets = repositoryService.searchObjects(clazz, prismContext.queryFactory().createQuery(evaluatedFilter), null, result); return targets.stream() .map(object -> ObjectTypeUtil.createObjectRef(object, prismContext)) .collect(Collectors.toList()); } finally { ModelExpressionThreadLocalHolder.popExpressionEnvironment(); } }
ObjectFilter filter = prismContext.getQueryConverter().parseFilter(constraint.getFilter(), object.asObjectable().getClass()); if (!filter.match(object.getValue(), matchingRuleRegistry)) { return null;
static boolean oidMatches(ObjectReferenceType targetRef, EvaluatedAssignmentTargetImpl assignmentTarget, PrismContext prismContext, MatchingRuleRegistry matchingRuleRegistry, String context) throws SchemaException { if (targetRef == null) { return true; // this means we rely on comparing relations } if (assignmentTarget.getOid() == null) { return false; // shouldn't occur } if (targetRef.getOid() != null) { return assignmentTarget.getOid().equals(targetRef.getOid()); } if (targetRef.getResolutionTime() == EvaluationTimeType.RUN) { SearchFilterType filterType = targetRef.getFilter(); if (filterType == null) { throw new SchemaException("No filter in " + context); } QName typeQName = targetRef.getType(); @SuppressWarnings("rawtypes") PrismObjectDefinition objDef = prismContext.getSchemaRegistry().findObjectDefinitionByType(typeQName); ObjectFilter filter = prismContext.getQueryConverter().parseFilter(filterType, objDef); PrismObject<? extends AssignmentHolderType> target = assignmentTarget.getTarget(); return filter.match(target.getValue(), matchingRuleRegistry); } else { throw new SchemaException("No OID in " + context); } }
ObjectFilter objectFilter = prismContext.getQueryConverter().parseFilter(filter, targetClass); virtualAssignmenetSpecification.setFilter(objectFilter);
SearchFilterType filterType = patternType.getFilter(); if (filterType != null) { ObjectFilter filter = prismContext.getQueryConverter().parseFilter(filterType, rAccountDef.getObjectDefinition()); resourceObjectPattern.addFilter(filter); return resourceObjectPattern;
@NotNull private <O extends ObjectType> List<PrismObject<O>> resolveTargetsFromFilter(Class<O> targetClass, SearchFilterType filter, AssignmentPathSegmentImpl segment, EvaluationContext ctx) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException{ ModelExpressionThreadLocalHolder.pushExpressionEnvironment(new ExpressionEnvironment<>(lensContext, null, ctx.task, ctx.result)); try { PrismObject<SystemConfigurationType> systemConfiguration = systemObjectCache.getSystemConfiguration(ctx.result); ExpressionVariables variables = ModelImplUtils.getDefaultExpressionVariables(segment.source, null, null, systemConfiguration.asObjectable()); variables.addVariableDefinition(ExpressionConstants.VAR_SOURCE, segment.getOrderOneObject()); AssignmentPathVariables assignmentPathVariables = LensUtil.computeAssignmentPathVariables(ctx.assignmentPath); if (assignmentPathVariables != null) { ModelImplUtils.addAssignmentPathVariables(assignmentPathVariables, variables); } variables.addVariableDefinitions(getAssignmentEvaluationVariables()); ObjectFilter origFilter = prismContext.getQueryConverter().parseFilter(filter, targetClass); ObjectFilter evaluatedFilter = ExpressionUtil.evaluateFilterExpressions(origFilter, variables, getMappingFactory().getExpressionFactory(), prismContext, " evaluating resource filter expression ", ctx.task, ctx.result); if (evaluatedFilter == null) { throw new SchemaException("The OID is null and filter could not be evaluated in assignment targetRef in "+segment.source); } return repository.searchObjects(targetClass, prismContext.queryFactory().createQuery(evaluatedFilter), null, ctx.result); // we don't check for no targets here; as we don't care for referential integrity } finally { ModelExpressionThreadLocalHolder.popExpressionEnvironment(); } }
SearchFilterType filter = prismContext.parserFor(query).parseRealValue(SearchFilterType.class); LOGGER.trace("filter {}", filter); ObjectFilter f = prismContext.getQueryConverter().parseFilter(filter, UserType.class); LOGGER.trace("f {}", f.debugDump()); if (!(f instanceof TypeFilter)) {
unresolvedObjectQuery = prismContext.queryFactory().createQuery(); try { ObjectFilter filter = prismContext.getQueryConverter().parseFilter(searchExpression.getSearchFilter(), objectClass); unresolvedObjectQuery.setFilter(filter); } catch (SchemaException e) {
try{ PrismObjectDefinition objDef = prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(type); objFilter = prismContext.getQueryConverter().parseFilter(filter, objDef); } catch (SchemaException ex){ LOGGER.error("Failed to convert object filter from filter because of: "+ ex.getMessage() + "; filter: " + filter.debugDump(), ex);
assertNotNull("No filter in connectorRef value", filter); if (!isSimple) { ObjectFilter objectFilter = prismContext.getQueryConverter().parseFilter(filter, ConnectorType.class); assertTrue("Wrong kind of filter: " + objectFilter, objectFilter instanceof EqualFilter); EqualFilter equalFilter = (EqualFilter) objectFilter;
ObjectFilter collectionFilter = null; if (collectionFilterType != null) { collectionFilter = prismContext.getQueryConverter().parseFilter(collectionFilterType, targetTypeClass);