protected internal virtual void CreateMultiInstanceLoopCharacteristics(BpmnParse bpmnParse, Activity modelActivity)
{
MultiInstanceLoopCharacteristics loopCharacteristics = modelActivity.LoopCharacteristics;
// Activity Behavior
MultiInstanceActivityBehavior miActivityBehavior;
if (loopCharacteristics.Sequential)
{
miActivityBehavior = bpmnParse.ActivityBehaviorFactory.CreateSequentialMultiInstanceBehavior(modelActivity, (AbstractBpmnActivityBehavior)modelActivity.Behavior);
}
else
{
miActivityBehavior = bpmnParse.ActivityBehaviorFactory.CreateParallelMultiInstanceBehavior(modelActivity, (AbstractBpmnActivityBehavior)modelActivity.Behavior);
}
modelActivity.Behavior = miActivityBehavior;
ExpressionManager expressionManager = Context.ProcessEngineConfiguration.ExpressionManager;
// loop cardinality
if (!string.IsNullOrWhiteSpace(loopCharacteristics.LoopCardinality))
{
miActivityBehavior.LoopCardinalityExpression = expressionManager.CreateExpression(loopCharacteristics.LoopCardinality);
}
// completion condition
if (!string.IsNullOrWhiteSpace(loopCharacteristics.CompletionCondition))
{
miActivityBehavior.CompletionConditionExpression = expressionManager.CreateExpression(loopCharacteristics.CompletionCondition);
}
// activiti:collection
if (!string.IsNullOrWhiteSpace(loopCharacteristics.InputDataItem))
{
if (loopCharacteristics.InputDataItem.Contains("{"))
{
miActivityBehavior.CollectionExpression = expressionManager.CreateExpression(loopCharacteristics.InputDataItem);
}
else
{
miActivityBehavior.CollectionVariable = loopCharacteristics.InputDataItem;
}
}
// activiti:elementVariable
if (!string.IsNullOrWhiteSpace(loopCharacteristics.ElementVariable))
{
miActivityBehavior.CollectionElementVariable = loopCharacteristics.ElementVariable;
}
// activiti:elementIndexVariable
if (!string.IsNullOrWhiteSpace(loopCharacteristics.ElementIndexVariable))
{
miActivityBehavior.CollectionElementIndexVariable = loopCharacteristics.ElementIndexVariable;
}
}
protected internal virtual void ParseFormField(Element formField, BpmnParse bpmnParse,
ExpressionManager expressionManager)
{
var formFieldHandler = new FormFieldHandler();
// parse Id
var id = formField.GetAttributeValue("id");
if (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
var name = formField.GetAttributeValue("label");
if (!ReferenceEquals(name, null))
{
IExpression nameExpression = (Bpm.Engine.Impl.EL.IExpression)expressionManager.CreateExpression(name);
formFieldHandler.Label = nameExpression;
}
// parse properties
ParseProperties(formField, formFieldHandler, bpmnParse, expressionManager);
// parse validation
ParseValidation(formField, formFieldHandler, bpmnParse, expressionManager);
// parse type
var formTypes = FormTypes;
var formType = formTypes.ParseFormPropertyType(formField, bpmnParse);
formFieldHandler.SetType(formType);
// parse default value
var defaultValue = formField.GetAttributeValue("defaultValue");
if (!ReferenceEquals(defaultValue, null))
{
IExpression defaultValueExpression = (Bpm.Engine.Impl.EL.IExpression)expressionManager.CreateExpression(defaultValue);
formFieldHandler.DefaultValueExpression = defaultValueExpression;
}
FormFieldHandlers.Add(formFieldHandler);
}
private void ApplyChanges()
{
if (m_currentExpression != null)
{
if (m_currentExpression.Id != m_exprIdTxt.Text)
{
throw new Exception("UI is out of sync with data");
}
// apply changes.
m_mgr.As <ITransactionContext>().DoTransaction(delegate
{
m_currentExpression.Label = m_exprLabelTxt.Text;
m_currentExpression.Script = m_exprTxt.Text;
}, "Edit expression".Localize()
);
m_numOfOperation++;
}
else if (!string.IsNullOrWhiteSpace(m_exprTxt.Text))
{
Expression expr = m_mgr.CreateExpression();
expr.Label = m_exprLabelTxt.Text;
expr.Script = m_exprTxt.Text;
m_mgr.As <ITransactionContext>().DoTransaction(delegate
{
m_mgr.Expressions.Add(expr);
}, "Add expression".Localize()
);
m_numOfOperation++;
SetActiveExpression(expr);
}
}
/// <summary>
/// Creates an <seealso cref="IExpression"/> for the <seealso cref="FieldExtension"/>.
/// </summary>
public static IExpression CreateExpressionForField(FieldExtension fieldExtension)
{
if (!string.IsNullOrWhiteSpace(fieldExtension.Expression))
{
ExpressionManager expressionManager = Context.ProcessEngineConfiguration.ExpressionManager;
return(expressionManager.CreateExpression(fieldExtension.Expression));
}
else
{
return(new FixedValue(fieldExtension.StringValue));
}
}
/// <summary>
/// Creates a new <seealso cref="ExecutableScript" /> from a source. It excepts static and dynamic sources.
/// Dynamic means that the source is an expression which will be evaluated during execution.
/// </summary>
/// <param name="language"> the language of the script </param>
/// <param name="source"> the source code of the script or an expression which evaluates to the source code </param>
/// <param name="expressionManager"> the expression manager to use to generate the expressions of dynamic scripts </param>
/// <param name="scriptFactory"> the script factory used to create the script </param>
/// <returns> the newly created script </returns>
/// <exception cref="NotValidException"> if language is null or empty or source is null </exception>
public static ExecutableScript GetScriptFormSource(string language, string source,
ExpressionManager expressionManager, ScriptFactory scriptFactory)
{
EnsureUtil.EnsureNotEmpty(typeof(NotValidException), "Script language", language);
EnsureUtil.EnsureNotNull(typeof(NotValidException), "Script source", source);
if (IsDynamicScriptExpression(language, source))
{
IExpression sourceExpression = expressionManager.CreateExpression(source);
return(GetScriptFromSourceExpression(language, sourceExpression, scriptFactory));
}
return(GetScriptFromSource(language, source, scriptFactory));
}
protected internal virtual AbstractDataAssociation CreateDataOutputAssociation(DataAssociation dataAssociationElement)
{
if (!string.IsNullOrWhiteSpace(dataAssociationElement.SourceRef))
{
return(new MessageImplicitDataOutputAssociation(dataAssociationElement.TargetRef, dataAssociationElement.SourceRef));
}
else
{
ExpressionManager expressionManager = Context.ProcessEngineConfiguration.ExpressionManager;
IExpression transformation = expressionManager.CreateExpression(dataAssociationElement.Transformation);
AbstractDataAssociation dataOutputAssociation = new TransformationDataOutputAssociation(null, dataAssociationElement.TargetRef, transformation);
return(dataOutputAssociation);
}
}
protected internal virtual AbstractDataAssociation CreateDataInputAssociation(DataAssociation dataAssociationElement)
{
if (dataAssociationElement.Assignments.Count == 0)
{
return(new MessageImplicitDataInputAssociation(dataAssociationElement.SourceRef, dataAssociationElement.TargetRef));
}
else
{
SimpleDataInputAssociation dataAssociation = new SimpleDataInputAssociation(dataAssociationElement.SourceRef, dataAssociationElement.TargetRef);
ExpressionManager expressionManager = Context.ProcessEngineConfiguration.ExpressionManager;
foreach (Assignment assignmentElement in dataAssociationElement.Assignments)
{
if (!string.IsNullOrWhiteSpace(assignmentElement.From) && !string.IsNullOrWhiteSpace(assignmentElement.To))
{
IExpression from = expressionManager.CreateExpression(assignmentElement.From);
IExpression to = expressionManager.CreateExpression(assignmentElement.To);
Datas.Assignment assignment = new Datas.Assignment(from, to);
dataAssociation.AddAssignment(assignment);
}
}
return(dataAssociation);
}
}
public virtual void Completing(IExecutionEntity execution, IExecutionEntity subProcessInstance)
{
// only data. no control flow available on this execution.
ExpressionManager expressionManager = Context.ProcessEngineConfiguration.ExpressionManager;
// copy process variables
CallActivity callActivity = (CallActivity)execution.CurrentFlowElement;
foreach (IOParameter ioParameter in callActivity.OutParameters)
{
object value = null;
if (!string.IsNullOrWhiteSpace(ioParameter.SourceExpression))
{
IExpression expression = expressionManager.CreateExpression(ioParameter.SourceExpression.Trim());
value = expression.GetValue(subProcessInstance);
}
else
{
value = subProcessInstance.GetVariable(ioParameter.Source);
}
execution.SetVariable(ioParameter.Target, value);
}
}
public override void Execute(IExecutionEntity execution)
{
string finalProcessDefinitonKey;
if (processDefinitionExpression != null)
{
finalProcessDefinitonKey = (string)processDefinitionExpression.GetValue(execution);
}
else
{
finalProcessDefinitonKey = processDefinitonKey;
}
IProcessDefinition processDefinition = FindProcessDefinition(finalProcessDefinitonKey, execution.TenantId);
// Get model from cache
Process subProcess = ProcessDefinitionUtil.GetProcess(processDefinition.Id);
if (subProcess == null)
{
throw new ActivitiException("Cannot start a sub process instance. Process model " + processDefinition.Name + " (id = " + processDefinition.Id + ") could not be found");
}
FlowElement initialFlowElement = subProcess.InitialFlowElement;
if (initialFlowElement == null)
{
throw new ActivitiException("No start element found for process definition " + processDefinition.Id);
}
// Do not start a process instance if the process definition is suspended
if (ProcessDefinitionUtil.IsProcessDefinitionSuspended(processDefinition.Id))
{
throw new ActivitiException("Cannot start process instance. Process definition " + processDefinition.Name + " (id = " + processDefinition.Id + ") is suspended");
}
ProcessEngineConfigurationImpl processEngineConfiguration = Context.ProcessEngineConfiguration;
IExecutionEntityManager executionEntityManager = Context.CommandContext.ExecutionEntityManager;
ExpressionManager expressionManager = processEngineConfiguration.ExpressionManager;
CallActivity callActivity = (CallActivity)execution.CurrentFlowElement;
string businessKey = null;
if (!string.IsNullOrWhiteSpace(callActivity.BusinessKey))
{
IExpression expression = expressionManager.CreateExpression(callActivity.BusinessKey);
businessKey = expression.GetValue(execution).ToString();
}
else if (callActivity.InheritBusinessKey)
{
IExecutionEntity processInstance = executionEntityManager.FindById <IExecutionEntity>(execution.ProcessInstanceId);
businessKey = processInstance.BusinessKey;
}
IExecutionEntity subProcessInstance = Context.CommandContext.ExecutionEntityManager.CreateSubprocessInstance(processDefinition, execution, businessKey);
Context.CommandContext.HistoryManager.RecordSubProcessInstanceStart(execution, subProcessInstance, initialFlowElement);
// process template-defined data objects
IDictionary <string, object> variables = ProcessDataObjects(subProcess.DataObjects);
if (callActivity.InheritVariables)
{
IDictionary <string, object> executionVariables = execution.Variables;
foreach (KeyValuePair <string, object> entry in executionVariables.SetOfKeyValuePairs())
{
variables[entry.Key] = entry.Value;
}
}
// copy process variables
foreach (IOParameter ioParameter in callActivity.InParameters)
{
object value = null;
if (!string.IsNullOrWhiteSpace(ioParameter.SourceExpression))
{
IExpression expression = expressionManager.CreateExpression(ioParameter.SourceExpression.Trim());
value = expression.GetValue(execution);
}
else
{
value = execution.GetVariable(ioParameter.Source);
}
variables[ioParameter.Target] = value;
}
if (variables.Count > 0)
{
InitializeVariables(subProcessInstance, variables);
}
// Create the first execution that will visit all the process definition elements
IExecutionEntity subProcessInitialExecution = executionEntityManager.CreateChildExecution(subProcessInstance);
subProcessInitialExecution.CurrentFlowElement = initialFlowElement;
Context.Agenda.PlanContinueProcessOperation(subProcessInitialExecution);
Context.ProcessEngineConfiguration.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateProcessStartedEvent(subProcessInitialExecution, variables, false));
}
protected internal virtual void ParseFormProperties(BpmnParse bpmnParse, ExpressionManager expressionManager,
Element extensionElement)
{
var formTypes = FormTypes;
var formPropertyElements = extensionElement.ElementsNS(BpmnParse.CamundaBpmnExtensionsNs,
FormPropertyElement);
foreach (var formPropertyElement in formPropertyElements)
{
var formPropertyHandler = new FormPropertyHandler();
var id = formPropertyElement.GetAttributeValue("id");
if (ReferenceEquals(id, null))
{
bpmnParse.AddError("attribute 'id' is required", formPropertyElement);
}
formPropertyHandler.Id = id;
var name = formPropertyElement.GetAttributeValue("name");
formPropertyHandler.Name = name;
var type = formTypes.ParseFormPropertyType(formPropertyElement, bpmnParse);
formPropertyHandler.SetType(type);
var requiredText = formPropertyElement.GetAttributeValue("required", "false");
var 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);
}
var readableText = formPropertyElement.GetAttributeValue("readable", "true");
var 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);
}
var writableText = formPropertyElement.GetAttributeValue("writable", "true");
var 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);
}
var variableName = formPropertyElement.GetAttributeValue("variable");
formPropertyHandler.VariableName = variableName;
var expressionText = formPropertyElement.GetAttributeValue("expression");
if (!ReferenceEquals(expressionText, null))
{
IExpression expression = (Bpm.Engine.Impl.EL.IExpression)expressionManager.CreateExpression(expressionText);
formPropertyHandler.VariableExpression = expression;
}
var defaultExpressionText = formPropertyElement.GetAttributeValue("default");
if (!ReferenceEquals(defaultExpressionText, null))
{
IExpression defaultExpression = (Bpm.Engine.Impl.EL.IExpression)expressionManager.CreateExpression(defaultExpressionText);
formPropertyHandler.DefaultExpression = defaultExpression;
}
FormPropertyHandlers.Add(formPropertyHandler);
}
}
public virtual void TestDecoratePriorityFromVariable()
{
// given
var aPriority = 10;
taskService.SetVariable(Task.Id, "priority", aPriority);
var priorityExpression = ExpressionManager.CreateExpression("${priority}");
TaskDefinition.PriorityExpression = priorityExpression;
// when
Decorate(Task, TaskDecorator);
// then
Assert.AreEqual(aPriority, Task.Priority);
}
/// <summary>
///
/// </summary>
/// <param name="execution"></param>
public override void Execute(IExecutionEntity execution)
{
ICommandContext commandContext = Context.CommandContext;
ITaskEntityManager taskEntityManager = commandContext.TaskEntityManager;
//如果当前任务为补偿任务，则修改任务的父级为流程实例
if ((execution.CurrentFlowElement as UserTask).ForCompensation)
{
execution.Parent = execution.ProcessInstance;
}
ITaskEntity task = taskEntityManager.Create();
task.Execution = execution;
task.TaskDefinitionKey = userTask.Id;
task.IsRuntimeAssignee();
task.CanTransfer = userTask.CanTransfer;
task.OnlyAssignee = task.OnlyAssignee;
ProcessEngineConfigurationImpl processEngineConfiguration = Context.ProcessEngineConfiguration;
ExpressionManager expressionManager = processEngineConfiguration.ExpressionManager;
string activeTaskName;
string activeTaskDescription;
string activeTaskDueDate;
string activeTaskCategory;
string activeTaskSkipExpression;
string activeTaskPriority;
string activeTaskFormKey;
string activeTaskAssignee;
string activeTaskOwner;
IList <string> activeTaskCandidateUsers;
IList <string> activeTaskCandidateGroups;
if (Context.ProcessEngineConfiguration.EnableProcessDefinitionInfoCache)
{
JToken taskElementProperties = Context.GetBpmnOverrideElementProperties(userTask.Id, execution.ProcessDefinitionId);
activeTaskName = GetActiveValue(userTask.Name, DynamicBpmnConstants.USER_TASK_NAME, taskElementProperties);
activeTaskDescription = GetActiveValue(userTask.Documentation, DynamicBpmnConstants.USER_TASK_DESCRIPTION, taskElementProperties);
activeTaskDueDate = GetActiveValue(userTask.DueDate, DynamicBpmnConstants.USER_TASK_DUEDATE, taskElementProperties);
activeTaskPriority = GetActiveValue(userTask.Priority, DynamicBpmnConstants.USER_TASK_PRIORITY, taskElementProperties);
activeTaskCategory = GetActiveValue(userTask.Category, DynamicBpmnConstants.USER_TASK_CATEGORY, taskElementProperties);
activeTaskFormKey = GetActiveValue(userTask.FormKey, DynamicBpmnConstants.USER_TASK_FORM_KEY, taskElementProperties);
activeTaskSkipExpression = GetActiveValue(userTask.SkipExpression, DynamicBpmnConstants.TASK_SKIP_EXPRESSION, taskElementProperties);
activeTaskAssignee = GetActiveValue(userTask.Assignee, DynamicBpmnConstants.USER_TASK_ASSIGNEE, taskElementProperties);
activeTaskOwner = GetActiveValue(userTask.Owner, DynamicBpmnConstants.USER_TASK_OWNER, taskElementProperties);
activeTaskCandidateUsers = GetActiveValueList(userTask.CandidateUsers, DynamicBpmnConstants.USER_TASK_CANDIDATE_USERS, taskElementProperties);
activeTaskCandidateGroups = GetActiveValueList(userTask.CandidateGroups, DynamicBpmnConstants.USER_TASK_CANDIDATE_GROUPS, taskElementProperties);
}
else
{
activeTaskName = userTask.Name;
activeTaskDescription = userTask.Documentation;
activeTaskDueDate = userTask.DueDate;
activeTaskPriority = userTask.Priority;
activeTaskCategory = userTask.Category;
activeTaskFormKey = userTask.FormKey;
activeTaskSkipExpression = userTask.SkipExpression;
activeTaskAssignee = userTask.Assignee;
activeTaskOwner = userTask.Owner;
activeTaskCandidateUsers = userTask.CandidateUsers;
activeTaskCandidateGroups = userTask.CandidateGroups;
}
if (!string.IsNullOrWhiteSpace(activeTaskName))
{
string name;
try
{
name = (string)expressionManager.CreateExpression(activeTaskName).GetValue(execution);
}
catch (ActivitiException e)
{
name = activeTaskName;
log.LogWarning("property not found in task name expression " + e.Message);
}
task.Name = name;
}
if (!string.IsNullOrWhiteSpace(activeTaskDescription))
{
string description;
try
{
description = (string)expressionManager.CreateExpression(activeTaskDescription).GetValue(execution);
}
catch (ActivitiException e)
{
description = activeTaskDescription;
log.LogWarning("property not found in task description expression " + e.Message);
}
task.Description = description;
}
if (!string.IsNullOrWhiteSpace(activeTaskDueDate))
{
object dueDate = expressionManager.CreateExpression(activeTaskDueDate).GetValue(execution);
if (dueDate != null)
{
if (dueDate is DateTime time)
{
task.DueDate = time;
}
else if (dueDate is string @string)
{
string businessCalendarName;
if (!string.IsNullOrWhiteSpace(userTask.BusinessCalendarName))
{
businessCalendarName = expressionManager.CreateExpression(userTask.BusinessCalendarName).GetValue(execution).ToString();
}
else
{
businessCalendarName = DueDateBusinessCalendar.NAME;
}
IBusinessCalendar businessCalendar = Context.ProcessEngineConfiguration.BusinessCalendarManager.GetBusinessCalendar(businessCalendarName);
task.DueDate = businessCalendar.ResolveDuedate(@string);
}
else
{
throw new ActivitiIllegalArgumentException("Due date expression does not resolve to a Date or Date string: " + activeTaskDueDate);
}
}
}
if (!string.IsNullOrWhiteSpace(activeTaskPriority))
{
object priority = expressionManager.CreateExpression(activeTaskPriority).GetValue(execution);
if (priority != null)
{
if (priority is string @string)
{
try
{
task.Priority = Convert.ToInt32(@string);
}
catch (FormatException e)
{
throw new ActivitiIllegalArgumentException("Priority does not resolve to a number: " + priority, e);
}
}
else if (priority is int || priority is long)
{
task.Priority = (int)priority;
}
else
{
throw new ActivitiIllegalArgumentException("Priority expression does not resolve to a number: " + activeTaskPriority);
}
}
}
if (!string.IsNullOrWhiteSpace(activeTaskCategory))
{
object category = expressionManager.CreateExpression(activeTaskCategory).GetValue(execution);
if (category != null)
{
if (category is string)
{
task.Category = category.ToString();
}
else
{
throw new ActivitiIllegalArgumentException("Category expression does not resolve to a string: " + activeTaskCategory);
}
}
}
if (!string.IsNullOrWhiteSpace(activeTaskFormKey))
{
object formKey = expressionManager.CreateExpression(activeTaskFormKey).GetValue(execution);
if (formKey != null)
{
if (formKey is string)
{
task.FormKey = formKey.ToString();
}
else
{
throw new ActivitiIllegalArgumentException("FormKey expression does not resolve to a string: " + activeTaskFormKey);
}
}
}
taskEntityManager.Insert(task, execution);
bool skipUserTask = false;
if (!string.IsNullOrWhiteSpace(activeTaskSkipExpression))
{
IExpression skipExpression = expressionManager.CreateExpression(activeTaskSkipExpression);
skipUserTask = SkipExpressionUtil.IsSkipExpressionEnabled(execution, skipExpression) && SkipExpressionUtil.ShouldSkipFlowElement(execution, skipExpression);
}
// Handling assignments need to be done after the task is inserted, to have an id
if (!skipUserTask)
{
HandleAssignments(taskEntityManager, activeTaskAssignee, activeTaskOwner, activeTaskCandidateUsers, activeTaskCandidateGroups, task, expressionManager, execution);
}
processEngineConfiguration.ListenerNotificationHelper.ExecuteTaskListeners(task, BaseTaskListenerFields.EVENTNAME_CREATE);
// All properties set, now fire events
if (Context.ProcessEngineConfiguration.EventDispatcher.Enabled)
{
IActivitiEventDispatcher eventDispatcher = Context.ProcessEngineConfiguration.EventDispatcher;
eventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.TASK_CREATED, task));
if (string.IsNullOrWhiteSpace(task.Assignee) == false)
{
eventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.TASK_ASSIGNED, task));
}
}
if (skipUserTask)
{
taskEntityManager.DeleteTask(task, null, false, false);
Leave(execution);
}
}
/// <summary>
///
/// </summary>
/// <param name="taskEntityManager"></param>
/// <param name="assignee"></param>
/// <param name="owner"></param>
/// <param name="candidateUsers"></param>
/// <param name="candidateGroups"></param>
/// <param name="task"></param>
/// <param name="expressionManager"></param>
/// <param name="execution"></param>
protected internal virtual void HandleAssignments(ITaskEntityManager taskEntityManager, string assignee, string owner, IList <string> candidateUsers, IList <string> candidateGroups, ITaskEntity task, ExpressionManager expressionManager, IExecutionEntity execution)
{
if (!string.IsNullOrWhiteSpace(assignee))
{
object assigneeExpressionValue = expressionManager.CreateExpression(assignee).GetValue(execution);
string assigneeValue = null;
if (assigneeExpressionValue != null)
{
assigneeValue = assigneeExpressionValue.ToString();
}
string assigneeUser = null;
if (string.IsNullOrWhiteSpace(assigneeValue) == false)
{
IUserServiceProxy userService = ProcessEngineServiceProvider.Resolve <IUserServiceProxy>();
var user = userService.GetUser(assigneeValue)
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
assigneeUser = user?.FullName;
task.SetVariableLocal(assigneeValue, user);
}
taskEntityManager.ChangeTaskAssigneeNoEvents(task, assigneeValue, assigneeUser);
}
if (!string.IsNullOrWhiteSpace(owner))
{
object ownerExpressionValue = expressionManager.CreateExpression(owner).GetValue(execution);
string ownerValue = null;
if (ownerExpressionValue != null)
{
ownerValue = ownerExpressionValue.ToString();
}
taskEntityManager.ChangeTaskOwner(task, ownerValue);
}
if (candidateGroups != null && candidateGroups.Count > 0)
{
foreach (string candidateGroup in candidateGroups)
{
IExpression groupIdExpr = expressionManager.CreateExpression(candidateGroup);
object value = groupIdExpr.GetValue(execution);
if (value is string @string)
{
IList <string> candidates = ExtractCandidates(@string);
task.AddCandidateGroups(candidates);
}
else if (value is ICollection)
{
task.AddCandidateGroups((ICollection <string>)value);
}
else
{
throw new ActivitiIllegalArgumentException("Expression did not resolve to a string or collection of strings");
}
}
}
if (candidateUsers != null && candidateUsers.Count > 0)
{
foreach (string candidateUser in candidateUsers)
{
IExpression userIdExpr = expressionManager.CreateExpression(candidateUser);
object value = userIdExpr.GetValue(execution);
if (value is string @string)
{
IList <string> candidates = ExtractCandidates(@string);
task.AddCandidateUsers(candidates);
}
else if (value is ICollection)
{
task.AddCandidateUsers((ICollection <string>)value);
}
else
{
throw new ActivitiException("Expression did not resolve to a string or collection of strings");
}
}
}
if (userTask.CustomUserIdentityLinks != null && userTask.CustomUserIdentityLinks.Count > 0)
{
foreach (string customUserIdentityLinkType in userTask.CustomUserIdentityLinks.Keys)
{
foreach (string userIdentityLink in userTask.CustomUserIdentityLinks[customUserIdentityLinkType])
{
IExpression idExpression = expressionManager.CreateExpression(userIdentityLink);
object value = idExpression.GetValue(execution);
if (value is string @string)
{
IList <string> userIds = ExtractCandidates(@string);
foreach (string userId in userIds)
{
task.AddUserIdentityLink(userId, customUserIdentityLinkType);
}
}
else if (value is ICollection collection)
{
IEnumerator userIdSet = collection.GetEnumerator();
while (userIdSet.MoveNext())
{
task.AddUserIdentityLink((string)userIdSet.Current, customUserIdentityLinkType);
}
}
else
{
throw new ActivitiException("Expression did not resolve to a string or collection of strings");
}
}
}
}
if (userTask.CustomGroupIdentityLinks != null && userTask.CustomGroupIdentityLinks.Count > 0)
{
foreach (string customGroupIdentityLinkType in userTask.CustomGroupIdentityLinks.Keys)
{
foreach (string groupIdentityLink in userTask.CustomGroupIdentityLinks[customGroupIdentityLinkType])
{
IExpression idExpression = expressionManager.CreateExpression(groupIdentityLink);
object value = idExpression.GetValue(execution);
if (value is string @string)
{
IList <string> groupIds = ExtractCandidates(@string);
foreach (string groupId in groupIds)
{
task.AddGroupIdentityLink(groupId, customGroupIdentityLinkType);
}
}
else if (value is ICollection collection)
{
IEnumerator groupIdSet = collection.GetEnumerator();
while (groupIdSet.MoveNext())
{
task.AddGroupIdentityLink((string)groupIdSet.Current, customGroupIdentityLinkType);
}
}
else
{
throw new ActivitiException("Expression did not resolve to a string or collection of strings");
}
}
}
}
}
/// <summary>
/// The event definition on which the timer is based.
///
/// Takes in an optional execution, if missing the <seealso cref="NoExecutionVariableScope"/> will be used (eg Timer start event)
/// </summary>
public static ITimerJobEntity CreateTimerEntityForTimerEventDefinition(TimerEventDefinition timerEventDefinition, bool isInterruptingTimer, IExecutionEntity executionEntity, string jobHandlerType, string jobHandlerConfig)
{
ProcessEngineConfigurationImpl processEngineConfiguration = Context.ProcessEngineConfiguration;
string businessCalendarRef = null;
IExpression expression = null;
ExpressionManager expressionManager = processEngineConfiguration.ExpressionManager;
// ACT-1415: timer-declaration on start-event may contain expressions NOT
// evaluating variables but other context, evaluating should happen nevertheless
IVariableScope scopeForExpression = executionEntity;
if (scopeForExpression == null)
{
//scopeForExpression = NoExecutionVariableScope.SharedInstance;
}
if (!string.IsNullOrWhiteSpace(timerEventDefinition.TimeDate))
{
businessCalendarRef = DueDateBusinessCalendar.NAME;
expression = expressionManager.CreateExpression(timerEventDefinition.TimeDate);
}
else if (!string.IsNullOrWhiteSpace(timerEventDefinition.TimeCycle))
{
businessCalendarRef = CycleBusinessCalendar.NAME;
expression = expressionManager.CreateExpression(timerEventDefinition.TimeCycle);
}
else if (!string.IsNullOrWhiteSpace(timerEventDefinition.TimeDuration))
{
businessCalendarRef = DurationBusinessCalendar.NAME;
expression = expressionManager.CreateExpression(timerEventDefinition.TimeDuration);
}
if (!string.IsNullOrWhiteSpace(timerEventDefinition.CalendarName))
{
businessCalendarRef = timerEventDefinition.CalendarName;
IExpression businessCalendarExpression = expressionManager.CreateExpression(businessCalendarRef);
businessCalendarRef = businessCalendarExpression.GetValue(scopeForExpression).ToString();
}
if (expression == null)
{
throw new ActivitiException("Timer needs configuration (either timeDate, timeCycle or timeDuration is needed) (" + timerEventDefinition.Id + ")");
}
IBusinessCalendar businessCalendar = processEngineConfiguration.BusinessCalendarManager.GetBusinessCalendar(businessCalendarRef);
string dueDateString = null;
DateTime?duedate = null;
object dueDateValue = expression.GetValue(scopeForExpression);
if (dueDateValue is string)
{
dueDateString = (string)dueDateValue;
}
else if (dueDateValue is DateTime)
{
duedate = (DateTime)dueDateValue;
}
else if (dueDateValue is Nullable <DateTime> )
{
//JodaTime support
duedate = (DateTime?)dueDateValue;
}
else if (dueDateValue != null)
{
throw new ActivitiException("Timer '" + executionEntity.ActivityId + "' was not configured with a valid duration/time, either hand in a java.util.Date or a String in format 'yyyy-MM-dd'T'hh:mm:ss'");
}
if (duedate == null && !string.IsNullOrWhiteSpace(dueDateString))
{
duedate = businessCalendar.ResolveDuedate(dueDateString);
}
ITimerJobEntity timer = null;
if (duedate != null)
{
timer = Context.CommandContext.TimerJobEntityManager.Create();
timer.JobType = JobFields.JOB_TYPE_TIMER;
timer.Revision = 1;
timer.JobHandlerType = jobHandlerType;
timer.JobHandlerConfiguration = jobHandlerConfig;
timer.Exclusive = true;
timer.Retries = processEngineConfiguration.AsyncExecutorNumberOfRetries;
timer.Duedate = duedate;
if (executionEntity != null)
{
timer.Execution = executionEntity;
timer.ProcessDefinitionId = executionEntity.ProcessDefinitionId;
timer.ProcessInstanceId = executionEntity.ProcessInstanceId;
// Inherit tenant identifier (if applicable)
if (!string.IsNullOrWhiteSpace(executionEntity.TenantId))
{
timer.TenantId = executionEntity.TenantId;
}
}
}
if (!string.IsNullOrWhiteSpace(timerEventDefinition.TimeCycle))
{
// See ACT-1427: A boundary timer with a cancelActivity='true', doesn't need to repeat itself
bool repeat = !isInterruptingTimer;
// ACT-1951: intermediate catching timer events shouldn't repeat according to spec
if (executionEntity != null)
{
FlowElement currentElement = executionEntity.CurrentFlowElement;
if (currentElement is IntermediateCatchEvent)
{
repeat = false;
}
}
if (repeat)
{
string prepared = PrepareRepeat(dueDateString);
timer.Repeat = prepared;
}
}
if (timer != null && executionEntity != null)
{
timer.Execution = executionEntity;
timer.ProcessDefinitionId = executionEntity.ProcessDefinitionId;
// Inherit tenant identifier (if applicable)
if (!string.IsNullOrWhiteSpace(executionEntity.TenantId))
{
timer.TenantId = executionEntity.TenantId;
}
}
return(timer);
}
public virtual IList <FieldDeclaration> CreateFieldDeclarations(IList <FieldExtension> fieldList)
{
IList <FieldDeclaration> fieldDeclarations = new List <FieldDeclaration>();
foreach (FieldExtension fieldExtension in fieldList)
{
FieldDeclaration fieldDeclaration = null;
if (!string.IsNullOrWhiteSpace(fieldExtension.Expression))
{
fieldDeclaration = new FieldDeclaration(fieldExtension.FieldName, typeof(IExpression).FullName, expressionManager.CreateExpression(fieldExtension.Expression));
}
else
{
fieldDeclaration = new FieldDeclaration(fieldExtension.FieldName, typeof(IExpression).FullName, new FixedValue(fieldExtension.StringValue));
}
fieldDeclarations.Add(fieldDeclaration);
}
return(fieldDeclarations);
}
/// <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);
}
