public override void Execute(IExecutionEntity execution)
{
ICommandContext commandContext = Context.CommandContext;
string eventSubscriptionName;
if (messageEventName is object)
{
eventSubscriptionName = messageEventName;
}
else
{
IExpression expressionObject = commandContext.ProcessEngineConfiguration.ExpressionManager.CreateExpression(messageExpression);
eventSubscriptionName = expressionObject.GetValue(execution).ToString();
}
IEventSubscriptionEntityManager eventSubscriptionEntityManager = commandContext.EventSubscriptionEntityManager;
IList <IMessageEventSubscriptionEntity> subscriptionEntities = eventSubscriptionEntityManager.FindMessageEventSubscriptionsByProcessInstanceAndEventName(execution.ProcessInstanceId, eventSubscriptionName);
foreach (IMessageEventSubscriptionEntity messageEventSubscriptionEntity in subscriptionEntities)
{
Context.ProcessEngineConfiguration.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateMessageEvent(ActivitiEventType.ACTIVITY_MESSAGE_RECEIVED, messageEventSubscriptionEntity.ActivityId, eventSubscriptionName, null, messageEventSubscriptionEntity.ExecutionId, messageEventSubscriptionEntity.ProcessInstanceId, messageEventSubscriptionEntity.ProcessDefinitionId));
eventSubscriptionEntityManager.EventReceived(messageEventSubscriptionEntity, null, false);
}
Context.Agenda.PlanTakeOutgoingSequenceFlowsOperation(execution, true);
}
public virtual object Execute(ICommandContext commandContext)
{
if (string.IsNullOrWhiteSpace(processDefinitionId))
{
throw new ActivitiIllegalArgumentException("Process definition id is null");
}
IProcessDefinitionEntity processDefinition = commandContext.ProcessDefinitionEntityManager.FindById <IProcessDefinitionEntity>(processDefinitionId);
if (processDefinition == null)
{
throw new ActivitiObjectNotFoundException("No process definition found for id = '" + processDefinitionId + "'", typeof(IProcessDefinition));
}
// Update category
processDefinition.Category = category;
// Remove process definition from cache, it will be refetched later
IDeploymentCache <ProcessDefinitionCacheEntry> processDefinitionCache = commandContext.ProcessEngineConfiguration.ProcessDefinitionCache;
if (processDefinitionCache != null)
{
processDefinitionCache.Remove(processDefinitionId);
}
if (commandContext.EventDispatcher.Enabled)
{
commandContext.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.ENTITY_UPDATED, processDefinition));
}
return(null);
}
protected internal virtual void SendCancelEvent(IJobEntity jobToDelete)
{
if (Context.ProcessEngineConfiguration.EventDispatcher.Enabled)
{
Context.ProcessEngineConfiguration.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.JOB_CANCELED, jobToDelete));
}
}
/// <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;
}
}
}
public virtual object Execute(ICommandContext commandContext)
{
if (jobId is null)
{
throw new ActivitiIllegalArgumentException("jobId is null");
}
// We need to refetch the job, as it could have been deleted by another concurrent job
// For exampel: an embedded subprocess with a couple of async tasks and a timer on the boundary of the subprocess
// when the timer fires, all executions and thus also the jobs inside of the embedded subprocess are destroyed.
// However, the async task jobs could already have been fetched and put in the queue.... while in reality they have been deleted.
// A refetch is thus needed here to be sure that it exists for this transaction.
IJob job = commandContext.JobEntityManager.FindById <IJobEntity>(jobId);
if (job == null)
{
log.LogDebug("Job does not exist anymore and will not be executed. It has most likely been deleted as part of another concurrent part of the process instance.");
return(null);
}
if (log.IsEnabled(LogLevel.Debug))
{
log.LogDebug($"Executing async job {job.Id}");
}
commandContext.JobManager.Execute(job);
if (commandContext.EventDispatcher.Enabled)
{
commandContext.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.JOB_EXECUTION_SUCCESS, job));
}
return(null);
}
// 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 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));
}
}
public virtual object Execute(ICommandContext commandContext)
{
CommandConfig commandConfig = outerInstance.processEngineConfiguration.CommandExecutor.DefaultConfig.TransactionRequiresNew();
IFailedJobCommandFactory failedJobCommandFactory = commandContext.FailedJobCommandFactory;
ICommand <object> cmd = failedJobCommandFactory.GetCommand(outerInstance.job.Id, exception);
log.LogTrace($"Using FailedJobCommandFactory '{failedJobCommandFactory.GetType()}' and command of type '{cmd.GetType()}'");
outerInstance.processEngineConfiguration.CommandExecutor.Execute(commandConfig, cmd);
// Dispatch an event, indicating job execution failed in a
// try-catch block, to prevent the original exception to be swallowed
if (commandContext.EventDispatcher.Enabled)
{
try
{
commandContext.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityExceptionEvent(ActivitiEventType.JOB_EXECUTION_FAILURE, outerInstance.job, exception));
}
catch (Exception ignore)
{
log.LogWarning(ignore, "Exception occurred while dispatching job failure event, ignoring.");
}
}
return(commandContext.GetResult());
}
public override void Insert(ICommentEntity commentEntity)
{
if (HistoryManager.HistoryEnabled == false)
{
return;
}
CheckHistoryEnabled();
Insert(commentEntity, false);
IComment comment = commentEntity;
if (EventDispatcher.Enabled)
{
// Forced to fetch the process-instance to associate the right
// process definition
string processDefinitionId = null;
string processInstanceId = comment.ProcessInstanceId;
if (comment.ProcessInstanceId is object)
{
IExecutionEntity process = ExecutionEntityManager.FindById <IExecutionEntity>(comment.ProcessInstanceId);
if (process != null)
{
processDefinitionId = process.ProcessDefinitionId;
}
}
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.ENTITY_CREATED, commentEntity, processInstanceId, processInstanceId, processDefinitionId));
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.ENTITY_INITIALIZED, commentEntity, processInstanceId, processInstanceId, processDefinitionId));
}
}
public override void Delete(ICommentEntity commentEntity)
{
CheckHistoryEnabled();
Delete(commentEntity, false);
IComment comment = commentEntity;
if (EventDispatcher.Enabled)
{
// Forced to fetch the process-instance to associate the right
// process definition
string processDefinitionId = null;
string processInstanceId = comment.ProcessInstanceId;
if (!(comment.ProcessInstanceId is null))
{
IExecutionEntity process = ExecutionEntityManager.FindById <IExecutionEntity>(comment.ProcessInstanceId);
if (process != null)
{
processDefinitionId = process.ProcessDefinitionId;
}
}
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.ENTITY_DELETED, commentEntity, processInstanceId, processInstanceId, processDefinitionId));
}
}
public virtual IExecutionEntity CreateSubprocessInstance(IProcessDefinition processDefinition, IExecutionEntity superExecutionEntity, string businessKey)
{
IExecutionEntity subProcessInstance = executionDataManager.Create();
InheritCommonProperties(superExecutionEntity, subProcessInstance);
subProcessInstance.ProcessDefinitionId = processDefinition.Id;
subProcessInstance.ProcessDefinitionKey = processDefinition.Key;
subProcessInstance.SuperExecution = superExecutionEntity;
subProcessInstance.RootProcessInstanceId = superExecutionEntity.RootProcessInstanceId;
subProcessInstance.IsScope = true; // process instance is always a scope for all child executions
subProcessInstance.StartUserId = Authentication.AuthenticatedUser.Id;
subProcessInstance.BusinessKey = businessKey;
// Store in database
Insert(subProcessInstance, false);
//if (logger.DebugEnabled)
//{
// logger.debug("Child execution {} created with super execution {}", subProcessInstance, superExecutionEntity.Id);
//}
subProcessInstance.ProcessInstanceId = subProcessInstance.Id;
superExecutionEntity.SubProcessInstance = subProcessInstance;
ProcessEngineConfigurationImpl processEngineConfiguration1 = Context.ProcessEngineConfiguration;
if (processEngineConfiguration1 is object && processEngineConfiguration1.EventDispatcher.Enabled)
{
processEngineConfiguration1.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.ENTITY_CREATED, subProcessInstance));
}
return(subProcessInstance);
}
public virtual void Closed(ICommandContext context)
{
if (context.EventDispatcher.Enabled)
{
context.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.JOB_EXECUTION_SUCCESS, job));
}
}
/// <summary>
/// Creates a new execution. properties processDefinition, processInstance and activity will be initialized.
/// </summary>
public virtual IExecutionEntity CreateChildExecution(IExecutionEntity parentExecutionEntity)
{
IExecutionEntity childExecution = executionDataManager.Create();
childExecution.Name = parentExecutionEntity.Name;
InheritCommonProperties(parentExecutionEntity, childExecution);
childExecution.Parent = parentExecutionEntity;
childExecution.ProcessDefinitionId = parentExecutionEntity.ProcessDefinitionId;
childExecution.ProcessDefinitionKey = parentExecutionEntity.ProcessDefinitionKey;
childExecution.ProcessInstanceId = parentExecutionEntity.ProcessInstanceId is object?parentExecutionEntity.ProcessInstanceId : parentExecutionEntity.Id;
childExecution.IsScope = false;
childExecution.ActivityId = parentExecutionEntity.ActivityId;
childExecution.BusinessKey = parentExecutionEntity.BusinessKey;
childExecution.DeploymentId = parentExecutionEntity.DeploymentId;
childExecution.TenantId = parentExecutionEntity.TenantId;
// manage the bidirectional parent-child relation
parentExecutionEntity.AddChildExecution(childExecution);
// Insert the child execution
Insert(childExecution, false);
if (logger.IsEnabled(LogLevel.Debug))
{
logger.LogDebug("Child execution {} created with parent {}", childExecution, parentExecutionEntity.Id);
}
if (EventDispatcher.Enabled)
{
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.ENTITY_CREATED, childExecution));
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.ENTITY_INITIALIZED, childExecution));
}
return(childExecution);
}
protected internal virtual void FireAssignmentEvents(ITaskEntity taskEntity)
{
RecordTaskAssignment(taskEntity);
if (EventDispatcher.Enabled)
{
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.TASK_ASSIGNED, taskEntity));
}
}
public virtual void Delete(EntityImpl entity, bool fireDeleteEvent)
{
DataManager.Delete(entity);
if (fireDeleteEvent && EventDispatcher.Enabled)
{
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.ENTITY_DELETED, entity));
}
}
public virtual EntityImpl Update(EntityImpl entity, bool fireUpdateEvent)
{
EntityImpl updatedEntity = DataManager.Update(entity);
if (fireUpdateEvent && EventDispatcher.Enabled)
{
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.ENTITY_UPDATED, entity));
}
return(updatedEntity);
}
protected internal virtual void SendProcessInstanceCancelledEvent(IExecutionEntity execution, FlowElement terminateEndEvent)
{
if (Context.ProcessEngineConfiguration.EventDispatcher.Enabled)
{
if ((execution.ProcessInstanceType && execution.SuperExecutionId is null) || (execution.ParentId is null && execution.SuperExecutionId is object))
{
Context.ProcessEngineConfiguration.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateCancelledEvent(execution.Id, execution.ProcessInstanceId, execution.ProcessDefinitionId, execution.CurrentFlowElement));
}
}
DispatchExecutionCancelled(execution, terminateEndEvent);
}
/// <summary>
///
/// </summary>
/// <param name="variableInstance"></param>
/// <param name="value"></param>
/// <param name="sourceActivityExecution"></param>
protected internal override void UpdateVariableInstance(IVariableInstanceEntity variableInstance, object value, IExecutionEntity sourceActivityExecution)
{
base.UpdateVariableInstance(variableInstance, value, sourceActivityExecution);
// Dispatch event, if needed
ProcessEngineConfigurationImpl processEngineConfiguration = Context.ProcessEngineConfiguration;
if (processEngineConfiguration is object && processEngineConfiguration.EventDispatcher.Enabled)
{
processEngineConfiguration.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateVariableEvent(ActivitiEventType.VARIABLE_UPDATED, variableInstance.Name, value, variableInstance.Type, variableInstance.TaskId, variableInstance.ExecutionId, ProcessInstanceId, ProcessDefinitionId));
}
}
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));
}
}
}
/// <summary>
///
/// </summary>
/// <param name="variableName"></param>
/// <param name="value"></param>
/// <param name="sourceActivityExecution"></param>
/// <returns></returns>
protected internal override IVariableInstanceEntity CreateVariableInstance(string variableName, object value, IExecutionEntity sourceActivityExecution)
{
IVariableInstanceEntity result = base.CreateVariableInstance(variableName, value, sourceActivityExecution);
// Dispatch event, if needed
ProcessEngineConfigurationImpl processEngineConfiguration = Context.ProcessEngineConfiguration;
if (processEngineConfiguration is object && processEngineConfiguration.EventDispatcher.Enabled)
{
processEngineConfiguration.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateVariableEvent(ActivitiEventType.VARIABLE_CREATED, variableName, value, result.Type, result.TaskId, result.ExecutionId, ProcessInstanceId, ProcessDefinitionId));
}
return(result);
}
public virtual void DeleteProcessInstanceExecutionEntity(string processInstanceId, string currentFlowElementId, string deleteReason, bool cascade, bool cancel)
{
IExecutionEntity processInstanceEntity = FindById <IExecutionEntity>(new KeyValuePair <string, object>("id", processInstanceId));
if (processInstanceEntity == null)
{
throw new ActivitiObjectNotFoundException("No process instance found for id '" + processInstanceId + "'", typeof(IProcessInstance));
}
if (processInstanceEntity.Deleted)
{
return;
}
// Call activities
foreach (IExecutionEntity subExecutionEntity in processInstanceEntity.Executions)
{
if (subExecutionEntity.SubProcessInstance != null && !subExecutionEntity.Ended)
{
DeleteProcessInstanceCascade(subExecutionEntity.SubProcessInstance, deleteReason, cascade);
}
}
// delete event scope executions
foreach (IExecutionEntity childExecution in processInstanceEntity.Executions)
{
if (childExecution.IsEventScope)
{
DeleteExecutionAndRelatedData(childExecution, null, false);
}
}
DeleteChildExecutions(processInstanceEntity, deleteReason, cancel);
DeleteExecutionAndRelatedData(processInstanceEntity, deleteReason, cancel);
if (EventDispatcher.Enabled)
{
if (!cancel)
{
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.PROCESS_COMPLETED, processInstanceEntity));
}
else
{
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateCancelledEvent(processInstanceEntity.Id, processInstanceEntity.Id, processInstanceEntity.ProcessDefinitionId, deleteReason));
}
}
// TODO: what about delete reason?
HistoryManager.RecordProcessInstanceEnd(processInstanceEntity.Id, deleteReason, currentFlowElementId);
processInstanceEntity.Deleted = true;
}
protected internal static void ExecuteEventHandler(Event @event, IExecutionEntity parentExecution, IExecutionEntity currentExecution, string errorId)
{
ProcessEngineConfigurationImpl processEngineConfiguration = Context.ProcessEngineConfiguration;
if (processEngineConfiguration is object && processEngineConfiguration.EventDispatcher.Enabled)
{
BpmnModel bpmnModel = ProcessDefinitionUtil.GetBpmnModel(parentExecution.ProcessDefinitionId);
if (bpmnModel != null)
{
bpmnModel.Errors.TryGetValue(errorId, out string errorCode);
if (errorCode is null)
{
errorCode = errorId;
}
processEngineConfiguration.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateErrorEvent(ActivitiEventType.ACTIVITY_ERROR_RECEIVED, @event.Id, errorId, errorCode, parentExecution.Id, parentExecution.ProcessInstanceId, parentExecution.ProcessDefinitionId));
}
}
if (@event is StartEvent)
{
IExecutionEntityManager executionEntityManager = Context.CommandContext.ExecutionEntityManager;
if (!currentExecution.ParentId.Equals(parentExecution.Id))
{
Context.Agenda.PlanDestroyScopeOperation(currentExecution);
}
else
{
executionEntityManager.DeleteExecutionAndRelatedData(currentExecution, null, false);
}
IExecutionEntity eventSubProcessExecution = executionEntityManager.CreateChildExecution(parentExecution);
eventSubProcessExecution.CurrentFlowElement = @event;
Context.Agenda.PlanContinueProcessOperation(eventSubProcessExecution);
}
else
{
IExecutionEntity boundaryExecution = null;
IList <IExecutionEntity> childExecutions = parentExecution.Executions;
foreach (IExecutionEntity childExecution in childExecutions)
{
if (childExecution.ActivityId.Equals(@event.Id))
{
boundaryExecution = childExecution;
}
}
Context.Agenda.PlanTriggerExecutionOperation(boundaryExecution);
}
}
public virtual void CloseFailure(ICommandContext commandContext)
{
if (commandContext.EventDispatcher.Enabled)
{
commandContext.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityExceptionEvent(ActivitiEventType.JOB_EXECUTION_FAILURE, job, commandContext.Exception));
}
CommandConfig commandConfig = commandExecutor.DefaultConfig.TransactionRequiresNew();
IFailedJobCommandFactory failedJobCommandFactory = commandContext.FailedJobCommandFactory;
ICommand <object> cmd = failedJobCommandFactory.GetCommand(job.Id, commandContext.Exception);
log.LogTrace("Using FailedJobCommandFactory '" + failedJobCommandFactory.GetType() + "' and command of type '" + cmd.GetType() + "'");
commandExecutor.Execute(commandConfig, cmd);
}
public override void Delete(IJobEntity jobEntity)
{
base.Delete(jobEntity);
DeleteExceptionByteArrayRef(jobEntity);
RemoveExecutionLink(jobEntity);
// Send event
if (EventDispatcher.Enabled)
{
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.ENTITY_DELETED, this));
}
}
public virtual void Execute(IJobEntity job, string configuration, IExecutionEntity execution, ICommandContext commandContext)
{
Context.Agenda.PlanTriggerExecutionOperation(execution);
if (commandContext.EventDispatcher.Enabled)
{
commandContext.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.TIMER_FIRED, job));
}
if (execution.CurrentFlowElement is BoundaryEvent)
{
IList <string> processedElements = new List <string>();
DispatchExecutionTimeOut(job, execution, processedElements, commandContext);
}
}
public virtual void DeleteTasksByProcessInstanceId(string processInstanceId, string deleteReason, bool cascade)
{
IList <ITaskEntity> tasks = FindTasksByProcessInstanceId(processInstanceId);
foreach (ITaskEntity task in tasks)
{
if (EventDispatcher.Enabled && !task.Canceled)
{
task.Canceled = true;
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateActivityCancelledEvent(task.Execution.ActivityId, task.Name, task.ExecutionId, task.ProcessInstanceId, task.ProcessDefinitionId, "userTask", deleteReason));
}
DeleteTask(task, deleteReason, cascade, false);
}
}
protected internal virtual void DispatchActivityCancelled(IEventSubscriptionEntity eventSubscription, IExecutionEntity boundaryEventExecution, FlowNode flowNode, ICommandContext commandContext)
{
// Scope
commandContext.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateActivityCancelledEvent(flowNode.Id, flowNode.Name, boundaryEventExecution.Id, boundaryEventExecution.ProcessInstanceId, boundaryEventExecution.ProcessDefinitionId, ParseActivityType(flowNode), eventSubscription));
if (flowNode is SubProcess)
{
// The parent of the boundary event execution will be the one on which the boundary event is set
IExecutionEntity parentExecutionEntity = commandContext.ExecutionEntityManager.FindById <IExecutionEntity>(boundaryEventExecution.ParentId);
if (parentExecutionEntity != null)
{
DispatchActivityCancelledForChildExecution(eventSubscription, parentExecutionEntity, boundaryEventExecution, commandContext);
}
}
}
protected internal virtual IActivitiVariableEvent CreateVariableDeleteEvent(IVariableInstanceEntity variableInstance)
{
string processDefinitionId = null;
if (!(variableInstance.ProcessInstanceId is null))
{
IExecutionEntity executionEntity = ExecutionEntityManager.FindById <IExecutionEntity>(variableInstance.ProcessInstanceId);
if (executionEntity != null)
{
processDefinitionId = executionEntity.ProcessDefinitionId;
}
}
return(ActivitiEventBuilder.CreateVariableEvent(ActivitiEventType.VARIABLE_DELETED, variableInstance.Name, null, variableInstance.Type, variableInstance.TaskId, variableInstance.ExecutionId, variableInstance.ProcessInstanceId, processDefinitionId));
}
/// <summary>
///
/// </summary>
/// <param name="executionEntityManager"></param>
/// <param name="parentExecution"></param>
/// <param name="subProcess"></param>
/// <returns></returns>
protected internal virtual IExecutionEntity HandleSubProcessEnd(IExecutionEntityManager executionEntityManager, IExecutionEntity parentExecution, SubProcess subProcess)
{
// create a new execution to take the outgoing sequence flows
IExecutionEntity executionToContinue = executionEntityManager.CreateChildExecution(parentExecution.Parent);
executionToContinue.CurrentFlowElement = subProcess;
bool hasCompensation = false;
if (subProcess is Transaction)
{
hasCompensation = true;
}
else
{
foreach (FlowElement subElement in subProcess.FlowElements)
{
if (subElement is Activity subActivity)
{
if (CollectionUtil.IsNotEmpty(subActivity.BoundaryEvents))
{
foreach (BoundaryEvent boundaryEvent in subActivity.BoundaryEvents)
{
if (CollectionUtil.IsNotEmpty(boundaryEvent.EventDefinitions) && boundaryEvent.EventDefinitions[0] is CompensateEventDefinition)
{
hasCompensation = true;
break;
}
}
}
}
}
}
// All executions will be cleaned up afterwards. However, for compensation we need
// a copy of these executions so we can use them later on when the compensation is thrown.
// The following method does exactly that, and moves the executions beneath the process instance.
if (hasCompensation)
{
ScopeUtil.CreateCopyOfSubProcessExecutionForCompensation(parentExecution);
}
executionEntityManager.DeleteChildExecutions(parentExecution, null, false);
executionEntityManager.DeleteExecutionAndRelatedData(parentExecution, null, false);
Context.ProcessEngineConfiguration.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateActivityEvent(ActivitiEventType.ACTIVITY_COMPLETED, subProcess.Id, subProcess.Name, parentExecution.Id, parentExecution.ProcessInstanceId, parentExecution.ProcessDefinitionId, subProcess));
return(executionToContinue);
}
