public static <T> PrismValueDeltaSetTriple<PrismPropertyValue<T>> evaluateExpressionInContext( Expression<PrismPropertyValue<T>,PrismPropertyDefinition<T>> expression, ExpressionEvaluationContext eeContext, ExpressionEnvironment<?> env) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException { ModelExpressionThreadLocalHolder.pushExpressionEnvironment(env); PrismValueDeltaSetTriple<PrismPropertyValue<T>> exprResultTriple; try { exprResultTriple = expression.evaluate(eeContext); } finally { ModelExpressionThreadLocalHolder.popExpressionEnvironment(); } return exprResultTriple; } }
@Override public String toString() { return "Expression(expressionType=" + expressionType + ", outputDefinition=" + outputDefinition + ": " + shortDebugDump() + ")"; }
private <V extends PrismValue,D extends ItemDefinition> Expression<V,D> createExpression(ExpressionType expressionType, D outputDefinition, String shortDesc, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException { Expression<V,D> expression = new Expression<>(expressionType, outputDefinition, objectResolver, securityContextManager, prismContext); expression.parse(this, shortDesc, task, result); return expression; }
private void traceSuccess(ExpressionEvaluationContext context, ExpressionVariables processedVariables, PrismValueDeltaSetTriple<V> outputTriple) { if (!isTrace()) { return; } StringBuilder sb = new StringBuilder(); sb.append("Expression trace:\n"); appendTraceHeader(sb, context, processedVariables); sb.append("\nResult: "); if (outputTriple == null) { sb.append("null"); } else { sb.append(outputTriple.toHumanReadableString()); } appendTraceFooter(sb); trace(sb.toString()); }
public void parse(ExpressionFactory factory, String contextDescription, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException { if (expressionType == null) { evaluators.add(createDefaultEvaluator(factory, contextDescription, task, result)); return; } if (expressionType.getExpressionEvaluator() == null /* && expressionType.getSequence() == null */) { throw new SchemaException("No evaluator was specified in "+contextDescription); } if (expressionType.getExpressionEvaluator() != null) { ExpressionEvaluator evaluator = createEvaluator(expressionType.getExpressionEvaluator(), factory, contextDescription, task, result); evaluators.add(evaluator); } if (evaluators.isEmpty()) { evaluators.add(createDefaultEvaluator(factory, contextDescription, task, result)); } }
private void traceFailure(ExpressionEvaluationContext context, ExpressionVariables processedVariables, Throwable e) { LOGGER.error("Error evaluating expression in {}: {}-{}", new Object[]{context.getContextDescription(), e.getMessage(), e}); if (!isTrace()) { return; } StringBuilder sb = new StringBuilder(); sb.append("Expression failure:\n"); appendTraceHeader(sb, context, processedVariables); sb.append("\nERROR: ").append(e.getClass().getSimpleName()).append(": ").append(e.getMessage()); appendTraceFooter(sb); trace(sb.toString()); }
public static <T> PrismValueDeltaSetTriple<PrismPropertyValue<T>> evaluateExpressionInContext(Expression<PrismPropertyValue<T>, PrismPropertyDefinition<T>> expression, ExpressionEvaluationContext eeContext, Task task, OperationResult result) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException { ModelExpressionThreadLocalHolder.pushExpressionEnvironment(new ExpressionEnvironment<>(task, result)); try { return expression.evaluate(eeContext); } finally { ModelExpressionThreadLocalHolder.popExpressionEnvironment(); } }
private void appendTraceHeader(StringBuilder sb) { sb.append("---[ MAPPING "); if (mappingType.getName() != null) { sb.append("'").append(mappingType.getName()).append("' "); } sb.append(" in "); sb.append(contextDescription); sb.append("]---------------------------"); MappingStrengthType strength = getStrength(); if (strength != null) { sb.append("\nStregth: ").append(strength); } for (Source<?,?> source: sources) { sb.append("\n"); source.mediumDump(sb); } sb.append("\nTarget: ").append(MiscUtil.toString(outputDefinition)); sb.append("\nExpression: "); if (expression == null) { sb.append("null"); } else { sb.append(expression.shortDebugDump()); } }
public static PrismValueDeltaSetTriple<PrismReferenceValue> evaluateRefExpressionInContext(Expression<PrismReferenceValue, PrismReferenceDefinition> expression, ExpressionEvaluationContext eeContext, Task task, OperationResult result) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException { ModelExpressionThreadLocalHolder.pushExpressionEnvironment(new ExpressionEnvironment<>(task, result)); try { return expression.evaluate(eeContext); } finally { ModelExpressionThreadLocalHolder.popExpressionEnvironment(); } }
private void appendTraceHeader(StringBuilder sb, ExpressionEvaluationContext context, ExpressionVariables processedVariables) { sb.append("---[ EXPRESSION in "); sb.append(context.getContextDescription()); sb.append("]---------------------------"); sb.append("\nSources:"); Collection<Source<?,?>> sources = context.getSources(); if (sources == null) { sb.append(" null"); } else { for (Source<?,?> source: sources) { sb.append("\n"); sb.append(source.debugDump(1)); } } sb.append("\nVariables:"); if (processedVariables == null) { sb.append(" null"); } else { sb.append("\n"); sb.append(processedVariables.debugDump(1)); } sb.append("\nOutput definition: ").append(MiscUtil.toString(outputDefinition)); sb.append("\nEvaluators: "); sb.append(shortDebugDump()); }
public static PrismValueDeltaSetTriple<?> evaluateAnyExpressionInContext(Expression<?, ?> expression, ExpressionEvaluationContext context, Task task, OperationResult result) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException { ModelExpressionThreadLocalHolder.pushExpressionEnvironment(new ExpressionEnvironment<>(task, result)); try { return expression.evaluate(context); } finally { ModelExpressionThreadLocalHolder.popExpressionEnvironment(); } }
public static <V extends PrismValue, D extends ItemDefinition> V evaluateExpression( ExpressionVariables variables, D outputDefinition, ExpressionType expressionType, ExpressionFactory expressionFactory, String shortDesc, Task task, OperationResult parentResult) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException { Expression<V, D> expression = expressionFactory.makeExpression(expressionType, outputDefinition, shortDesc, task, parentResult); ExpressionEvaluationContext context = new ExpressionEvaluationContext(null, variables, shortDesc, task, parentResult); PrismValueDeltaSetTriple<V> outputTriple = expression.evaluate(context); LOGGER.trace("Result of the expression evaluation: {}", outputTriple); return getExpressionOutputValue(outputTriple, shortDesc); }
PrismValueDeltaSetTriple<PrismPropertyValue<T>> expressionOutputTriple = expression.evaluate(expressionContext); Collection<PrismPropertyValue<T>> expressionOutputValues = expressionOutputTriple.getNonNegativeValues(); if (expressionOutputValues != null && !expressionOutputValues.isEmpty()) {
public static Collection<String> evaluateStringExpression(ExpressionVariables variables, PrismContext prismContext, ExpressionType expressionType, ExpressionFactory expressionFactory, String shortDesc, Task task, OperationResult parentResult) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException { MutablePrismPropertyDefinition<String> outputDefinition = prismContext.definitionFactory().createPropertyDefinition( ExpressionConstants.OUTPUT_ELEMENT_NAME, DOMUtil.XSD_STRING); outputDefinition.setMaxOccurs(-1); Expression<PrismPropertyValue<String>, PrismPropertyDefinition<String>> expression = expressionFactory .makeExpression(expressionType, outputDefinition, shortDesc, task, parentResult); ExpressionEvaluationContext context = new ExpressionEvaluationContext(null, variables, shortDesc, task, parentResult); PrismValueDeltaSetTriple<PrismPropertyValue<String>> outputTriple = expression.evaluate(context); LOGGER.trace("Result of the expression evaluation: {}", outputTriple); if (outputTriple == null) { return null; } Collection<PrismPropertyValue<String>> nonNegativeValues = outputTriple.getNonNegativeValues(); if (nonNegativeValues == null || nonNegativeValues.isEmpty()) { return null; } return PrismValueCollectionsUtil.getRealValuesOfCollection((Collection) nonNegativeValues); // return nonNegativeValues.iterator().next(); }
PrismValueDeltaSetTriple<V> outputTriple = expression.evaluate(context);
private <O extends ObjectType> Collection<PrismValue> evaluateValueExpression(PrismObject<O> objectLeft, PrismObject<O> objectRight, String side, PrismValue origValue, Expression<PrismValue, ItemDefinition> valueExpression, Task task, OperationResult result) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException { ExpressionVariables variables = new ExpressionVariables(); variables.addVariableDefinition(ExpressionConstants.VAR_SIDE, side); variables.addVariableDefinition(ExpressionConstants.VAR_OBJECT_LEFT, side); variables.addVariableDefinition(ExpressionConstants.VAR_OBJECT_RIGHT, side); variables.addVariableDefinition(ExpressionConstants.VAR_INPUT, origValue); variables.addVariableDefinition(ExpressionConstants.VAR_VALUE, origValue); ExpressionEvaluationContext exprContext = new ExpressionEvaluationContext(null, variables, "for value "+origValue, task, result); PrismValueDeltaSetTriple<PrismValue> triple = valueExpression.evaluate(exprContext); if (triple == null) { return null; } return triple.getNonNegativeValues(); }
private boolean evalCondition(Object value) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException { ExpressionVariables variables = new ExpressionVariables(); variables.addVariableDefinition(ExpressionConstants.VAR_INPUT, value); if (additionalVariableName != null) { variables.addVariableDefinition(additionalVariableName, value); } if (additionalVariables != null) { variables.addVariableDefinitions(additionalVariables, variables.keySet()); } ExpressionEvaluationContext context = new ExpressionEvaluationContext(null, variables, shortDesc, task, result); PrismValueDeltaSetTriple<PrismPropertyValue<Boolean>> outputTriple = condition.evaluate(context); if (outputTriple == null) { return false; } return ExpressionUtil.computeConditionResult(outputTriple.getNonNegativeValues()); }
PrismValueDeltaSetTriple<PrismPropertyValue<String>> outputTriple = expression.evaluate(context);
return expression.evaluate(context);
ExpressionEvaluationContext ctx = new ExpressionEvaluationContext(null, scriptVariables, "condition in " + contextDescription, task, result); PrismValueDeltaSetTriple<PrismPropertyValue<Boolean>> triple = conditionExpression.evaluate(ctx); conditionResult = ExpressionUtil.computeConditionResult(triple.getNonNegativeValues()); } else {