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 ObjectQuery evaluateQueryExpressions(ObjectQuery query, ShadowType currentShadow, ResourceType resource, SystemConfigurationType configuration, String shortDesc, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { ExpressionVariables variables = ModelImplUtils.getDefaultExpressionVariables(null, currentShadow, resource, configuration); return ExpressionUtil.evaluateQueryExpressions(query, variables, expressionFactory, prismContext, shortDesc, task, result); }
private static Object variableFromPathExpression(HashMap<String, Object> resultingVariables, JAXBElement<?> expressionEvaluator, VariableResolutionContext ctx, String shortDesc, OperationResult result) throws SchemaException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException, ExpressionEvaluationException { if (!(expressionEvaluator.getValue() instanceof ItemPathType)) { throw new IllegalArgumentException("Path expression: expected ItemPathType but got " + expressionEvaluator.getValue()); } ItemPath itemPath = ctx.prismContext.toPath((ItemPathType) expressionEvaluator.getValue()); return ExpressionUtil.resolvePath(itemPath, createVariables(resultingVariables), false, null, ctx.objectResolver, shortDesc, ctx.task, result); }
@Override protected ObjectQuery preProcessQuery(ObjectQuery query, Task coordinatorTask, OperationResult opResult) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { // TODO consider which variables should go here (there's no focus, shadow, resource - only configuration) if (ExpressionUtil.hasExpressions(query.getFilter())) { PrismObject<SystemConfigurationType> configuration = systemObjectCache.getSystemConfiguration(opResult); ExpressionVariables variables = ModelImplUtils.getDefaultExpressionVariables(null, null, null, configuration != null ? configuration.asObjectable() : null); try { ExpressionEnvironment<?> env = new ExpressionEnvironment<>(coordinatorTask, opResult); ModelExpressionThreadLocalHolder.pushExpressionEnvironment(env); query = ExpressionUtil.evaluateQueryExpressions(query, variables, expressionFactory, prismContext, "evaluate query expressions", coordinatorTask, opResult); } finally { ModelExpressionThreadLocalHolder.popExpressionEnvironment(); } } return query; }
private <F extends AssignmentHolderType> boolean shouldTransition(LensContext<F> context, LifecycleStateTransitionType transitionType, String targetLifecycleState, Task task, OperationResult result) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException { ExpressionType conditionExpressionType = transitionType.getCondition(); if (conditionExpressionType == null) { return false; } String desc = "condition for transition to state "+targetLifecycleState+" for "+context.getFocusContext().getHumanReadableName(); ExpressionVariables variables = new ExpressionVariables(); variables.addVariableDefinition(ExpressionConstants.VAR_OBJECT, context.getFocusContext().getObjectNew()); // TODO: more variables? Expression<PrismPropertyValue<Boolean>,PrismPropertyDefinition<Boolean>> expression = expressionFactory.makeExpression( conditionExpressionType, ExpressionUtil.createConditionOutputDefinition(context.getPrismContext()) , desc, task, result); ExpressionEvaluationContext expressionContext = new ExpressionEvaluationContext(null , variables, desc, task, result); ExpressionEnvironment<?> env = new ExpressionEnvironment<>(context, null, task, result); PrismValueDeltaSetTriple<PrismPropertyValue<Boolean>> outputTriple = ModelExpressionThreadLocalHolder.evaluateExpressionInContext(expression, expressionContext, env); PrismPropertyValue<Boolean> expressionOutputValue = ExpressionUtil.getExpressionOutputValue(outputTriple, desc); return ExpressionUtil.getBooleanConditionOutput(expressionOutputValue); }
ExpressionType valueExpression = getExpression(expressionWrapper, shortDesc); Collection<String> expressionResult = evaluateStringExpression(variables, prismContext, valueExpression, expressionFactory, shortDesc, task, result); LOGGER.debug("Result of search filter expression was null or empty. Expression: {}", valueExpression); return createFilterForNoValue(filter, valueExpression, prismContext); if (expressionMissing(expressionWrapper, filter, shortDesc)) { return filter.clone(); ExpressionType valueExpression = getExpression(expressionWrapper, shortDesc); Collection<String> expressionResult = evaluateStringExpression(variables, prismContext, valueExpression, expressionFactory, shortDesc, task, result); if (expressionResult == null || expressionResult.isEmpty()) { LOGGER.debug("Result of search filter expression was null or empty. Expression: {}", valueExpression); return createFilterForNoValue(filter, valueExpression, prismContext); LogicalFilter evaluatedFilter = ((LogicalFilter) filter).cloneEmpty(); for (ObjectFilter condition : conditions) { ObjectFilter evaluatedSubFilter = evaluateFilterExpressionsInternal(condition, variables, expressionFactory, prismContext, shortDesc, task, result); evaluatedFilter.addCondition(evaluatedSubFilter); if (expressionMissing(expressionWrapper, filter, shortDesc)) { return valueFilter.clone();
public static PrismPropertyValue<Boolean> evaluateCondition(ExpressionVariables variables, ExpressionType expressionType, ExpressionFactory expressionFactory, String shortDesc, Task task, OperationResult parentResult) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException { ItemDefinition outputDefinition = expressionFactory.getPrismContext().definitionFactory().createPropertyDefinition( ExpressionConstants.OUTPUT_ELEMENT_NAME, DOMUtil.XSD_BOOLEAN); return (PrismPropertyValue<Boolean>) evaluateExpression(variables, outputDefinition, expressionType, expressionFactory, shortDesc, task, parentResult); }
ExpressionUtil.addActorVariable(newVariables, securityContextManager); boolean actorDefined = newVariables.get(ExpressionConstants.VAR_ACTOR) != null; Object resolvedValue = ExpressionUtil.resolvePath(itemPath, variables, false, null, objectResolver, contextDescription, task, result); newVariables.addVariableDefinition(varName, resolvedValue); } else {
public static <D extends ItemDefinition> Object convertToOutputValue(Long longValue, D outputDefinition, Protector protector) throws ExpressionEvaluationException, SchemaException { if (longValue == null) { return null; } QName outputType = outputDefinition.getTypeName(); if (outputType.equals(DOMUtil.XSD_INT)) { return longValue.intValue(); } else if (outputType.equals(DOMUtil.XSD_LONG)) { return longValue; } else { return convertToOutputValue(longValue.toString(), outputDefinition, protector); } }
PrismValueDeltaSetTriple<PrismPropertyValue<Boolean>> conditionTriple = evaluateCondition(assignmentCondition, assignmentType, segment.source, assignmentPathVariables, ctx); boolean condOld = ExpressionUtil.computeConditionResult(conditionTriple.getNonPositiveValues()); boolean condNew = ExpressionUtil.computeConditionResult(conditionTriple.getNonNegativeValues()); PlusMinusZero modeFromCondition = ExpressionUtil.computeConditionResultMode(condOld, condNew); if (modeFromCondition == null) { // removed "|| (condMode == PlusMinusZero.ZERO && !condNew)" as it is always false if (LOGGER.isTraceEnabled()) {
conditionExpression = ExpressionUtil.createCondition(expressionEvaluatorType.getCondition(), evaluationContext.getExpressionFactory(), "condition in " + contextDescription, task, result); } else { "condition in " + contextDescription, task, result); PrismValueDeltaSetTriple<PrismPropertyValue<Boolean>> triple = conditionExpression.evaluate(ctx); conditionResult = ExpressionUtil.computeConditionResult(triple.getNonNegativeValues()); } else { conditionResult = true;
evalResult = ExpressionUtil.convertValue(javaReturnType, additionalConvertor, resultWriter.toString(), protector, prismContext); } catch (IllegalArgumentException e) { throw new ExpressionEvaluationException(e.getMessage()+" in "+contextDescription, e); if (allowEmptyValues || !ExpressionUtil.isEmpty(evalResult)) { pvals.add((V) ExpressionUtil.convertToPrismValue(evalResult, outputDefinition, contextDescription, prismContext));
private boolean computeConditionResult(Collection<PrismPropertyValue<Boolean>> booleanPropertyValues) { if (mappingType.getCondition() == null) { // If condition is not present at all consider it to be true return true; } return ExpressionUtil.computeConditionResult(booleanPropertyValues); }
private <T> T convertScalarResult(Class<T> expectedType, Function<Object, Object> additionalConvertor, Object rawValue, String contextDescription) throws ExpressionEvaluationException { try { T convertedValue = ExpressionUtil.convertValue(expectedType, additionalConvertor, rawValue, protector, prismContext); return convertedValue; } catch (IllegalArgumentException e) { throw new ExpressionEvaluationException(e.getMessage() + " in " + contextDescription, e); } }
public static Expression<PrismPropertyValue<Boolean>,PrismPropertyDefinition<Boolean>> createCondition( ExpressionType conditionExpressionType, ExpressionFactory expressionFactory, String shortDesc, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException { return expressionFactory.makeExpression(conditionExpressionType, createConditionOutputDefinition(expressionFactory.getPrismContext()), shortDesc, task, result); }
public void init(ExpressionFactory expressionFactory) throws SchemaException, ObjectNotFoundException { ExpressionType conditionType = setDefinitionType.getCondition(); condition = ExpressionUtil.createCondition(conditionType, expressionFactory, shortDesc, task, result); }
private Object executeScript(ScriptExpression scriptExpression, Object input, Map<String, Object> externalVariables, ExecutionContext context, OperationResult result) throws ExpressionEvaluationException, ObjectNotFoundException, SchemaException, CommunicationException, ConfigurationException, SecurityViolationException { ExpressionVariables variables = new ExpressionVariables(); variables.addVariableDefinition(ExpressionConstants.VAR_INPUT, input); variables.addVariableDefinition(ExpressionConstants.VAR_PRISM_CONTEXT, prismContext); ExpressionUtil.addActorVariable(variables, securityContextManager); externalVariables.forEach((k, v) -> variables.addVariableDefinition(new QName(NS_C, k), cloneIfNecessary(k, v))); List<?> rv = ModelImplUtils.evaluateScript(scriptExpression, null, variables, true, "in '"+NAME+"' action", context.getTask(), result); if (rv == null || rv.size() == 0) { return null; } else if (rv.size() == 1) { return rv.get(0); } else { return rv; // shouldn't occur; would cause problems } }
private static <V extends PrismValue> V evaluateExpression(ExpressionVariables variables, PrismContext prismContext, ExpressionType expressionType, ObjectFilter filter, ExpressionFactory expressionFactory, String shortDesc, Task task, OperationResult parentResult) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { // TODO refactor after new query engine is implemented ItemDefinition outputDefinition = null; if (filter instanceof ValueFilter) { outputDefinition = ((ValueFilter) filter).getDefinition(); } if (outputDefinition == null) { outputDefinition = prismContext.definitionFactory().createPropertyDefinition(ExpressionConstants.OUTPUT_ELEMENT_NAME, DOMUtil.XSD_STRING); } return (V) evaluateExpression(variables, outputDefinition, expressionType, expressionFactory, shortDesc, task, parentResult); // String expressionResult = // expressionHandler.evaluateExpression(currentShadow, valueExpression, // shortDesc, result); }
@Override public PrismValueDeltaSetTriple<V> evaluate(ExpressionEvaluationContext context) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException { String constName = constEvaluatorType.getValue(); String stringValue = constantsManager.getConstantValue(constName); Item<V, D> output = outputDefinition.instantiate(); Object value = ExpressionUtil.convertToOutputValue(stringValue, outputDefinition, protector); if (output instanceof PrismProperty) { ((PrismProperty<Object>) output).addRealValue(value); } else { throw new UnsupportedOperationException( "Can only generate values of property, not " + output.getClass()); } return ItemDeltaUtil.toDeltaSetTriple(output, null, prismContext); }
PrismValueDeltaSetTriple<PrismPropertyValue<Boolean>> conditionTriple = evaluateCondition(roleCondition, null, segment.source, assignmentPathVariables, ctx); boolean condOld = ExpressionUtil.computeConditionResult(conditionTriple.getNonPositiveValues()); boolean condNew = ExpressionUtil.computeConditionResult(conditionTriple.getNonNegativeValues()); PlusMinusZero modeFromCondition = ExpressionUtil.computeConditionResultMode(condOld, condNew); if (modeFromCondition == null) { // removed "|| (condMode == PlusMinusZero.ZERO && !condNew)" because it's always false LOGGER.trace("Skipping evaluation of {} because of condition result ({} -> {}: null)",