private ObjectFilterExpressionEvaluator createFilterEvaluator(MidPointPrincipal principal, String objectTargetDesc, String autzHumanReadableDesc, Task task, OperationResult result) { return filter -> { if (filter == null) { return null; } ExpressionVariables variables = new ExpressionVariables(); PrismObject<UserType> subject = null; if (principal != null) { subject = principal.getUser().asPrismObject(); } variables.addVariableDefinition(ExpressionConstants.VAR_SUBJECT, subject); return ExpressionUtil.evaluateFilterExpressions(filter, variables, expressionFactory, prismContext, "expression in " + objectTargetDesc + " in authorization " + autzHumanReadableDesc, task, result); }; }
private ObjectFilter evaluateExpressionAssertFilter(String filename, String input, Class<? extends ObjectFilter> expectedType, Task task, OperationResult result) throws SchemaException, IOException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { PrismContext prismContext = PrismTestUtil.getPrismContext(); SearchFilterType filterType = PrismTestUtil.parseAtomicValue(new File(TEST_DIR, filename), SearchFilterType.COMPLEX_TYPE); ObjectFilter filter = prismContext.getQueryConverter().createObjectFilter(UserType.class, filterType); Map<QName, Object> params = new HashMap<>(); PrismPropertyValue<String> pval = null; if (input != null) { pval = prismContext.itemFactory().createPropertyValue(input); } params.put(ExpressionConstants.VAR_INPUT, pval); ExpressionVariables variables = new ExpressionVariables(); variables.addVariableDefinitions(params); // WHEN ObjectFilter evaluatedFilter = ExpressionUtil.evaluateFilterExpressions(filter, variables, expressionFactory, prismContext, "evaluating filter with null value not allowed", task, result); // THEN display("Evaluated filter", evaluatedFilter); AssertJUnit.assertTrue("Expression should be evaluated to "+expectedType+", but was "+evaluatedFilter, expectedType.isAssignableFrom(evaluatedFilter.getClass())); return evaluatedFilter; }
ResourceType.class); LOGGER.info("Orig filter {}", origFilter); ObjectFilter evaluatedFilter = ExpressionUtil.evaluateFilterExpressions(origFilter, variables, getMappingFactory().getExpressionFactory(), getPrismContext(), " evaluating resource filter expression ", task, result);
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(); } }
@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(); } }