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; }
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()); }
private void resolveEntitlement(PrismContainerValue<ShadowAssociationType> value, LensProjectionContext projContext, ExpressionVariables variables) { LOGGER.trace("Producing value {} ", value); PrismObject<ShadowType> entitlement = projContext.getEntitlementMap().get(value.findReference(ShadowAssociationType.F_SHADOW_REF).getOid()); LOGGER.trace("Resolved entitlement {}", entitlement); if (variables.containsKey(ExpressionConstants.VAR_ENTITLEMENT)) { variables.replaceVariableDefinition(ExpressionConstants.VAR_ENTITLEMENT, entitlement); } else { variables.addVariableDefinition(ExpressionConstants.VAR_ENTITLEMENT, entitlement); } }
public void addVariableDefinitionsNew(ExpressionVariables extraVariables) { addVariableDefinitionsNew(extraVariables.getMap()); }
public void addVariableDefinitions(ExpressionVariables extraVariables, @NotNull Collection<QName> exceptFor) { addVariableDefinitions(extraVariables.getMap(), exceptFor); }
PrismPropertyDefinition<Boolean> resultDef = prismContext.definitionFactory().createPropertyDefinition(resultName, DOMUtil.XSD_BOOLEAN); ExpressionVariables expressionVariables = new ExpressionVariables(); expressionVariables.addVariableDefinition(SchemaConstants.C_MODEL_CONTEXT, modelContext); expressionVariables.addVariableDefinition(SchemaConstants.C_ITEM_TO_APPROVE, itemToApprove); if (additionalVariables != null) { expressionVariables.addVariableDefinitions(additionalVariables);
@Override @NotNull public LocalizableMessageType createLocalizableMessageType(LocalizableMessageTemplateType template, Map<QName, Object> variables, Task task, OperationResult result) throws ObjectNotFoundException, SchemaException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { ExpressionVariables vars = new ExpressionVariables(); vars.addVariableDefinitions(variables); return LensUtil.interpretLocalizableMessageTemplate(template, vars, expressionFactory, prismContext, task, result); }
public Builder<V, D> addVariableDefinition(QName name, Object value) { variables.addVariableDefinition(name, value); return this; }
public static <O extends ObjectType> ExpressionVariables getDefaultExpressionVariables(PrismObject<? extends ObjectType> focus, PrismObject<? extends ShadowType> shadow, ResourceShadowDiscriminator discr, PrismObject<ResourceType> resource, PrismObject<SystemConfigurationType> configuration, LensElementContext<O> affectedElementContext) { ExpressionVariables variables = new ExpressionVariables(); addDefaultExpressionVariables(variables, focus, shadow, discr, resource, configuration, affectedElementContext); return variables; }
ExpressionVariables newVariables = new ExpressionVariables(); boolean actorDefined = newVariables.get(ExpressionConstants.VAR_ACTOR) != null; for (Entry<QName,Object> entry: variables.entrySet()) { if (ExpressionConstants.VAR_ACTOR.equals(entry.getKey()) && actorDefined) { continue; // avoid pointless warning about redefined value of actor newVariables.addVariableDefinition(entry.getKey(), entry.getValue()); ref.setType(prismContext.getSchemaRegistry().qualifyTypeName(ref.getType())); ObjectType varObject = objectResolver.resolve(ref, ObjectType.class, null, "variable "+varName+" in "+contextDescription, task, result); newVariables.addVariableDefinition(varName, varObject); } else if (variableDefType.getValue() != null) { newVariables.addVariableDefinition(varName, valueObject); } else if (valueObject instanceof Element) { newVariables.addVariableDefinition(varName, ((Element)valueObject).getTextContent()); } else if (valueObject instanceof RawType) { newVariables.addVariableDefinition(varName, ((RawType) valueObject).getParsedValue(null, varName)); } else { throw new SchemaException("Unexpected type "+valueObject.getClass()+" in variable definition "+varName+" in "+contextDescription); ItemPath itemPath = variableDefType.getPath().getItemPath(); Object resolvedValue = ExpressionUtil.resolvePath(itemPath, variables, false, null, objectResolver, contextDescription, task, result); newVariables.addVariableDefinition(varName, resolvedValue); } else { throw new SchemaException("No value for variable "+varName+" in "+contextDescription);
Task task, OperationResult result) throws ExpressionEvaluationException, ObjectNotFoundException, SchemaException, CommunicationException, ConfigurationException, SecurityViolationException { ExpressionVariables scriptVariables = new ExpressionVariables(); if (useNew) { scriptVariables.addVariableDefinitionsNew(variables); } else { scriptVariables.addVariableDefinitionsOld(variables); value = getRealContent(source.getItemOld(), source.getResidualPath()); scriptVariables.addVariableDefinition(name, value);
ExpressionVariables scriptVariables = new ExpressionVariables(); scriptVariables.addVariableDefinitions(sourceVariables); PlusMinusZero valueDestination; boolean useNew = false; if (hasPlus) { scriptVariables.addVariableDefinitionsNew(variables); valueDestination = PlusMinusZero.PLUS; useNew = true; } else if (hasMinus) { scriptVariables.addVariableDefinitionsOld(variables); valueDestination = PlusMinusZero.MINUS; } else { scriptVariables.addVariableDefinitionsNew(variables); valueDestination = PlusMinusZero.ZERO; useNew = true;
@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(); } }
public static <V extends PrismValue,D extends ItemDefinition> MappingImpl.Builder<V,D> addAssignmentPathVariables(MappingImpl.Builder<V,D> builder, AssignmentPathVariables assignmentPathVariables) { ExpressionVariables expressionVariables = new ExpressionVariables(); ModelImplUtils.addAssignmentPathVariables(assignmentPathVariables, expressionVariables); return builder.addVariableDefinitions(expressionVariables.getMap()); }
PrismObject<UserType> oldActor = (PrismObject<UserType>) scriptVariables.get(ExpressionConstants.VAR_ACTOR); if (oldActor != null) { return; scriptVariables.addVariableDefinition(ExpressionConstants.VAR_ACTOR, null); return; "Couldn't get principal information - the 'actor' variable is set to null", e); scriptVariables.addVariableDefinition(ExpressionConstants.VAR_ACTOR, actor);
public Builder<V, D> addVariableDefinitions(Map<QName, Object> extraVariables) { variables.addVariableDefinitions(extraVariables); return this; }
relativePath = path.rest(); QName varName = ItemPath.toVariableName(first); if (variables.containsKey(varName)) { Object varValue = variables.get(varName); if (varValue instanceof ItemDeltaItem<?, ?>) { root = ((ItemDeltaItem<?, ?>) varValue).getDefinition();
public void addVariableDefinition(QName name, Object value) { if (variables.containsKey(name)) { LOGGER.warn("Duplicate definition of variable {}", name); return; } replaceVariableDefinition(name, value); }
public boolean hasVariableDefinition(QName varName) { return variables.containsKey(varName); }
private boolean isInRange(V value, Task task, OperationResult result) throws ExpressionEvaluationException, ObjectNotFoundException, SchemaException, CommunicationException, ConfigurationException, SecurityViolationException { @NotNull ValueSetSpecificationType range = mappingType.getRange(); if (range.getIsInSetExpression() == null) { return false; } ExpressionVariables variables = new ExpressionVariables(); variables.addVariableDefinitions(this.variables); // TODO is this ok? if (value instanceof PrismContainerValue) { // artificially create parent for PCV in order to pass it to expression PrismContainer.createParentIfNeeded((PrismContainerValue) value, outputDefinition); } variables.addVariableDefinition(ExpressionConstants.VAR_VALUE, value); PrismPropertyDefinition<Boolean> outputDef = getPrismContext().definitionFactory().createPropertyDefinition(SchemaConstantsGenerated.C_VALUE, DOMUtil.XSD_BOOLEAN, null, false); PrismPropertyValue<Boolean> rv = ExpressionUtil.evaluateExpression(variables, outputDef, range.getIsInSetExpression(), expressionFactory, "isInSet expression in " + contextDescription, task, result); // but now remove the parent! TODO: PM: why??? // if (value.getParent() != null) { // value.setParent(null); // } return rv != null && rv.getValue() != null ? rv.getValue() : Boolean.FALSE; }