protected internal virtual void parseFormField(Element formField, BpmnParse bpmnParse, ExpressionManager expressionManager)
{
FormFieldHandler formFieldHandler = new FormFieldHandler();
// parse Id
string id = formField.attribute("id");
if (string.ReferenceEquals(id, null) || id.Length == 0)
{
bpmnParse.addError("attribute id must be set for FormFieldGroup and must have a non-empty value", formField);
}
else
{
formFieldHandler.Id = id;
}
if (id.Equals(businessKeyFieldId))
{
formFieldHandler.BusinessKey = true;
}
// parse name
string name = formField.attribute("label");
if (!string.ReferenceEquals(name, null))
{
Expression nameExpression = expressionManager.createExpression(name);
formFieldHandler.Label = nameExpression;
}
// parse properties
parseProperties(formField, formFieldHandler, bpmnParse, expressionManager);
// parse validation
parseValidation(formField, formFieldHandler, bpmnParse, expressionManager);
// parse type
FormTypes formTypes = FormTypes;
AbstractFormFieldType formType = formTypes.parseFormPropertyType(formField, bpmnParse);
formFieldHandler.setType(formType);
// parse default value
string defaultValue = formField.attribute("defaultValue");
if (!string.ReferenceEquals(defaultValue, null))
{
Expression defaultValueExpression = expressionManager.createExpression(defaultValue);
formFieldHandler.DefaultValueExpression = defaultValueExpression;
}
formFieldHandlers.Add(formFieldHandler);
}
/// <exception cref="BpmnParseException"> if the parameter is invalid </exception>
protected internal static ParameterValueProvider parseParamValueProvider(Element parameterElement)
{
// LIST
if ("list".Equals(parameterElement.TagName))
{
IList <ParameterValueProvider> providerList = new List <ParameterValueProvider>();
foreach (Element element in parameterElement.elements())
{
// parse nested provider
providerList.Add(parseParamValueProvider(element));
}
return(new ListValueProvider(providerList));
}
// MAP
if ("map".Equals(parameterElement.TagName))
{
SortedDictionary <ParameterValueProvider, ParameterValueProvider> providerMap = new SortedDictionary <ParameterValueProvider, ParameterValueProvider>();
foreach (Element entryElement in parameterElement.elements("entry"))
{
// entry must provide key
string keyAttribute = entryElement.attribute("key");
if (string.ReferenceEquals(keyAttribute, null) || keyAttribute.Length == 0)
{
throw new BpmnParseException("Missing attribute 'key' for 'entry' element", entryElement);
}
// parse nested provider
providerMap[new ElValueProvider(ExpressionManager.createExpression(keyAttribute))] = parseNestedParamValueProvider(entryElement);
}
return(new MapValueProvider(providerMap));
}
// SCRIPT
if ("script".Equals(parameterElement.TagName))
{
ExecutableScript executableScript = parseCamundaScript(parameterElement);
if (executableScript != null)
{
return(new ScriptValueProvider(executableScript));
}
else
{
return(new NullValueProvider());
}
}
string textContent = parameterElement.Text.Trim();
if (textContent.Length > 0)
{
// EL
return(new ElValueProvider(ExpressionManager.createExpression(textContent)));
}
else
{
// NULL value
return(new NullValueProvider());
}
}
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 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 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 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 CaseControlRule initializeCaseControlRule(ConditionExpression condition, CmmnHandlerContext context)
{
Expression expression = null;
if (condition != null)
{
string rule = condition.Text;
if (!string.ReferenceEquals(rule, null) && rule.Length > 0)
{
ExpressionManager expressionManager = context.ExpressionManager;
expression = expressionManager.createExpression(rule);
}
}
return(new CaseControlRuleImpl(expression));
}
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;
}
}
/// <summary>
/// factory method for creating validator instances
///
/// </summary>
public virtual FormFieldValidator createValidator(Element constraint, BpmnParse bpmnParse, ExpressionManager expressionManager)
{
string name = constraint.attribute("name");
string config = constraint.attribute("config");
if ("validator".Equals(name))
{
// custom validators
if (string.ReferenceEquals(config, null) || config.Length == 0)
{
bpmnParse.addError("validator configuration needs to provide either a fully " + "qualified classname or an expression resolving to a custom FormFieldValidator implementation.", constraint);
}
else
{
if (StringUtil.isExpression(config))
{
// expression
Expression validatorExpression = expressionManager.createExpression(config);
return(new DelegateFormFieldValidator(validatorExpression));
}
else
{
// classname
return(new DelegateFormFieldValidator(config));
}
}
}
else
{
// built-in validators
Type validator = validators[name];
if (validator != null)
{
FormFieldValidator validatorInstance = createValidatorInstance(validator);
return(validatorInstance);
}
else
{
bpmnParse.addError("Cannot find validator implementation for name '" + name + "'.", constraint);
}
}
return(null);
}
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;
}
}
}
public static FailedJobRetryConfiguration parseRetryIntervals(string retryIntervals)
{
if (!string.ReferenceEquals(retryIntervals, null) && retryIntervals.Length > 0)
{
if (StringUtil.isExpression(retryIntervals))
{
ExpressionManager expressionManager = Context.ProcessEngineConfiguration.ExpressionManager;
Expression expression = expressionManager.createExpression(retryIntervals);
return(new FailedJobRetryConfiguration(expression));
}
string[] intervals = StringUtil.Split(retryIntervals, ",");
int retries = intervals.Length + 1;
if (intervals.Length == 1)
{
try
{
DurationHelper durationHelper = new DurationHelper(intervals[0]);
if (durationHelper.Repeat)
{
retries = durationHelper.Times;
}
}
catch (Exception e)
{
LOG.logParsingRetryIntervals(intervals[0], e);
return(null);
}
}
return(new FailedJobRetryConfiguration(retries, Arrays.asList(intervals)));
}
else
{
return(null);
}
}
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 Expression getExpressionValue(CamundaField field, ExpressionManager expressionManager)
{
CamundaExpression expression = field.CamundaExpressionChild;
string value = null;
if (expression != null)
{
value = expression.TextContent;
}
if (string.ReferenceEquals(value, null))
{
value = field.CamundaExpression;
}
if (!string.ReferenceEquals(value, null))
{
return(expressionManager.createExpression(value));
}
return(null);
}
protected internal virtual void initializeIfPart(IfPart ifPart, CmmnSentryDeclaration sentryDeclaration, CmmnHandlerContext context)
{
if (ifPart == null)
{
return;
}
ICollection <ConditionExpression> conditions = ifPart.Conditions;
if (conditions.Count > 1)
{
string id = sentryDeclaration.Id;
LOG.multipleIgnoredConditions(id);
}
ExpressionManager expressionManager = context.ExpressionManager;
ConditionExpression condition = conditions.GetEnumerator().next();
Expression conditionExpression = expressionManager.createExpression(condition.Text);
CmmnIfPartDeclaration ifPartDeclaration = new CmmnIfPartDeclaration();
ifPartDeclaration.Condition = conditionExpression;
sentryDeclaration.IfPart = ifPartDeclaration;
}
protected internal virtual void parseFormProperties(BpmnParse bpmnParse, ExpressionManager expressionManager, Element extensionElement)
{
FormTypes formTypes = FormTypes;
IList <Element> formPropertyElements = extensionElement.elementsNS(BpmnParse.CAMUNDA_BPMN_EXTENSIONS_NS, FORM_PROPERTY_ELEMENT);
foreach (Element formPropertyElement in formPropertyElements)
{
FormPropertyHandler formPropertyHandler = new FormPropertyHandler();
string id = formPropertyElement.attribute("id");
if (string.ReferenceEquals(id, null))
{
bpmnParse.addError("attribute 'id' is required", formPropertyElement);
}
formPropertyHandler.Id = id;
string name = formPropertyElement.attribute("name");
formPropertyHandler.Name = name;
AbstractFormFieldType type = formTypes.parseFormPropertyType(formPropertyElement, bpmnParse);
formPropertyHandler.setType(type);
string requiredText = formPropertyElement.attribute("required", "false");
bool? required = bpmnParse.parseBooleanAttribute(requiredText);
if (required != null)
{
formPropertyHandler.Required = required.Value;
}
else
{
bpmnParse.addError("attribute 'required' must be one of {on|yes|true|enabled|active|off|no|false|disabled|inactive}", formPropertyElement);
}
string readableText = formPropertyElement.attribute("readable", "true");
bool? readable = bpmnParse.parseBooleanAttribute(readableText);
if (readable != null)
{
formPropertyHandler.Readable = readable.Value;
}
else
{
bpmnParse.addError("attribute 'readable' must be one of {on|yes|true|enabled|active|off|no|false|disabled|inactive}", formPropertyElement);
}
string writableText = formPropertyElement.attribute("writable", "true");
bool? writable = bpmnParse.parseBooleanAttribute(writableText);
if (writable != null)
{
formPropertyHandler.Writable = writable.Value;
}
else
{
bpmnParse.addError("attribute 'writable' must be one of {on|yes|true|enabled|active|off|no|false|disabled|inactive}", formPropertyElement);
}
string variableName = formPropertyElement.attribute("variable");
formPropertyHandler.VariableName = variableName;
string expressionText = formPropertyElement.attribute("expression");
if (!string.ReferenceEquals(expressionText, null))
{
Expression expression = expressionManager.createExpression(expressionText);
formPropertyHandler.VariableExpression = expression;
}
string defaultExpressionText = formPropertyElement.attribute("default");
if (!string.ReferenceEquals(defaultExpressionText, null))
{
Expression defaultExpression = expressionManager.createExpression(defaultExpressionText);
formPropertyHandler.DefaultExpression = defaultExpression;
}
formPropertyHandlers.Add(formPropertyHandler);
}
}
/// <summary>
/// Checks whether a <seealso cref="string"/> seams to be a composite expression or not. In contrast to an eval expression
/// is the composite expression also allowed to consist of a combination of literal and eval expressions, e.g.,
/// "Welcome ${customer.name} to our site".
///
/// Note: If you just want to allow eval expression, then the expression must always start with "#{" or "${".
/// Use <seealso cref="isExpression(string)"/> to conduct these kind of checks.
///
/// </summary>
public static bool isCompositeExpression(string text, ExpressionManager expressionManager)
{
return(!expressionManager.createExpression(text).LiteralText);
}