Examples with DmnExpressionImpl org.camunda.bpm.dmn.engine.impl.DmnExpressionImpl used on opensource projects

Example 1 with DmnExpressionImpl

use of org.camunda.bpm.dmn.engine.impl.DmnExpressionImpl in project camunda-engine-dmn by camunda.

the class DefaultDmnTransform method transformDecisionTableRule.

protected DmnDecisionTableRuleImpl transformDecisionTableRule(Rule rule) {
    DmnElementTransformHandler<Rule, DmnDecisionTableRuleImpl> handler = handlerRegistry.getHandler(Rule.class);
    DmnDecisionTableRuleImpl dmnRule = handler.handleElement(this, rule);
    // validate rule id
    if (dmnRule.getId() == null) {
        throw LOG.decisionTableRuleIdIsMissing(decision, dmnRule);
    }
    List<DmnDecisionTableInputImpl> inputs = this.decisionTable.getInputs();
    List<InputEntry> inputEntries = new ArrayList<InputEntry>(rule.getInputEntries());
    if (inputs.size() != inputEntries.size()) {
        throw LOG.differentNumberOfInputsAndInputEntries(inputs.size(), inputEntries.size(), dmnRule);
    }
    for (InputEntry inputEntry : inputEntries) {
        parent = dmnRule;
        DmnExpressionImpl condition = transformInputEntry(inputEntry);
        dmnRule.getConditions().add(condition);
    }
    List<DmnDecisionTableOutputImpl> outputs = this.decisionTable.getOutputs();
    List<OutputEntry> outputEntries = new ArrayList<OutputEntry>(rule.getOutputEntries());
    if (outputs.size() != outputEntries.size()) {
        throw LOG.differentNumberOfOutputsAndOutputEntries(outputs.size(), outputEntries.size(), dmnRule);
    }
    for (OutputEntry outputEntry : outputEntries) {
        parent = dmnRule;
        DmnExpressionImpl conclusion = transformOutputEntry(outputEntry);
        dmnRule.getConclusions().add(conclusion);
    }
    return dmnRule;
}

Example 2 with DmnExpressionImpl

use of org.camunda.bpm.dmn.engine.impl.DmnExpressionImpl in project camunda-engine-dmn by camunda.

the class ExpressionCachingTest method testElExpressionCaching.

@Test
public void testElExpressionCaching() {
    // given
    DmnExpressionImpl expression = createExpression("1 > 2", "juel");
    // when
    expressionEvaluationHandler.evaluateExpression("juel", expression, emptyVariableContext());
    // then
    InOrder inOrder = inOrder(expression, elProviderSpy);
    inOrder.verify(expression, atLeastOnce()).getCachedExpression();
    inOrder.verify(elProviderSpy, times(1)).createExpression(anyString());
    inOrder.verify(expression, times(1)).setCachedExpression(any(ElExpression.class));
    // when (2)
    expressionEvaluationHandler.evaluateExpression("juel", expression, emptyVariableContext());
    // then (2)
    inOrder.verify(expression, atLeastOnce()).getCachedExpression();
    inOrder.verify(elProviderSpy, times(0)).createExpression(anyString());
}

Example 3 with DmnExpressionImpl

use of org.camunda.bpm.dmn.engine.impl.DmnExpressionImpl in project camunda-engine-dmn by camunda.

the class ExpressionLanguageTest method testGlobalExpressionLanguageDecisionTable.

@Test
@DecisionResource(resource = GROOVY_DECISION_TABLE_DMN)
public void testGlobalExpressionLanguageDecisionTable() {
    DmnDecisionTableImpl decisionTable = (DmnDecisionTableImpl) decision.getDecisionLogic();
    for (DmnDecisionTableInputImpl dmnInput : decisionTable.getInputs()) {
        assertThat(dmnInput.getExpression().getExpressionLanguage()).isEqualTo("groovy");
    }
    for (DmnDecisionTableRuleImpl dmnRule : decisionTable.getRules()) {
        for (DmnExpressionImpl condition : dmnRule.getConditions()) {
            assertThat(condition.getExpressionLanguage()).isEqualTo("groovy");
        }
        for (DmnExpressionImpl conclusion : dmnRule.getConclusions()) {
            assertThat(conclusion.getExpressionLanguage()).isEqualTo("groovy");
        }
    }
    assertExample(dmnEngine, decision);
    verify(scriptEngineResolver, atLeastOnce()).getScriptEngineForLanguage("groovy");
    verify(scriptEngineResolver, never()).getScriptEngineForLanguage(JUEL);
}

