org.mvel2.integration.PropertyHandler Java Examples

public static MvelExecutionContext build(Decision decision, Map<String, Object> inputVariables,
    Map<String, Method> customExpressionFunctions, Map<Class<?>, PropertyHandler> propertyHandlers) {

  MvelExecutionContext executionContext = new MvelExecutionContext();

  // initialize audit trail
  executionContext.setAuditContainer(DecisionExecutionAuditUtil.initializeRuleExecutionAudit(decision, inputVariables));

  ParserContext parserContext = new ParserContext();

  // add custom functions to context
  if (customExpressionFunctions != null && !customExpressionFunctions.isEmpty()) {
    for (Map.Entry<String, Method> config : customExpressionFunctions.entrySet()) {
      parserContext.addImport(config.getKey(), config.getValue());
    }
  }

  executionContext.setParserContext(parserContext);

  if (propertyHandlers != null) {
    for (Class<?> variableClass : propertyHandlers.keySet()) {
      executionContext.addPropertyHandler(variableClass, propertyHandlers.get(variableClass));
    }
  }
  
  DecisionTable decisionTable = (DecisionTable) decision.getExpression();
  
  preProcessInputVariables(decisionTable, inputVariables);

  executionContext.setStackVariables(inputVariables);

  logger.debug("Execution Context created");

  return executionContext;
}
 

/**
 * Executes the given decision table and creates the outcome results
 *
 * @param decision
 *          the DMN decision 
 * @param input
 *          map with input variables
 * @return updated execution variables map
 */
@Override
public RuleEngineExecutionResult execute(Decision decision, Map<String, Object> input,
    Map<String, Method> customExpressionFunctions, Map<Class<?>, PropertyHandler> propertyHandlers) {

  if (decision  == null) {
    throw new IllegalArgumentException("no decision provided");
  }

  if (decision.getExpression() == null || !(decision.getExpression() instanceof DecisionTable)) {
    throw new IllegalArgumentException("no decision table present in decision");
  }
  
  DecisionTable currentDecisionTable = (DecisionTable) decision.getExpression();

  // create execution context and audit trail
  MvelExecutionContext executionContext = MvelExecutionContextBuilder.build(decision, input, 
      customExpressionFunctions, propertyHandlers);

  // evaluate decision table
  Map<String, Object> resultVariables = evaluateDecisionTable(currentDecisionTable, executionContext);

  // end audit trail
  executionContext.getAuditContainer().stopAudit(resultVariables);

  // create result container
  RuleEngineExecutionResult executionResult = new RuleEngineExecutionResult(resultVariables, executionContext.getAuditContainer());

  return executionResult;
}
 

private Pattern buildPattern(RuleBuildContext context, PatternDescr patternDescr, ObjectType objectType) {
    String patternIdentifier = patternDescr.getIdentifier();
    boolean duplicateBindings = patternIdentifier != null && objectType instanceof ClassObjectType &&
            context.getDeclarationResolver().isDuplicated(context.getRule(),
                                                          patternIdentifier,
                                                          objectType.getClassName());

    Pattern pattern;
    if (!StringUtils.isEmpty(patternIdentifier) && !duplicateBindings) {

        pattern = new Pattern(context.getNextPatternId(),
                              0, // offset is 0 by default
                              objectType,
                              patternIdentifier,
                              patternDescr.isInternalFact(context));
        if (objectType instanceof ClassObjectType) {
            // make sure PatternExtractor is wired up to correct ClassObjectType and set as a target for rewiring
            context.getPkg().getClassFieldAccessorStore().wireObjectType(objectType, (AcceptsClassObjectType) pattern.getDeclaration().getExtractor());
        }
    } else {
        pattern = new Pattern(context.getNextPatternId(),
                              0, // offset is 0 by default
                              objectType,
                              null);
    }
    pattern.setPassive(patternDescr.isPassive(context));

    if (ClassObjectType.Match_ObjectType.isAssignableFrom(pattern.getObjectType())) {
        PropertyHandler handler = PropertyHandlerFactory.getPropertyHandler(RuleTerminalNodeLeftTuple.class);
        if (handler == null) {
            PropertyHandlerFactoryFixer.getPropertyHandlerClass().put(RuleTerminalNodeLeftTuple.class,
                                                                      new ActivationPropertyHandler());
        }
    }

    // adding the newly created pattern to the build stack this is necessary in case of local declaration usage
    context.getDeclarationResolver().pushOnBuildStack(pattern);

    if (duplicateBindings) {
        processDuplicateBindings(patternDescr.isUnification(), patternDescr, pattern, patternDescr, "this", patternDescr.getIdentifier(), context);
    }
    return pattern;
}
 

public static  Map<Class, PropertyHandler> getPropertyHandlerClass() {
    return propertyHandlerClass;
}
 

RuleEngineExecutionResult execute(Decision decision, Map<String, Object> input,
Map<String, Method> customExpressionFunctions, Map<Class<?>, PropertyHandler> propertyHandlers);
 

public Map<Class<?>, PropertyHandler> getCustomPropertyHandlers() {
  return customPropertyHandlers;
}
 

public void setCustomPropertyHandlers(Map<Class<?>, PropertyHandler> customPropertyHandlers) {
  this.customPropertyHandlers = customPropertyHandlers;
}
 

public Map<Class<?>, PropertyHandler> getPropertyHandlers() {
    return propertyHandlers;
}
 

public void addPropertyHandler(Class<?> variableClass, PropertyHandler propertyHandler) {
    propertyHandlers.put(variableClass, propertyHandler);
}