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); }
private boolean sourcesChanged() { for (Source<?,?> source: sources) { if (source.getDelta() != null) { return true; } } return false; }
private ExpressionVariables getAssignmentEvaluationVariables() { ExpressionVariables variables = new ExpressionVariables(); variables.addVariableDefinition(ExpressionConstants.VAR_LOGIN_MODE, loginMode); // e.g. AssignmentEvaluator itself, model context, etc (when needed) return variables; }
private <O extends ObjectType> boolean checkExpression(String generatedValue, ExpressionType checkExpression, AbstractValuePolicyOriginResolver<O> originResolver, String shortDesc, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { ExpressionVariables variables = new ExpressionVariables(); variables.addVariableDefinition(ExpressionConstants.VAR_INPUT, generatedValue); variables.addVariableDefinition(ExpressionConstants.VAR_OBJECT, originResolver == null ? null : originResolver.getObject()); PrismPropertyValue<Boolean> output = ExpressionUtil.evaluateCondition(variables, checkExpression, expressionFactory, shortDesc, task, result); return ExpressionUtil.getBooleanConditionOutput(output); }
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); }
public Builder<V, D> addVariableDefinition(QName name, Object value) { variables.addVariableDefinition(name, value); return this; }
public ExpressionEvaluationContext shallowClone() { ExpressionEvaluationContext clone = new ExpressionEvaluationContext(sources, variables, contextDescription, task, result); clone.skipEvaluationMinus = this.skipEvaluationMinus; clone.skipEvaluationPlus = this.skipEvaluationPlus; clone.valuePolicyResolver = this.valuePolicyResolver; clone.expressionFactory = this.expressionFactory; clone.defaultSource = this.defaultSource; clone.refinedObjectClassDefinition = this.refinedObjectClassDefinition; clone.mappingQName = this.mappingQName; clone.additionalConvertor = this.additionalConvertor; clone.variableProducer = this.variableProducer; return clone; }
public Builder<V, D> addVariableDefinitions(Map<QName, Object> extraVariables) { variables.addVariableDefinitions(extraVariables); return this; }
public CustomFunctions(FunctionLibraryType library, ExpressionFactory expressionFactory, OperationResult result, Task task) { this.library = library; this.expressionFactory = expressionFactory; this.prismContext = expressionFactory.getPrismContext(); this.result = result; this.task = task; }
@Override public String toString() { return "Expression(expressionType=" + expressionType + ", outputDefinition=" + outputDefinition + ": " + shortDebugDump() + ")"; }
public static boolean hasExplicitTarget(List<MappingType> mappingTypes) { for (MappingType mappingType : mappingTypes) { if (hasExplicitTarget(mappingType)) { return true; } } return false; }
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; }
public <V extends PrismValue,D extends ItemDefinition> Expression<V,D> makeExpression(ExpressionType expressionType, D outputDefinition, String shortDesc, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException { ExpressionIdentifier eid = new ExpressionIdentifier(expressionType, outputDefinition); Expression<V,D> expression = (Expression<V,D>) cache.get(eid); if (expression == null) { expression = createExpression(expressionType, outputDefinition, shortDesc, task, result); cache.put(eid, expression); } return expression; }
private ExpressionEvaluator<V,D> createDefaultEvaluator(ExpressionFactory factory, String contextDescription, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException { ExpressionEvaluatorFactory evaluatorFactory = factory.getDefaultEvaluatorFactory(); if (evaluatorFactory == null) { throw new SystemException("Internal error: No default expression evaluator factory"); } return evaluatorFactory.createEvaluator(null, outputDefinition, factory, contextDescription, task, result); }
private String formatVariables(ExpressionVariables variables) { if (variables == null) { return "null"; } return variables.formatVariables(); }
public static ObjectFilter evaluateFilterExpressions(ObjectFilter origFilter, ExpressionVariables variables, ExpressionFactory expressionFactory, PrismContext prismContext, String shortDesc, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { if (origFilter == null) { return null; } return evaluateFilterExpressionsInternal(origFilter, variables, expressionFactory, prismContext, shortDesc, task, result); }
@Override public String debugDump() { return debugDump(0); }
public AssociationSearchQueryKey(Class<? extends ObjectType> type, ObjectQuery query, ObjectSearchStrategyType searchStrategy, ExpressionEvaluationContext params, PrismContext prismContext) { super(type, query, searchStrategy, prismContext); mappingName = params != null ? params.getMappingQName() : null; }
@Override public String toString() { return "Source(" + shortDump() + ")"; }
protected ExpressionVariables getDefaultVariables(Message message, Event event) throws UnsupportedEncodingException { ExpressionVariables variables = new ExpressionVariables(); variables.addVariableDefinition(SchemaConstants.C_MESSAGE, message); variables.addVariableDefinition(SchemaConstants.C_EVENT, event); return variables; }