Example 4 with DmnExpressionImpl

use of org.camunda.bpm.dmn.engine.impl.DmnExpressionImpl in project camunda-engine-dmn by camunda.

the class DmnTransformTest method shouldTransformRules.

@Test
public void shouldTransformRules() {
    DmnDecisionImpl decisionEntity = (DmnDecisionImpl) parseDecisionFromFile("decision1", TRANSFORM_DMN);
    DmnDecisionTableImpl decisionTable = (DmnDecisionTableImpl) decisionEntity.getDecisionLogic();
    List<DmnDecisionTableRuleImpl> rules = decisionTable.getRules();
    assertThat(rules).hasSize(1);
    DmnDecisionTableRuleImpl rule = rules.get(0);
    List<DmnExpressionImpl> conditions = rule.getConditions();
    assertThat(conditions).hasSize(2);
    DmnExpressionImpl condition = conditions.get(0);
    assertThat(condition.getId()).isEqualTo("inputEntry");
    assertThat(condition.getName()).isEqualTo("camunda");
    assertThat(condition.getExpressionLanguage()).isEqualTo("camunda");
    assertThat(condition.getExpression()).isEqualTo("camunda");
    condition = conditions.get(1);
    assertThat(condition.getId()).isNull();
    assertThat(condition.getName()).isNull();
    assertThat(condition.getExpressionLanguage()).isNull();
    assertThat(condition.getExpression()).isNull();
    List<DmnExpressionImpl> conclusions = rule.getConclusions();
    assertThat(conclusions).hasSize(2);
    DmnExpressionImpl dmnOutputEntry = conclusions.get(0);
    assertThat(dmnOutputEntry.getId()).isEqualTo("outputEntry");
    assertThat(dmnOutputEntry.getName()).isEqualTo("camunda");
    assertThat(dmnOutputEntry.getExpressionLanguage()).isEqualTo("camunda");
    assertThat(dmnOutputEntry.getExpression()).isEqualTo("camunda");
    dmnOutputEntry = conclusions.get(1);
    assertThat(dmnOutputEntry.getId()).isNull();
    assertThat(dmnOutputEntry.getName()).isNull();
    assertThat(dmnOutputEntry.getExpressionLanguage()).isNull();
    assertThat(dmnOutputEntry.getExpression()).isNull();
}

Example 5 with DmnExpressionImpl

use of org.camunda.bpm.dmn.engine.impl.DmnExpressionImpl in project camunda-engine-dmn by camunda.

the class DecisionLiteralExpressionEvaluationHandler method evaluate.

@Override
public DmnDecisionLogicEvaluationEvent evaluate(DmnDecision decision, VariableContext variableContext) {
    DmnDecisionLiteralExpressionEvaluationEventImpl evaluationResult = new DmnDecisionLiteralExpressionEvaluationEventImpl();
    evaluationResult.setDecision(decision);
    evaluationResult.setExecutedDecisionElements(1);
    DmnDecisionLiteralExpressionImpl dmnDecisionLiteralExpression = (DmnDecisionLiteralExpressionImpl) decision.getDecisionLogic();
    DmnVariableImpl variable = dmnDecisionLiteralExpression.getVariable();
    DmnExpressionImpl expression = dmnDecisionLiteralExpression.getExpression();
    Object evaluateExpression = evaluateLiteralExpression(expression, variableContext);
    TypedValue typedValue = variable.getTypeDefinition().transform(evaluateExpression);
    evaluationResult.setOutputValue(typedValue);
    evaluationResult.setOutputName(variable.getName());
    return evaluationResult;
}