protected internal override void initializeActivity(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context)
{
// execute standard initialization
base.initializeActivity(element, activity, context);
// create a taskDefinition
TaskDefinition taskDefinition = createTaskDefinition(element, context);
// get the caseDefinition...
CaseDefinitionEntity caseDefinition = (CaseDefinitionEntity)context.CaseDefinition;
// ... and taskDefinition to caseDefinition
caseDefinition.TaskDefinitions[taskDefinition.Key] = taskDefinition;
ExpressionManager expressionManager = context.ExpressionManager;
// create decorator
TaskDecorator taskDecorator = new TaskDecorator(taskDefinition, expressionManager);
// set taskDecorator on behavior
HumanTaskActivityBehavior behavior = (HumanTaskActivityBehavior)activity.ActivityBehavior;
behavior.TaskDecorator = taskDecorator;
// task listeners
initializeTaskListeners(element, activity, context, taskDefinition);
}
protected internal virtual void initializeVariableOnParts(CmmnElement element, CmmnSentryDeclaration sentryDeclaration, CmmnHandlerContext context, IList <CamundaVariableOnPart> variableOnParts)
{
foreach (CamundaVariableOnPart variableOnPart in variableOnParts)
{
initializeVariableOnPart(variableOnPart, sentryDeclaration, context);
}
}
protected internal virtual void initializeOutputParameter(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context, CallableElement callableElement)
{
ExpressionManager expressionManager = context.ExpressionManager;
IList <CamundaOut> outputs = getOutputs(element);
foreach (CamundaOut output in outputs)
{
// create new parameter
CallableElementParameter parameter = new CallableElementParameter();
callableElement.addOutput(parameter);
// all variables
string variables = output.CamundaVariables;
if ("all".Equals(variables))
{
parameter.AllVariables = true;
continue;
}
// source/sourceExpression
string source = output.CamundaSource;
if (string.ReferenceEquals(source, null) || source.Length == 0)
{
source = output.CamundaSourceExpression;
}
ParameterValueProvider sourceValueProvider = createParameterValueProvider(source, expressionManager);
parameter.SourceValueProvider = sourceValueProvider;
// target
string target = output.CamundaTarget;
parameter.Target = target;
}
}
protected internal virtual CaseDefinitionEntity createActivity(CmmnElement element, CmmnHandlerContext context)
{
CaseDefinitionEntity definition = new CaseDefinitionEntity();
definition.CmmnElement = element;
return(definition);
}
protected internal override void initializeAutoComplete(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context)
{
PlanItemDefinition definition = getDefinition(element);
if (definition is Stage)
{
Stage stage = (Stage)definition;
activity.setProperty(PROPERTY_AUTO_COMPLETE, stage.AutoComplete);
}
}
protected internal override void initializeCallableElement(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context)
{
base.initializeCallableElement(element, activity, context);
ProcessOrCaseTaskActivityBehavior behavior = (ProcessOrCaseTaskActivityBehavior)activity.ActivityBehavior;
CallableElement callableElement = behavior.CallableElement;
// inputs
initializeInputParameter(element, activity, context, callableElement);
// outputs
initializeOutputParameter(element, activity, context, callableElement);
}
protected internal virtual void initializeTaskDefinitionPriority(CmmnElement element, TaskDefinition taskDefinition, CmmnHandlerContext context)
{
HumanTask definition = getDefinition(element);
string priority = definition.CamundaPriority;
if (!string.ReferenceEquals(priority, null))
{
ExpressionManager expressionManager = context.ExpressionManager;
Expression priorityExpression = expressionManager.createExpression(priority);
taskDefinition.PriorityExpression = priorityExpression;
}
}
protected internal virtual void initializeTaskDefinitionFollowUpDate(CmmnElement element, TaskDefinition taskDefinition, CmmnHandlerContext context)
{
HumanTask definition = getDefinition(element);
string followUpDate = definition.CamundaFollowUpDate;
if (!string.ReferenceEquals(followUpDate, null))
{
ExpressionManager expressionManager = context.ExpressionManager;
Expression followUpDateExpression = expressionManager.createExpression(followUpDate);
taskDefinition.FollowUpDateExpression = followUpDateExpression;
}
}
protected internal virtual void initializeTaskDefinitionCandidateGroups(CmmnElement element, TaskDefinition taskDefinition, CmmnHandlerContext context)
{
HumanTask definition = getDefinition(element);
ExpressionManager expressionManager = context.ExpressionManager;
IList <string> candidateGroups = definition.CamundaCandidateGroupsList;
foreach (string candidateGroup in candidateGroups)
{
Expression candidateGroupExpression = expressionManager.createExpression(candidateGroup);
taskDefinition.addCandidateGroupIdExpression(candidateGroupExpression);
}
}
protected internal virtual void initializeInputParameter(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context, CallableElement callableElement)
{
ExpressionManager expressionManager = context.ExpressionManager;
IList <CamundaIn> inputs = getInputs(element);
foreach (CamundaIn input in inputs)
{
// businessKey
string businessKey = input.CamundaBusinessKey;
if (!string.ReferenceEquals(businessKey, null) && businessKey.Length > 0)
{
ParameterValueProvider businessKeyValueProvider = createParameterValueProvider(businessKey, expressionManager);
callableElement.BusinessKeyValueProvider = businessKeyValueProvider;
}
else
{
// create new parameter
CallableElementParameter parameter = new CallableElementParameter();
callableElement.addInput(parameter);
if (input.CamundaLocal)
{
parameter.ReadLocal = true;
}
// all variables
string variables = input.CamundaVariables;
if ("all".Equals(variables))
{
parameter.AllVariables = true;
continue;
}
// source/sourceExpression
string source = input.CamundaSource;
if (string.ReferenceEquals(source, null) || source.Length == 0)
{
source = input.CamundaSourceExpression;
}
ParameterValueProvider sourceValueProvider = createParameterValueProvider(source, expressionManager);
parameter.SourceValueProvider = sourceValueProvider;
// target
string target = input.CamundaTarget;
parameter.Target = target;
}
}
}
protected internal virtual IList <V> queryExtensionElementsByClass <V>(CmmnElement element, Type cls) where V : org.camunda.bpm.model.xml.instance.ModelElementInstance
{
cls = typeof(V);
ExtensionElements extensionElements = element.ExtensionElements;
if (extensionElements != null)
{
Query <ModelElementInstance> query = extensionElements.ElementsQuery;
return(query.filterByType(cls).list());
}
else
{
return(new List <V>());
}
}
public override CmmnActivity handleElement(CmmnElement element, CmmnHandlerContext context)
{
HumanTask definition = getDefinition(element);
if (!definition.Blocking)
{
// The CMMN 1.0 specification says:
// When a HumanTask is not 'blocking' (isBlocking is 'false'),
// it can be considered a 'manual' Task, i.e., the Case management
// system is not tracking the lifecycle of the HumanTask (instance).
return(null);
}
return(base.handleElement(element, context));
}
protected internal virtual void initializeTaskDefinitionName(CmmnElement element, TaskDefinition taskDefinition, CmmnHandlerContext context)
{
string name = getName(element);
if (string.ReferenceEquals(name, null))
{
HumanTask definition = getDefinition(element);
name = definition.Name;
}
if (!string.ReferenceEquals(name, null))
{
ExpressionManager expressionManager = context.ExpressionManager;
Expression nameExpression = expressionManager.createExpression(name);
taskDefinition.NameExpression = nameExpression;
}
}
protected internal virtual void initializeTaskDescription(CmmnElement element, TaskDefinition taskDefinition, CmmnHandlerContext context)
{
string description = getDesciption(element);
if (!string.ReferenceEquals(description, null) && description.Length > 0)
{
ExpressionManager expressionManager = context.ExpressionManager;
Expression descriptionExpression = expressionManager.createExpression(description);
taskDefinition.DescriptionExpression = descriptionExpression;
}
else
{
string documentation = getDocumentation(element);
if (!string.ReferenceEquals(documentation, null) && documentation.Length > 0)
{
ExpressionManager expressionManager = context.ExpressionManager;
Expression documentationExpression = expressionManager.createExpression(documentation);
taskDefinition.DescriptionExpression = documentationExpression;
}
}
}
protected internal virtual TaskDefinition createTaskDefinition(CmmnElement element, CmmnHandlerContext context)
{
Deployment deployment = context.Deployment;
string deploymentId = deployment.Id;
// at the moment a default task form handler is only supported,
// custom task form handler are not supported.
DefaultTaskFormHandler taskFormHandler = new DefaultTaskFormHandler();
taskFormHandler.DeploymentId = deploymentId;
// create new taskDefinition
TaskDefinition taskDefinition = new TaskDefinition(taskFormHandler);
// the plan item id will be handled as taskDefinitionKey
string taskDefinitionKey = element.Id;
taskDefinition.Key = taskDefinitionKey;
// name
initializeTaskDefinitionName(element, taskDefinition, context);
// dueDate
initializeTaskDefinitionDueDate(element, taskDefinition, context);
// followUp
initializeTaskDefinitionFollowUpDate(element, taskDefinition, context);
// priority
initializeTaskDefinitionPriority(element, taskDefinition, context);
// assignee
initializeTaskDefinitionAssignee(element, taskDefinition, context);
// candidateUsers
initializeTaskDefinitionCandidateUsers(element, taskDefinition, context);
// candidateGroups
initializeTaskDefinitionCandidateGroups(element, taskDefinition, context);
// formKey
initializeTaskDefinitionFormKey(element, taskDefinition, context);
// description
initializeTaskDescription(element, taskDefinition, context);
return(taskDefinition);
}
protected internal virtual TaskListener initializeTaskListener(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context, CamundaTaskListener listener)
{
ICollection <CamundaField> fields = listener.CamundaFields;
IList <FieldDeclaration> fieldDeclarations = initializeFieldDeclarations(element, activity, context, fields);
ExpressionManager expressionManager = context.ExpressionManager;
TaskListener taskListener = null;
string className = listener.CamundaClass;
string expression = listener.CamundaExpression;
string delegateExpression = listener.CamundaDelegateExpression;
CamundaScript scriptElement = listener.CamundaScript;
if (!string.ReferenceEquals(className, null))
{
taskListener = new ClassDelegateTaskListener(className, fieldDeclarations);
}
else if (!string.ReferenceEquals(expression, null))
{
Expression expressionExp = expressionManager.createExpression(expression);
taskListener = new ExpressionTaskListener(expressionExp);
}
else if (!string.ReferenceEquals(delegateExpression, null))
{
Expression delegateExp = expressionManager.createExpression(delegateExpression);
taskListener = new DelegateExpressionTaskListener(delegateExp, fieldDeclarations);
}
else if (scriptElement != null)
{
ExecutableScript executableScript = initializeScript(element, activity, context, scriptElement);
if (executableScript != null)
{
taskListener = new ScriptTaskListener(executableScript);
}
}
return(taskListener);
}
protected internal virtual void initializeTaskDefinitionAssignee(CmmnElement element, TaskDefinition taskDefinition, CmmnHandlerContext context)
{
HumanTask definition = getDefinition(element);
Role performer = definition.Performer;
string assignee = null;
if (performer != null)
{
assignee = performer.Name;
}
else
{
assignee = definition.CamundaAssignee;
}
if (!string.ReferenceEquals(assignee, null))
{
ExpressionManager expressionManager = context.ExpressionManager;
Expression assigneeExpression = expressionManager.createExpression(assignee);
taskDefinition.AssigneeExpression = assigneeExpression;
}
}
protected internal virtual void initializeTaskListeners(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context, TaskDefinition taskDefinition)
{
HumanTask humanTask = getDefinition(element);
IList <CamundaTaskListener> listeners = queryExtensionElementsByClass(humanTask, typeof(CamundaTaskListener));
foreach (CamundaTaskListener listener in listeners)
{
TaskListener taskListener = initializeTaskListener(element, activity, context, listener);
string eventName = listener.CamundaEvent;
if (!string.ReferenceEquals(eventName, null))
{
taskDefinition.addTaskListener(eventName, taskListener);
}
else
{
taskDefinition.addTaskListener([email protected]_Fields.EVENTNAME_CREATE, taskListener);
taskDefinition.addTaskListener([email protected]_Fields.EVENTNAME_ASSIGNMENT, taskListener);
taskDefinition.addTaskListener([email protected]_Fields.EVENTNAME_COMPLETE, taskListener);
taskDefinition.addTaskListener([email protected]_Fields.EVENTNAME_DELETE, taskListener);
}
}
}
protected internal virtual IList <CamundaOut> getOutputs(CmmnElement element)
{
PlanItemDefinition definition = getDefinition(element);
return(queryExtensionElementsByClass(definition, typeof(CamundaOut)));
}
protected internal override IList <string> getStandardEvents(CmmnElement element)
{
return(TASK_OR_STAGE_EVENTS);
}
protected internal override void initializeExitCriterias(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context)
{
// exit criteria is not applicable on milestones
}
protected internal override void initializeManualActivationRule(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context)
{
// manual activation rule is not applicable on milestones
}
protected internal override IList <string> getStandardEvents(CmmnElement element)
{
return(EVENT_LISTENER_OR_MILESTONE_EVENTS);
}
protected internal override void initializeRequiredRule(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context)
{
// required rule is not applicable on event listeners
}
protected internal override void initializeEntryCriterias(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context)
{
// entry criteria is not applicable on event listeners
}
protected internal override IList <string> getStandardEvents(CmmnElement element)
{
return(CASE_PLAN_MODEL_EVENTS);
}
protected internal override PlanItemDefinition getDefinition(CmmnElement element)
{
return((PlanItemDefinition)element);
}
protected internal virtual void initializeBlocking(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context)
{
Task task = (Task)getDefinition(element);
activity.setProperty("isBlocking", task.Blocking);
}
protected internal override HumanTask getDefinition(CmmnElement element)
{
return((HumanTask)base.getDefinition(element));
}
protected internal override void initializeActivity(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context)
{
base.initializeActivity(element, activity, context);
initializeBlocking(element, activity, context);
}
