protected internal virtual void addResultToVariableContext(IDmnDecisionResult evaluatedResult,
IVariableMap variableMap, IDmnDecision evaluatedDecision)
{
var resultList = evaluatedResult.ResultList;
if (resultList.Count == 0)
{
}
else if ((resultList.Count == 1) && !isDecisionTableWithCollectOrRuleOrderHitPolicy(evaluatedDecision))
{
foreach (var it in evaluatedResult.SingleResult)
{
variableMap.PutValue(it.Key, it.Value);
}
//variableMap.putAll(evaluatedResult.SingleResult);
}
else
{
ISet <string> outputs = new HashSet <string>();
foreach (var resultMap in resultList)
{
outputs.UnionWith(resultMap.Keys);
}
foreach (var output in outputs)
{
var values = evaluatedResult.CollectEntries <object>(output);
variableMap.PutValue(output, values);
}
}
}
public virtual DmnDecisionResultException decisionResultHasMoreThanOneOutput(IDmnDecisionResult decisionResult)
{
return
(new DmnDecisionResultException(ExceptionMessage("011",
string.Format("Unable to get single decision result as it has more than one result '{0}'",
decisionResult))));
}
/// <summary>
/// Evaluate a decision with the given <seealso cref="IVariableContext" />
/// </summary>
/// <param name="decision"> the decision to evaluate </param>
/// <param name="variableContext"> the available variable context </param>
/// <returns> the result of the decision evaluation </returns>
public virtual IDmnDecisionResult evaluateDecision(IDmnDecision decision, IVariableContext variableContext)
{
if (ReferenceEquals(decision.Key, null))
{
throw LOG.unableToFindAnyDecisionTable();
}
var variableMap = buildVariableMapFromVariableContext(variableContext);
IList <IDmnDecision> requiredDecisions = new List <IDmnDecision>();
buildDecisionTree(decision, requiredDecisions);
IList <IDmnDecisionLogicEvaluationEvent> evaluatedEvents = new List <IDmnDecisionLogicEvaluationEvent>();
IDmnDecisionResult evaluatedResult = null;
foreach (var evaluateDecision in requiredDecisions)
{
var handler = getDecisionEvaluationHandler(evaluateDecision);
var evaluatedEvent = handler.Evaluate(evaluateDecision, variableMap.AsVariableContext());
evaluatedEvents.Add(evaluatedEvent);
evaluatedResult = handler.GenerateDecisionResult(evaluatedEvent);
if (decision != evaluateDecision)
{
addResultToVariableContext(evaluatedResult, variableMap, evaluateDecision);
}
}
generateDecisionEvaluationEvent(evaluatedEvents);
return(evaluatedResult);
}
public virtual void evaluateDecisionByKeyAndNullVersion()
{
testRule.Deploy(DMN_DECISION_LITERAL_EXPRESSION_V2);
IDmnDecisionResult decisionResult = decisionService.EvaluateDecisionByKey(DECISION_DEFINITION_KEY).Version(null).Variables(createVariables()).Evaluate();
AssertThatDecisionHasResult(decisionResult, RESULT_OF_SECOND_VERSION);
}
public virtual void evaluateDecisionById()
{
IDecisionDefinition decisionDefinition = repositoryService.CreateDecisionDefinitionQuery().First();
IDmnDecisionResult decisionResult = decisionService.EvaluateDecisionById(decisionDefinition.Id).Variables(createVariables()).Evaluate();
AssertThatDecisionHasResult(decisionResult, RESULT_OF_FIRST_VERSION);
}
[Test] public virtual void testEvaluateDecisionByKeyForAnyTenants()
{
DeploymentForTenant(TENANT_ONE, DMN_FILE);
IDmnDecisionResult decisionResult = decisionService.EvaluateDecisionByKey(DECISION_DEFINITION_KEY).Variables(createVariables()).Evaluate();
AssertThatDecisionHasResult(decisionResult, RESULT_OF_FIRST_VERSION);
}
protected internal virtual void AssertThatDecisionHasResult(IDmnDecisionResult decisionResult, object expectedValue)
{
Assert.That(decisionResult != null);
Assert.That(decisionResult.Count, Is.EqualTo(1));
string value = decisionResult.SingleResult.GetFirstEntry().ToString();
Assert.That(value, Is.EqualTo(expectedValue));
}
[Test] public virtual void testEvaluateDecisionByKeyWithoutTenantId()
{
Deployment(DMN_FILE);
IDmnDecisionResult decisionResult = decisionService.EvaluateDecisionByKey(DECISION_DEFINITION_KEY).Variables(createVariables()).DecisionDefinitionWithoutTenantId().Evaluate();
AssertThatDecisionHasResult(decisionResult, RESULT_OF_FIRST_VERSION);
}
public virtual ProcessEngineException DecisionResultCollectMappingException(ICollection <string> outputNames,
IDmnDecisionResult decisionResult, IDecisionResultMapper resultMapper)
{
return
(new ProcessEngineException(ExceptionMessage("002",
"The decision result mapper '{0}' failed to process '{1}'. The decision outputs should only contains values for one output name but found '{2}'.",
resultMapper, decisionResult, outputNames)));
}
public virtual ProcessEngineException DecisionResultMappingException(IDmnDecisionResult decisionResult,
IDecisionResultMapper resultMapper, DmnEngineException cause)
{
return
(new ProcessEngineException(
ExceptionMessage("001", "The decision result mapper '{0}' failed to process '{1}'", resultMapper,
decisionResult), cause));
}
[Test] public virtual void testEvaluateDecisionByKeyLatestVersionAndTenantId()
{
DeploymentForTenant(TENANT_ONE, DMN_FILE);
DeploymentForTenant(TENANT_ONE, DMN_FILE_SECOND_VERSION);
IDmnDecisionResult decisionResult = decisionService.EvaluateDecisionByKey(DECISION_DEFINITION_KEY).Variables(createVariables()).DecisionDefinitionTenantId(TENANT_ONE).Evaluate();
AssertThatDecisionHasResult(decisionResult, RESULT_OF_SECOND_VERSION);
}
protected internal virtual void AssertThatDecisionHasResult(IDmnDecisionResult decisionResult, object expectedValue)
{
//Assert.That(decisionResult, Is.EqualTo(notNullValue()));
Assert.That(decisionResult, Is.Not.Null);
Assert.That(decisionResult.Count, Is.EqualTo(1));
string value = (string)decisionResult.GetSingleEntry().GetFirstEntry();
//string value = decisionResult.SingleResult.FirstEntry;
Assert.That(value, Is.EqualTo(expectedValue));
}
[Test] public virtual void testEvaluateDecisionByKeyWithTenantIdDisabledTenantCheck()
{
processEngineConfiguration.SetTenantCheckEnabled(false);
identityService.SetAuthentication("user", null, null);
DeploymentForTenant(TENANT_ONE, DMN_FILE);
IDmnDecisionResult decisionResult = decisionService.EvaluateDecisionByKey(DECISION_DEFINITION_KEY).DecisionDefinitionTenantId(TENANT_ONE).Variables(createVariables()).Evaluate();
AssertThatDecisionHasResult(decisionResult, RESULT_OF_FIRST_VERSION);
}
protected internal virtual IProcessInstance startTestProcess(string input)
{
var dic = new Dictionary <string, ITypedValue>();
dic["input"] = new StringValueImpl(input);
IProcessInstance processInstance = runtimeService.StartProcessInstanceByKey("testProcess", dic);
// get the result from an execution listener that is invoked at the end of the business rule activity
results = DecisionResultTestListener.DecisionResult;
Assert.NotNull(results);
return(processInstance);
}
[Test] public virtual void testEvaluateDecisionByKeyWithAuthenticatedTenant()
{
identityService.SetAuthentication("user", null, new List <string>()
{
TENANT_ONE
});
DeploymentForTenant(TENANT_ONE, DMN_FILE);
DeploymentForTenant(TENANT_TWO, DMN_FILE_SECOND_VERSION);
IDmnDecisionResult decisionResult = decisionService.EvaluateDecisionByKey(DECISION_DEFINITION_KEY).Variables(createVariables()).Evaluate();
AssertThatDecisionHasResult(decisionResult, RESULT_OF_FIRST_VERSION);
}
public static DmnDecisionTableResultImpl Wrap(IDmnDecisionResult decisionResult)
{
IList <IDmnDecisionRuleResult> ruleResults = new List <IDmnDecisionRuleResult>();
foreach (var result in decisionResult)
{
var ruleResult = new DmnDecisionRuleResultImpl();
ruleResult.putAllValues(result.EntryMapTyped);
ruleResults.Add(ruleResult);
}
return(new DmnDecisionTableResultImpl(ruleResults));
}
[Test] public virtual void testEvaluateDecisionByIdAuthenticatedTenant()
{
DeploymentForTenant(TENANT_ONE, DMN_FILE);
IDecisionDefinition decisionDefinition = repositoryService.CreateDecisionDefinitionQuery().First();
identityService.SetAuthentication("user", null, new List <string>()
{
TENANT_ONE
});
IDmnDecisionResult decisionResult = decisionService.EvaluateDecisionById(decisionDefinition.Id).Variables(createVariables()).Evaluate();
AssertThatDecisionHasResult(decisionResult, RESULT_OF_FIRST_VERSION);
}
public virtual object MapDecisionResult(IDmnDecisionResult decisionResult)
{
if ((decisionResult == null) || (decisionResult.Count == 0))
{
return(null);
}
var outputNames = CollectOutputNames(decisionResult);
if (outputNames.Count > 1)
{
throw Log.DecisionResultCollectMappingException(outputNames, decisionResult, this);
}
var outputName = outputNames.FirstOrDefault();
//return decisionResult.CollectEntries<IDmnDecisionResultEntries>(outputName);
return(decisionResult.CollectEntries <ITypedValue>(outputName));
}
protected internal virtual ICollection <string> CollectOutputNames(IDmnDecisionResult decisionResult)
{
var outputNames = new List <string>();
foreach (var entryMap in decisionResult.ResultList)
{
foreach (var item in entryMap.Keys)
{
if (!outputNames.Contains(item))
{
outputNames.Add(item);
}
}
}
return(outputNames);
}
public virtual object MapDecisionResult(IDmnDecisionResult decisionResult)
{
try
{
var singleResult = decisionResult.SingleResult;
if (singleResult != null)
{
return(singleResult.EntryMap);
}
return(Variables.UntypedNullValue());
}
catch (DmnEngineException e)
{
throw Log.DecisionResultMappingException(decisionResult, this, e);
}
catch (System.Exception e)
{
throw e;
}
}
public virtual object MapDecisionResult(IDmnDecisionResult decisionResult)
{
try
{
ITypedValue typedValue = decisionResult.GetSingleEntryTyped<ITypedValue>();//.SingleEntryTyped;
if (typedValue != null)
{
return typedValue;
}
return Variables.UntypedNullValue();
}
catch (DmnEngineException e)
{
throw Log.DecisionResultMappingException(decisionResult, this, e);
}
catch (System.Exception e)
{
throw e;
}
}
public virtual void evaluateDecisionByKey()
{
IDmnDecisionResult decisionResult = decisionService.EvaluateDecisionByKey(DECISION_DEFINITION_KEY).Variables(createVariables()).Evaluate();
AssertThatDecisionHasResult(decisionResult, RESULT_OF_FIRST_VERSION);
}
//自定义类可获取运行时var
public void Notify(IBaseDelegateExecution execution)
{
decisionResult = (IDmnDecisionResult)execution.GetVariable(DecisionEvaluationUtil.DecisionResultVariable);
}
public virtual object MapDecisionResult(IDmnDecisionResult decisionResult)
{
return(decisionResult.ResultList);
}
public static void Reset()
{
decisionResult = null;
}
