public override void Delete(IVariableInstanceEntity entity, bool fireDeleteEvent)
{
base.Delete(entity, false);
IByteArrayRef byteArrayRef = entity.ByteArrayRef;
if (byteArrayRef != null)
{
byteArrayRef.Delete();
}
entity.Deleted = true;
if (!(entity.ExecutionId is null) && ExecutionRelatedEntityCountEnabledGlobally)
{
ICountingExecutionEntity executionEntity = ExecutionEntityManager.FindById <ICountingExecutionEntity>(entity.ExecutionId);
if (IsExecutionRelatedEntityCountEnabled(executionEntity))
{
executionEntity.VariableCount -= 1;
}
}
IActivitiEventDispatcher eventDispatcher = EventDispatcher;
if (fireDeleteEvent && eventDispatcher.Enabled)
{
eventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.ENTITY_DELETED, entity));
eventDispatcher.DispatchEvent(CreateVariableDeleteEvent(entity));
}
}
/// <summary>
///
/// </summary>
/// <param name="parentExecution"></param>
/// <param name="subProcessInstance"></param>
/// <param name="initialElement"></param>
public virtual void RecordSubProcessInstanceStart(IExecutionEntity parentExecution, IExecutionEntity subProcessInstance, FlowElement initialElement)
{
if (IsHistoryLevelAtLeast(HistoryLevel.ACTIVITY))
{
IHistoricProcessInstanceEntity historicProcessInstance = HistoricProcessInstanceEntityManager.Create(subProcessInstance);
// Fix for ACT-1728: startActivityId not initialized with subprocess instance
if (historicProcessInstance.StartActivityId is null)
{
historicProcessInstance.StartActivityId = initialElement.Id;
}
HistoricProcessInstanceEntityManager.Insert(historicProcessInstance, false);
// Fire event
IActivitiEventDispatcher activitiEventDispatcher = EventDispatcher;
if (activitiEventDispatcher != null && activitiEventDispatcher.Enabled)
{
activitiEventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.HISTORIC_PROCESS_INSTANCE_CREATED, historicProcessInstance));
}
IHistoricActivityInstanceEntity activitiyInstance = FindActivityInstance(parentExecution, false, true);
if (activitiyInstance != null)
{
activitiyInstance.CalledProcessInstanceId = subProcessInstance.ProcessInstanceId;
}
}
}
// Activity related history
/// <summary>
///
/// </summary>
/// <param name="executionEntity"></param>
public virtual void RecordActivityStart(IExecutionEntity executionEntity)
{
if (IsHistoryLevelAtLeast(HistoryLevel.ACTIVITY))
{
if (executionEntity.ActivityId != null && executionEntity.CurrentFlowElement != null)
{
// Historic activity instance could have been created (but only in cache, never persisted)
// for example when submitting form properties
IHistoricActivityInstanceEntity historicActivityInstanceEntityFromCache = GetHistoricActivityInstanceFromCache(executionEntity.Id, executionEntity.ActivityId, true);
IHistoricActivityInstanceEntity historicActivityInstanceEntity;
if (historicActivityInstanceEntityFromCache != null)
{
historicActivityInstanceEntity = historicActivityInstanceEntityFromCache;
}
else
{
historicActivityInstanceEntity = CreateHistoricActivityInstanceEntity(executionEntity);
}
// Fire event
IActivitiEventDispatcher activitiEventDispatcher = EventDispatcher;
if (activitiEventDispatcher != null && activitiEventDispatcher.Enabled)
{
activitiEventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.HISTORIC_ACTIVITY_INSTANCE_CREATED, historicActivityInstanceEntity));
}
}
}
}
public virtual void Insert(EntityImpl entity, bool fireCreateEvent)
{
DataManager.Insert(entity);
IActivitiEventDispatcher eventDispatcher = EventDispatcher;
if (fireCreateEvent && eventDispatcher.Enabled)
{
eventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.ENTITY_CREATED, entity));
eventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.ENTITY_INITIALIZED, entity));
}
}
public virtual void StartProcessInstance(IExecutionEntity processInstance, ICommandContext commandContext, IDictionary <string, object> variables)
{
Process process = ProcessDefinitionUtil.GetProcess(processInstance.ProcessDefinitionId);
// Event sub process handling
IList <IMessageEventSubscriptionEntity> messageEventSubscriptions = new List <IMessageEventSubscriptionEntity>();
foreach (FlowElement flowElement in process.FlowElements)
{
if (flowElement is EventSubProcess eventSubProcess)
{
foreach (FlowElement subElement in eventSubProcess.FlowElements)
{
if (subElement is StartEvent startEvent)
{
if (CollectionUtil.IsNotEmpty(startEvent.EventDefinitions))
{
EventDefinition eventDefinition = startEvent.EventDefinitions[0];
if (eventDefinition is MessageEventDefinition messageEventDefinition)
{
BpmnModel bpmnModel = ProcessDefinitionUtil.GetBpmnModel(processInstance.ProcessDefinitionId);
if (bpmnModel.ContainsMessageId(messageEventDefinition.MessageRef))
{
messageEventDefinition.MessageRef = bpmnModel.GetMessage(messageEventDefinition.MessageRef).Name;
}
IExecutionEntity messageExecution = commandContext.ExecutionEntityManager.CreateChildExecution(processInstance);
messageExecution.CurrentFlowElement = startEvent;
messageExecution.IsEventScope = true;
messageEventSubscriptions.Add(commandContext.EventSubscriptionEntityManager.InsertMessageEvent(messageEventDefinition.MessageRef, messageExecution));
}
}
}
}
}
}
IExecutionEntity execution = processInstance.Executions[0]; // There will always be one child execution created
commandContext.Agenda.PlanContinueProcessOperation(execution);
if (Context.ProcessEngineConfiguration.EventDispatcher.Enabled)
{
IActivitiEventDispatcher eventDispatcher = Context.ProcessEngineConfiguration.EventDispatcher;
eventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateProcessStartedEvent(execution, variables, false));
foreach (IMessageEventSubscriptionEntity messageEventSubscription in messageEventSubscriptions)
{
commandContext.ProcessEngineConfiguration.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateMessageEvent(ActivitiEventType.ACTIVITY_MESSAGE_WAITING, messageEventSubscription.ActivityId, messageEventSubscription.EventName, null, messageEventSubscription.Execution.Id, messageEventSubscription.ProcessInstanceId, messageEventSubscription.ProcessDefinitionId));
}
}
}
protected internal override void ExecuteTaskComplete(ICommandContext commandContext, ITaskEntity taskEntity, IDictionary <string, object> variables, bool localScope)
{
Transfer(commandContext);
// Task complete logic
if (taskEntity.DelegationState.HasValue && taskEntity.DelegationState.Value == DelegationState.PENDING)
{
throw new ActivitiException("A delegated task cannot be completed, but should be resolved instead.");
}
commandContext.ProcessEngineConfiguration.ListenerNotificationHelper.ExecuteTaskListeners(taskEntity, BaseTaskListenerFields.EVENTNAME_COMPLETE);
IUserInfo user = Authentication.AuthenticatedUser;
if (user != null && string.IsNullOrWhiteSpace(taskEntity.ProcessInstanceId) == false)
{
IExecutionEntity processInstanceEntity = commandContext.ExecutionEntityManager.FindById <IExecutionEntity>(taskEntity.ProcessInstanceId);//这里为什么取ProcessInstance而不是Exceution.
commandContext.IdentityLinkEntityManager.InvolveUser(processInstanceEntity, user.Id, IdentityLinkType.PARTICIPANT);
}
IActivitiEventDispatcher eventDispatcher = Context.ProcessEngineConfiguration.EventDispatcher;
if (eventDispatcher.Enabled)
{
if (variables != null)
{
eventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityWithVariablesEvent(ActivitiEventType.TASK_COMPLETED, taskEntity, variables, localScope));
}
else
{
eventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.TASK_COMPLETED, taskEntity));
}
}
commandContext.TaskEntityManager.DeleteTask(taskEntity, completeReason, false, false);
if (eventDispatcher.Enabled)
{
eventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateCustomTaskCompletedEvent(taskEntity, ActivitiEventType.TASK_TRANSFERED));
}
// Continue process (if not a standalone task)
if (taskEntity.ExecutionId is object)
{
IExecutionEntity executionEntity = commandContext.ExecutionEntityManager.FindById <IExecutionEntity>(taskEntity.ExecutionId);
Context.Agenda.PlanTriggerExecutionOperation(executionEntity);
}
}
private void ReturnToTasks(ICommandContext commandContext, Interceptor.ICommandExecutor commandExecutor, IExecutionEntity execution, IExecutionEntityManager executionEntityManager, List <ITask> tasks)
{
foreach (ITaskEntity delTask in tasks)
{
IActivitiEventDispatcher eventDispatcher = commandContext.ProcessEngineConfiguration.EventDispatcher;
if (eventDispatcher.Enabled)
{
eventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateTaskReturnEntityEvent(delTask, returnToActivityId));
}
commandExecutor.Execute(new AddCommentCmd(delTask.Id, delTask.ProcessInstanceId, returnToReason));
commandContext.TaskEntityManager.DeleteTask(delTask, returnToReason, false, false);
}
DeleteExecutions(execution, true, returnToReason, commandContext);
}
/// <summary>
///
/// </summary>
/// <param name="timerJob"></param>
public virtual void ScheduleTimerJob(ITimerJobEntity timerJob)
{
if (timerJob == null)
{
throw new ActivitiException("Empty timer job can not be scheduled");
}
processEngineConfiguration.TimerJobEntityManager.Insert(timerJob);
ICommandContext commandContext = Context.CommandContext;
IActivitiEventDispatcher eventDispatcher = commandContext.EventDispatcher;
if (eventDispatcher.Enabled)
{
eventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.TIMER_SCHEDULED, timerJob));
}
}
/// <summary>
///
/// </summary>
/// <param name="executionEntity"></param>
/// <param name="deleteReason"></param>
public virtual void RecordActivityEnd(IExecutionEntity executionEntity, string deleteReason)
{
if (IsHistoryLevelAtLeast(HistoryLevel.ACTIVITY))
{
IHistoricActivityInstanceEntity historicActivityInstance = FindActivityInstance(executionEntity, false, true);
if (historicActivityInstance != null)
{
historicActivityInstance.markEnded(deleteReason);
// Fire event
IActivitiEventDispatcher activitiEventDispatcher = EventDispatcher;
if (activitiEventDispatcher != null && activitiEventDispatcher.Enabled)
{
activitiEventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.HISTORIC_ACTIVITY_INSTANCE_ENDED, historicActivityInstance));
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="processInstance"></param>
/// <param name="startElement"></param>
public virtual void RecordProcessInstanceStart(IExecutionEntity processInstance, FlowElement startElement)
{
if (IsHistoryLevelAtLeast(HistoryLevel.ACTIVITY))
{
IHistoricProcessInstanceEntity historicProcessInstance = HistoricProcessInstanceEntityManager.Create(processInstance);
historicProcessInstance.StartActivityId = startElement.Id;
// Insert historic process-instance
HistoricProcessInstanceEntityManager.Insert(historicProcessInstance, false);
// Fire event
IActivitiEventDispatcher activitiEventDispatcher = EventDispatcher;
if (activitiEventDispatcher != null && activitiEventDispatcher.Enabled)
{
activitiEventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.HISTORIC_PROCESS_INSTANCE_CREATED, historicProcessInstance));
}
}
}
// Process related history
/// <summary>
///
/// </summary>
/// <param name="processInstanceId"></param>
/// <param name="deleteReason"></param>
/// <param name="activityId"></param>
public virtual void RecordProcessInstanceEnd(string processInstanceId, string deleteReason, string activityId)
{
if (IsHistoryLevelAtLeast(HistoryLevel.ACTIVITY))
{
IHistoricProcessInstanceEntity historicProcessInstance = HistoricProcessInstanceEntityManager.FindById <IHistoricProcessInstanceEntity>(new KeyValuePair <string, object>("processInstanceId", processInstanceId));
if (historicProcessInstance != null)
{
historicProcessInstance.markEnded(deleteReason);
historicProcessInstance.EndActivityId = activityId;
// Fire event
IActivitiEventDispatcher activitiEventDispatcher = EventDispatcher;
if (activitiEventDispatcher != null && activitiEventDispatcher.Enabled)
{
activitiEventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.HISTORIC_PROCESS_INSTANCE_ENDED, historicProcessInstance));
}
}
}
}
protected internal override void ExecuteTaskComplete(ICommandContext commandContext, ITaskEntity taskEntity, IDictionary <string, object> variables, bool localScope)
{
Transfer(commandContext);
// Task complete logic
CompleteTask(commandContext, taskEntity, variables, localScope);
IActivitiEventDispatcher eventDispatcher = Context.ProcessEngineConfiguration.EventDispatcher;
if (eventDispatcher.Enabled)
{
eventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateCustomTaskCompletedEvent(taskEntity, ActivitiEventType.TASK_TRANSFERED));
}
// Continue process (if not a standalone task)
if (taskEntity.ExecutionId is object)
{
IExecutionEntity executionEntity = commandContext.ExecutionEntityManager.FindById <IExecutionEntity>(taskEntity.ExecutionId);
Context.Agenda.PlanTriggerExecutionOperation(executionEntity, variables ?? new Dictionary <string, object>());
}
}
protected internal override void ExecuteTaskComplete(ICommandContext commandContext, ITaskEntity taskEntity, IDictionary <string, object> variables, bool localScope)
{
lock (syncRoot)
{
// Task complete logic
CompleteTask(commandContext, taskEntity, variables, localScope);
IActivitiEventDispatcher eventDispatcher = Context.ProcessEngineConfiguration.EventDispatcher;
if (eventDispatcher.Enabled)
{
eventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateCustomTaskCompletedEvent(taskEntity, ActivitiEventType.TASK_TERMINATED));
}
// Continue process (if not a standalone task)
if (taskEntity.ExecutionId is object && isTerminateExecution)
{
IExecutionEntity executionEntity = commandContext.ExecutionEntityManager.FindById <IExecutionEntity>(taskEntity.ExecutionId);
executionEntity.SetVariableLocal(WorkflowVariable.GLOBAL_TERMINATE_TASK_VARNAME, true);
Context.Agenda.PlanTriggerExecutionOperation(executionEntity, variables ?? new Dictionary <string, object>());
}
}
}
protected void CompleteTask(ICommandContext commandContext, ITaskEntity taskEntity, IDictionary <string, object> variables, bool localScope)
{
// Task complete logic
if (taskEntity.DelegationState.HasValue && taskEntity.DelegationState.Value == DelegationState.PENDING)
{
throw new ActivitiException("A delegated task cannot be completed, but should be resolved instead.");
}
ProcessEngineConfigurationImpl processEngineConfiguration = commandContext.ProcessEngineConfiguration;
processEngineConfiguration.ListenerNotificationHelper.ExecuteTaskListeners(taskEntity, BaseTaskListenerFields.EVENTNAME_COMPLETE);
IUserInfo user = Authentication.AuthenticatedUser;
if (user is object && string.IsNullOrWhiteSpace(taskEntity.ProcessInstanceId) == false)
{
IExecutionEntity processInstanceEntity = commandContext.ExecutionEntityManager.FindById <IExecutionEntity>(taskEntity.ProcessInstanceId);
commandContext.IdentityLinkEntityManager.InvolveUser(processInstanceEntity, user.Id, IdentityLinkType.PARTICIPANT);
}
IActivitiEventDispatcher eventDispatcher = Context.ProcessEngineConfiguration.EventDispatcher;
if (eventDispatcher.Enabled)
{
if (variables is null)
{
eventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.TASK_COMPLETED, taskEntity));
}
else
{
eventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityWithVariablesEvent(ActivitiEventType.TASK_COMPLETED, taskEntity, variables, localScope));
}
}
commandContext.TaskEntityManager.DeleteTask(taskEntity, completeReason, false, false);
}
public virtual void RemoveDeployment(string deploymentId, bool cascade)
{
IDeploymentEntity deployment = deploymentEntityManager.FindById <IDeploymentEntity>(new KeyValuePair <string, object>("id", deploymentId));
if (deployment == null)
{
throw new ActivitiObjectNotFoundException("Could not find a deployment with id '" + deploymentId + "'.", typeof(IDeploymentEntity));
}
// Remove any process definition from the cache
IList <IProcessDefinition> processDefinitions = (new ProcessDefinitionQueryImpl()).SetDeploymentId(deploymentId).List();
IActivitiEventDispatcher eventDispatcher = Context.ProcessEngineConfiguration.EventDispatcher;
foreach (IProcessDefinition processDefinition in processDefinitions)
{
// Since all process definitions are deleted by a single query, we should dispatch the events in this loop
if (eventDispatcher.Enabled)
{
eventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.ENTITY_DELETED, processDefinition));
}
}
// Delete data
deploymentEntityManager.DeleteDeployment(deploymentId, cascade);
// Since we use a delete by query, delete-events are not automatically dispatched
if (eventDispatcher.Enabled)
{
eventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.ENTITY_DELETED, deployment));
}
foreach (IProcessDefinition processDefinition in processDefinitions)
{
processDefinitionCache.Remove(processDefinition.Id);
}
}
/// <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);
}
}
public virtual object Execute(ICommandContext commandContext)
{
IJobEntity job = commandContext.JobEntityManager.FindById <IJobEntity>(new KeyValuePair <string, object>("id", jobId));
if (job == null)
{
return(null);
}
ProcessEngineConfiguration processEngineConfig = commandContext.ProcessEngineConfiguration;
IExecutionEntity executionEntity = fetchExecutionEntity(commandContext, job.ExecutionId);
FlowElement currentFlowElement = executionEntity != null ? executionEntity.CurrentFlowElement : null;
string failedJobRetryTimeCycleValue = null;
if (currentFlowElement is ServiceTask)
{
failedJobRetryTimeCycleValue = ((ServiceTask)currentFlowElement).FailedJobRetryTimeCycleValue;
}
IAbstractJobEntity newJobEntity = null;
if (currentFlowElement == null || ReferenceEquals(failedJobRetryTimeCycleValue, null))
{
log.LogDebug("activity or FailedJobRetryTimerCycleValue is null in job " + jobId + ". only decrementing retries.");
if (job.Retries <= 1)
{
newJobEntity = commandContext.JobManager.MoveJobToDeadLetterJob(job);
}
else
{
newJobEntity = commandContext.JobManager.MoveJobToTimerJob(job);
}
newJobEntity.Retries = job.Retries - 1;
if (!job.Duedate.HasValue || JobFields.JOB_TYPE_MESSAGE.Equals(job.JobType))
{
// add wait time for failed async job
newJobEntity.Duedate = calculateDueDate(commandContext, processEngineConfig.AsyncFailedJobWaitTime, null);
}
else
{
// add default wait time for failed job
newJobEntity.Duedate = calculateDueDate(commandContext, processEngineConfig.DefaultFailedJobWaitTime, job.Duedate);
}
}
else
{
try
{
DurationHelper durationHelper = new DurationHelper(failedJobRetryTimeCycleValue, processEngineConfig.Clock);
int jobRetries = job.Retries;
if (ReferenceEquals(job.ExceptionMessage, null))
{
// change default retries to the ones configured
jobRetries = durationHelper.Times;
}
if (jobRetries <= 1)
{
newJobEntity = commandContext.JobManager.MoveJobToDeadLetterJob(job);
}
else
{
newJobEntity = commandContext.JobManager.MoveJobToTimerJob(job);
}
newJobEntity.Duedate = durationHelper.DateAfter;
if (ReferenceEquals(job.ExceptionMessage, null))
{
// is it the first exception
log.LogDebug("Applying JobRetryStrategy '" + failedJobRetryTimeCycleValue + "' the first time for job " + job.Id + " with " + durationHelper.Times + " retries");
}
else
{
log.LogDebug("Decrementing retries of JobRetryStrategy '" + failedJobRetryTimeCycleValue + "' for job " + job.Id);
}
newJobEntity.Retries = jobRetries - 1;
}
catch (Exception)
{
throw new ActivitiException("failedJobRetryTimeCylcle has wrong format:" + failedJobRetryTimeCycleValue, exception);
}
}
if (exception != null)
{
newJobEntity.ExceptionMessage = exception.Message;
newJobEntity.ExceptionStacktrace = ExceptionStacktrace;
}
// Dispatch both an update and a retry-decrement event
IActivitiEventDispatcher eventDispatcher = commandContext.EventDispatcher;
if (eventDispatcher.Enabled)
{
eventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.ENTITY_UPDATED, newJobEntity));
eventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.JOB_RETRIES_DECREMENTED, newJobEntity));
}
return(null);
}
