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; }
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; }
/** * Expects QName-value pairs. * * E.g. * create(var1qname, var1value, var2qname, var2value, ...) * * Mostly for testing. Use at your own risk. */ public static ExpressionVariables create(Object... parameters) { ExpressionVariables vars = new ExpressionVariables(); for (int i = 0; i < parameters.length; i += 2) { vars.addVariableDefinition((QName)parameters[i], parameters[i+1]); } return vars; }
private static ExpressionVariables createVariables(HashMap<String, Object> variableMap) { ExpressionVariables rv = new ExpressionVariables(); Map<String, Object> clonedVariableMap = cloneIfNecessary(variableMap); clonedVariableMap.forEach((name, value) -> rv.addVariableDefinition(new QName(SchemaConstants.NS_C, name), value)); return rv; }
public ExpressionVariables getDefaultVariables(Event event, OperationResult result) { ExpressionVariables expressionVariables = new ExpressionVariables(); Map<QName, Object> variables = new HashMap<>(); event.createExpressionVariables(variables, result); variables.put(SchemaConstants.C_TEXT_FORMATTER, textFormatter); variables.put(SchemaConstants.C_NOTIFICATION_FUNCTIONS, notificationsUtil); variables.put(ExpressionConstants.VAR_CONFIGURATION, getSystemConfiguration(result)); expressionVariables.addVariableDefinitions(variables); return expressionVariables; }
@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); }
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; }
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()); }
boolean evaluateActivationCondition(GeneralChangeProcessorScenarioType scenarioType, ModelContext context, Task taskFromModel, OperationResult result) throws SchemaException { ExpressionType conditionExpression = scenarioType.getActivationCondition(); if (conditionExpression == null) { return true; } ExpressionVariables variables = new ExpressionVariables(); variables.addVariableDefinition(new QName(SchemaConstants.NS_C, "context"), context); boolean start; try { start = evaluateBooleanExpression(conditionExpression, variables, "workflow activation condition", taskFromModel, result); } catch (ObjectNotFoundException|ExpressionEvaluationException | CommunicationException | ConfigurationException | SecurityViolationException e) { throw new SystemException("Couldn't evaluate generalChangeProcessor activation condition", e); } return start; }
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 <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 void executeScript(CommandLineScriptType scriptType, ExpressionVariables variables, String shortDesc, Task task, OperationResult parentResult) throws IOException, InterruptedException, SchemaException, ExpressionEvaluationException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException { OperationResult result = parentResult.createSubresult(CommandLineScriptExecutor.class.getSimpleName() + ".run"); if (variables == null) { variables = new ExpressionVariables(); } String expandedCode = expandMacros(scriptType, variables, shortDesc, task, result); // TODO: later: prepare agruments and environment String preparedCode = expandedCode.trim(); LOGGER.debug("Prepared shell code: {}", preparedCode); CommandLineRunner runner = new CommandLineRunner(preparedCode, result); runner.setExectionMethod(scriptType.getExecutionMethod()); runner.execute(); result.computeStatus(); }
private ExpressionVariables createVariables() throws SchemaException, IOException { ExpressionVariables variables = new ExpressionVariables(); variables.addVariableDefinition(ExpressionConstants.VAR_USER, createUser()); return variables; }
private List<ObjectReferenceType> computeDelegateTo(DelegateWorkItemActionType delegateAction, AccessCertificationWorkItemType workItem, AccessCertificationCaseType aCase, AccessCertificationCampaignType campaign, Task task, OperationResult result) { List<ObjectReferenceType> rv = CloneUtil.cloneCollectionMembers(delegateAction.getApproverRef()); if (!delegateAction.getApproverExpression().isEmpty()) { ExpressionVariables variables = new ExpressionVariables(); variables.addVariableDefinition(ExpressionConstants.VAR_WORK_ITEM, workItem); variables.addVariableDefinition(ExpressionConstants.VAR_CERTIFICATION_CASE, aCase); variables.addVariableDefinition(ExpressionConstants.VAR_CAMPAIGN, campaign); for (ExpressionType expression : delegateAction.getApproverExpression()) { rv.addAll(expressionHelper.evaluateRefExpressionChecked(expression, variables, "computing delegates", task, result)); } } return rv; }
private boolean isAssociationRelevant(PcpAspectConfigurationType config, AssociationAdditionType itemToApprove, ResourceShadowDiscriminator rsd, ModelContext<?> modelContext, Task task, OperationResult result) { LOGGER.trace(" - considering: {}", itemToApprove); ExpressionVariables variables = new ExpressionVariables(); variables.addVariableDefinition(SchemaConstants.C_ASSOCIATION, itemToApprove.getAssociation()); variables.addVariableDefinition(SchemaConstants.C_SHADOW_DISCRIMINATOR, rsd); boolean applicable = primaryChangeAspectHelper.evaluateApplicabilityCondition( config, modelContext, itemToApprove, variables, this, task, result); LOGGER.trace(" - result: applicable = {}", applicable); return applicable; }
public <V extends PrismValue, D extends ItemDefinition> MappingImpl.Builder<V, D> createMappingBuilder() { return new MappingImpl.Builder<V, D>() .prismContext(prismContext) .expressionFactory(expressionFactory) .securityContextManager(securityContextManager) .variables(new ExpressionVariables()) .filterManager(filterManager) .profiling(profiling); }
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(); }
public static ExpressionVariables getDefaultXPathVariables(UserType user, ShadowType shadow, ResourceType resource) { ExpressionVariables variables = new ExpressionVariables(); if (user != null) { variables.addVariableDefinition(ExpressionConstants.VAR_USER, user.asPrismObject()); } if (shadow != null) { variables.addVariableDefinition(ExpressionConstants.VAR_ACCOUNT, shadow.asPrismObject()); variables.addVariableDefinition(ExpressionConstants.VAR_PROJECTION, shadow.asPrismObject()); } if (resource != null) { variables.addVariableDefinition(ExpressionConstants.VAR_RESOURCE, resource.asPrismObject()); } 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 ExpressionVariables createVariablesOdo() throws SchemaException, IOException { ExpressionVariables variables = new ExpressionVariables(); PrismObject<UserType> userOld = createUser(); ObjectDelta<UserType> delta = PrismTestUtil.getPrismContext().deltaFactory().object().createModificationReplaceProperty(UserType.class, userOld.getOid(), UserType.F_FULL_NAME, PrismTestUtil.createPolyString("Captain Jack Sparrow")); ObjectDeltaObject<UserType> odo = new ObjectDeltaObject<>(userOld, delta, null); odo.recompute(); variables.addVariableDefinition(ExpressionConstants.VAR_USER, odo); return variables; }