protected internal virtual string getDocumentation(CmmnElement element)
{
ICollection <Documentation> documentations = element.Documentations;
if (documentations.Count == 0)
{
PlanItemDefinition definition = getDefinition(element);
documentations = definition.Documentations;
}
if (documentations.Count == 0)
{
return(null);
}
StringBuilder builder = new StringBuilder();
foreach (Documentation doc in documentations)
{
string content = doc.TextContent;
if (string.ReferenceEquals(content, null) || content.Length == 0)
{
continue;
}
if (builder.Length != 0)
{
builder.Append("\n\n");
}
builder.Append(content.Trim());
}
return(builder.ToString());
}
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 virtual string getDesciption(CmmnElement element)
{
string description = element.Description;
if (string.ReferenceEquals(description, null))
{
PlanItemDefinition definition = getDefinition(element);
description = definition.Description;
}
return(description);
}
protected internal virtual void initializeActivity(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context)
{
if (isDiscretionaryItem(element))
{
activity.setProperty(PROPERTY_DISCRETIONARY, true);
}
string name = getName(element);
if (string.ReferenceEquals(name, null))
{
PlanItemDefinition definition = getDefinition(element);
if (definition != null)
{
name = definition.Name;
}
}
activity.Name = name;
// activityType
initializeActivityType(element, activity, context);
// description
initializeDescription(element, activity, context);
// autoComplete
initializeAutoComplete(element, activity, context);
// requiredRule
initializeRequiredRule(element, activity, context);
// manualActivation
initializeManualActivationRule(element, activity, context);
// repetitionRule
initializeRepetitionRule(element, activity, context);
// case execution listeners
initializeCaseExecutionListeners(element, activity, context);
// variable listeners
initializeVariableListeners(element, activity, context);
// initialize entry criteria
initializeEntryCriterias(element, activity, context);
// initialize exit criteria
initializeExitCriterias(element, activity, context);
}
protected internal virtual void initializeActivityType(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context)
{
PlanItemDefinition definition = getDefinition(element);
string activityType = null;
if (definition != null)
{
ModelElementType elementType = definition.ElementType;
if (elementType != null)
{
activityType = elementType.TypeName;
}
}
activity.setProperty(PROPERTY_ACTIVITY_TYPE, activityType);
}
protected internal virtual string getName(CmmnElement element)
{
string name = null;
if (isPlanItem(element))
{
PlanItem planItem = (PlanItem)element;
name = planItem.Name;
}
if (string.ReferenceEquals(name, null) || name.Length == 0)
{
PlanItemDefinition definition = getDefinition(element);
if (definition != null)
{
name = definition.Name;
}
}
return(name);
}
protected internal virtual void initializeVariableListeners(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context)
{
PlanItemDefinition definition = getDefinition(element);
IList <CamundaVariableListener> listeners = queryExtensionElementsByClass(definition, typeof(CamundaVariableListener));
foreach (CamundaVariableListener listener in listeners)
{
CaseVariableListener variableListener = initializeVariableListener(element, activity, context, listener);
string eventName = listener.CamundaEvent;
if (!string.ReferenceEquals(eventName, null))
{
activity.addVariableListener(eventName, variableListener);
}
else
{
foreach (string @event in DEFAULT_VARIABLE_EVENTS)
{
activity.addVariableListener(@event, variableListener);
}
}
}
}
protected internal virtual void initializeCaseExecutionListeners(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context)
{
PlanItemDefinition definition = getDefinition(element);
IList <CamundaCaseExecutionListener> listeners = queryExtensionElementsByClass(definition, typeof(CamundaCaseExecutionListener));
foreach (CamundaCaseExecutionListener listener in listeners)
{
CaseExecutionListener caseExecutionListener = initializeCaseExecutionListener(element, activity, context, listener);
string eventName = listener.CamundaEvent;
if (!string.ReferenceEquals(eventName, null))
{
activity.addListener(eventName, caseExecutionListener);
}
else
{
foreach (string @event in getStandardEvents(element))
{
activity.addListener(@event, caseExecutionListener);
}
}
}
}
protected internal virtual IList <CamundaOut> getOutputs(CmmnElement element)
{
PlanItemDefinition definition = getDefinition(element);
return(queryExtensionElementsByClass(definition, typeof(CamundaOut)));
}
protected internal virtual void transformPlanItem(PlanItem planItem, CmmnActivity parent)
{
PlanItemDefinition definition = planItem.Definition;
ItemHandler planItemTransformer = null;
if (definition is HumanTask)
{
planItemTransformer = getPlanItemHandler(typeof(HumanTask));
}
else if (definition is ProcessTask)
{
planItemTransformer = getPlanItemHandler(typeof(ProcessTask));
}
else if (definition is CaseTask)
{
planItemTransformer = getPlanItemHandler(typeof(CaseTask));
}
else if (definition is DecisionTask)
{
planItemTransformer = getPlanItemHandler(typeof(DecisionTask));
}
else if (definition is Task)
{
planItemTransformer = getPlanItemHandler(typeof(Task));
}
else if (definition is Stage)
{
planItemTransformer = getPlanItemHandler(typeof(Stage));
}
else if (definition is Milestone)
{
planItemTransformer = getPlanItemHandler(typeof(Milestone));
}
else if (definition is EventListener)
{
planItemTransformer = getPlanItemHandler(typeof(EventListener));
}
if (planItemTransformer != null)
{
CmmnActivity newActivity = planItemTransformer.handleElement(planItem, context);
if (definition is Stage)
{
Stage stage = (Stage)definition;
transformStage(stage, newActivity);
context.Parent = parent;
}
else if (definition is HumanTask)
{
HumanTask humanTask = (HumanTask)definition;
// According to the specification: A HumanTask can only contain
// one planningTable, the XSD allows multiple planningTables!
ICollection <PlanningTable> planningTables = humanTask.PlanningTables;
foreach (PlanningTable planningTable in planningTables)
{
transformPlanningTable(planningTable, parent);
}
}
foreach (CmmnTransformListener transformListener in transformListeners)
{
if (definition is HumanTask)
{
transformListener.transformHumanTask(planItem, (HumanTask)definition, newActivity);
}
else if (definition is ProcessTask)
{
transformListener.transformProcessTask(planItem, (ProcessTask)definition, newActivity);
}
else if (definition is CaseTask)
{
transformListener.transformCaseTask(planItem, (CaseTask)definition, newActivity);
}
else if (definition is DecisionTask)
{
transformListener.transformDecisionTask(planItem, (DecisionTask)definition, newActivity);
}
else if (definition is Task)
{
transformListener.transformTask(planItem, (Task)definition, newActivity);
}
else if (definition is Stage)
{
transformListener.transformStage(planItem, (Stage)definition, newActivity);
}
else if (definition is Milestone)
{
transformListener.transformMilestone(planItem, (Milestone)definition, newActivity);
}
else if (definition is EventListener)
{
transformListener.transformEventListener(planItem, (EventListener)definition, newActivity);
}
}
}
}
protected internal virtual PlanItemControl getDefaultControl(CmmnElement element)
{
PlanItemDefinition definition = getDefinition(element);
return(definition.DefaultControl);
}
