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 static void CreateCopyOfSubProcessExecutionForCompensation(IExecutionEntity subProcessExecution)
{
IEventSubscriptionEntityManager eventSubscriptionEntityManager = Context.CommandContext.EventSubscriptionEntityManager;
IList <ICompensateEventSubscriptionEntity> compensateEventSubscriptions = eventSubscriptionEntityManager.FindCompensateEventSubscriptionsByExecutionId(subProcessExecution.Id);
if (CollectionUtil.IsNotEmpty(compensateEventSubscriptions))
{
IExecutionEntity processInstanceExecutionEntity = subProcessExecution.ProcessInstance;
IExecutionEntity eventScopeExecution = Context.CommandContext.ExecutionEntityManager.CreateChildExecution(processInstanceExecutionEntity);
eventScopeExecution.IsActive = false;
eventScopeExecution.IsEventScope = true;
eventScopeExecution.CurrentFlowElement = subProcessExecution.CurrentFlowElement;
// copy local variables to eventScopeExecution by value. This way,
// the eventScopeExecution references a 'snapshot' of the local variables
(new SubProcessVariableSnapshotter()).SetVariablesSnapshots(subProcessExecution, eventScopeExecution);
// set event subscriptions to the event scope execution:
foreach (ICompensateEventSubscriptionEntity eventSubscriptionEntity in compensateEventSubscriptions)
{
eventSubscriptionEntityManager.Delete(eventSubscriptionEntity);
ICompensateEventSubscriptionEntity newSubscription = eventSubscriptionEntityManager.InsertCompensationEvent(eventScopeExecution, eventSubscriptionEntity.ActivityId);
newSubscription.Configuration = eventSubscriptionEntity.Configuration;
newSubscription.Created = eventSubscriptionEntity.Created;
}
ICompensateEventSubscriptionEntity eventSubscription = eventSubscriptionEntityManager.InsertCompensationEvent(processInstanceExecutionEntity, eventScopeExecution.CurrentFlowElement.Id);
eventSubscription.Configuration = eventScopeExecution.Id;
}
}
public override void OnEvent(IActivitiEvent @event)
{
if (IsValidEvent(@event))
{
if (@event.ProcessInstanceId is null && processInstanceScope)
{
throw new ActivitiIllegalArgumentException("Cannot throw process-instance scoped signal, since the dispatched event is not part of an ongoing process instance");
}
ICommandContext commandContext = Context.CommandContext;
IEventSubscriptionEntityManager eventSubscriptionEntityManager = commandContext.EventSubscriptionEntityManager;
IList <ISignalEventSubscriptionEntity> subscriptionEntities;
if (processInstanceScope)
{
subscriptionEntities = eventSubscriptionEntityManager.FindSignalEventSubscriptionsByProcessInstanceAndEventName(@event.ProcessInstanceId, signalName);
}
else
{
string tenantId = null;
if (!(@event.ProcessDefinitionId is null))
{
IProcessDefinition processDefinition = commandContext.ProcessEngineConfiguration.DeploymentManager.FindDeployedProcessDefinitionById(@event.ProcessDefinitionId);
tenantId = processDefinition.TenantId;
}
subscriptionEntities = eventSubscriptionEntityManager.FindSignalEventSubscriptionsByEventName(signalName, tenantId);
}
foreach (ISignalEventSubscriptionEntity signalEventSubscriptionEntity in subscriptionEntities)
{
eventSubscriptionEntityManager.EventReceived(signalEventSubscriptionEntity, null, false);
}
}
}
public override void Trigger(IExecutionEntity execution, string triggerName, object triggerData, bool throwError = true)
{
IExecutionEntity executionEntity = execution;
BoundaryEvent boundaryEvent = (BoundaryEvent)execution.CurrentFlowElement;
if (boundaryEvent.CancelActivity)
{
string eventName;
if (signal != null)
{
eventName = signal.Name;
}
else
{
eventName = signalEventDefinition.SignalRef;
}
IEventSubscriptionEntityManager eventSubscriptionEntityManager = Context.CommandContext.EventSubscriptionEntityManager;
IList <IEventSubscriptionEntity> eventSubscriptions = executionEntity.EventSubscriptions;
foreach (IEventSubscriptionEntity eventSubscription in eventSubscriptions)
{
if (eventSubscription.EventType == SignalEventSubscriptionEntityFields.EVENT_TYPE && eventSubscription.EventName.Equals(eventName))
{
eventSubscriptionEntityManager.Delete(eventSubscription);
}
}
}
base.Trigger(executionEntity, triggerName, triggerData, throwError);
}
protected internal virtual IExecutionEntity DeleteSignalEventSubscription(IExecutionEntity execution)
{
string eventName;
if (signal != null)
{
eventName = signal.Name;
}
else
{
eventName = signalEventDefinition.SignalRef;
}
IEventSubscriptionEntityManager eventSubscriptionEntityManager = Context.CommandContext.EventSubscriptionEntityManager;
IList <IEventSubscriptionEntity> eventSubscriptions = execution.EventSubscriptions;
foreach (IEventSubscriptionEntity eventSubscription in eventSubscriptions)
{
if (eventSubscription.EventType == SignalEventSubscriptionEntityFields.EVENT_TYPE && eventSubscription.EventName.Equals(eventName))
{
eventSubscriptionEntityManager.Delete(eventSubscription);
}
}
return(execution);
}
public override void Execute(IExecutionEntity execution)
{
ThrowEvent throwEvent = (ThrowEvent)execution.CurrentFlowElement;
/*
* From the BPMN 2.0 spec:
*
* The Activity to be compensated MAY be supplied.
*
* If an Activity is not supplied, then the compensation is broadcast to all completed Activities in
* the current Sub- Process (if present), or the entire Process instance (if at the global level). This "throws" the compensation.
*/
string activityRef = compensateEventDefinition.ActivityRef;
ICommandContext commandContext = Context.CommandContext;
IEventSubscriptionEntityManager eventSubscriptionEntityManager = commandContext.EventSubscriptionEntityManager;
IList <ICompensateEventSubscriptionEntity> eventSubscriptions = new List <ICompensateEventSubscriptionEntity>();
if (!string.IsNullOrWhiteSpace(activityRef))
{
// If an activity ref is provided, only that activity is compensated
((List <ICompensateEventSubscriptionEntity>)eventSubscriptions).AddRange(eventSubscriptionEntityManager.FindCompensateEventSubscriptionsByProcessInstanceIdAndActivityId(execution.ProcessInstanceId, activityRef));
}
else
{
// If no activity ref is provided, it is broadcast to the current sub process / process instance
Process process = ProcessDefinitionUtil.GetProcess(execution.ProcessDefinitionId);
IFlowElementsContainer flowElementsContainer;
if (throwEvent.SubProcess == null)
{
flowElementsContainer = process;
}
else
{
flowElementsContainer = throwEvent.SubProcess;
}
foreach (FlowElement flowElement in flowElementsContainer.FlowElements)
{
if (flowElement is Activity)
{
((List <ICompensateEventSubscriptionEntity>)eventSubscriptions).AddRange(eventSubscriptionEntityManager.FindCompensateEventSubscriptionsByProcessInstanceIdAndActivityId(execution.ProcessInstanceId, flowElement.Id));
}
}
}
if (eventSubscriptions.Count == 0)
{
Leave(execution);
}
else
{
// TODO: implement async (waitForCompletion=false in bpmn)
ScopeUtil.ThrowCompensationEvent(eventSubscriptions, execution, false);
Leave(execution);
}
}
public override void Trigger(IExecutionEntity execution, string triggerName, object triggerData, bool throwError = true)
{
BoundaryEvent boundaryEvent = (BoundaryEvent)execution.CurrentFlowElement;
ICommandContext commandContext = Context.CommandContext;
IExecutionEntityManager executionEntityManager = commandContext.ExecutionEntityManager;
IExecutionEntity subProcessExecution = null;
// TODO: this can be optimized. A full search in the all executions shouldn't be needed
IList <IExecutionEntity> processInstanceExecutions = executionEntityManager.FindChildExecutionsByProcessInstanceId(execution.ProcessInstanceId);
foreach (IExecutionEntity childExecution in processInstanceExecutions)
{
if (childExecution.CurrentFlowElement != null && childExecution.CurrentFlowElement.Id.Equals(boundaryEvent.AttachedToRefId))
{
subProcessExecution = childExecution;
break;
}
}
if (subProcessExecution == null)
{
throw new ActivitiException("No execution found for sub process of boundary cancel event " + boundaryEvent.Id);
}
IEventSubscriptionEntityManager eventSubscriptionEntityManager = commandContext.EventSubscriptionEntityManager;
IList <ICompensateEventSubscriptionEntity> eventSubscriptions = eventSubscriptionEntityManager.FindCompensateEventSubscriptionsByExecutionId(subProcessExecution.ParentId);
if (eventSubscriptions.Count == 0)
{
Leave(execution);
}
else
{
Leave(execution);
string deleteReason = History.DeleteReasonFields.BOUNDARY_EVENT_INTERRUPTING + "(" + boundaryEvent.Id + ")";
// cancel boundary is always sync
ScopeUtil.ThrowCompensationEvent(eventSubscriptions, execution, false);
executionEntityManager.DeleteExecutionAndRelatedData(subProcessExecution, deleteReason, false);
if (subProcessExecution.CurrentFlowElement is Activity activity)
{
if (activity.LoopCharacteristics != null)
{
IExecutionEntity miExecution = subProcessExecution.Parent;
IList <IExecutionEntity> miChildExecutions = executionEntityManager.FindChildExecutionsByParentExecutionId(miExecution.Id);
foreach (IExecutionEntity miChildExecution in miChildExecutions)
{
if (subProcessExecution.Id.Equals(miChildExecution.Id) == false && activity.Id.Equals(miChildExecution.CurrentActivityId))
{
executionEntityManager.DeleteExecutionAndRelatedData(miChildExecution, deleteReason, false);
}
}
}
}
}
}
protected internal virtual void RemoveObsoleteEventSubscriptionsImpl(IProcessDefinitionEntity processDefinition, string eventHandlerType)
{
// remove all subscriptions for the previous version
IEventSubscriptionEntityManager eventSubscriptionEntityManager = Context.CommandContext.EventSubscriptionEntityManager;
IList <IEventSubscriptionEntity> subscriptionsToDelete = eventSubscriptionEntityManager.FindEventSubscriptionsByTypeAndProcessDefinitionId(eventHandlerType, processDefinition.Id, processDefinition.TenantId);
foreach (IEventSubscriptionEntity eventSubscriptionEntity in subscriptionsToDelete)
{
eventSubscriptionEntityManager.Delete(eventSubscriptionEntity);
}
}
public virtual void Execute(IJobEntity job, string configuration, IExecutionEntity execution, ICommandContext commandContext)
{
IEventSubscriptionEntityManager eventSubscriptionEntityManager = commandContext.EventSubscriptionEntityManager;
// lookup subscription:
IEventSubscriptionEntity eventSubscriptionEntity = eventSubscriptionEntityManager.FindById <IEventSubscriptionEntity>(new KeyValuePair <string, object>("id", configuration));
// if event subscription is null, ignore
if (eventSubscriptionEntity != null)
{
eventSubscriptionEntityManager.EventReceived(eventSubscriptionEntity, null, false);
}
}
protected internal virtual IExecutionEntity DeleteMessageEventSubScription(IExecutionEntity execution)
{
IEventSubscriptionEntityManager eventSubscriptionEntityManager = Context.CommandContext.EventSubscriptionEntityManager;
IList <IEventSubscriptionEntity> eventSubscriptions = execution.EventSubscriptions;
foreach (IEventSubscriptionEntity eventSubscription in eventSubscriptions)
{
if (eventSubscription.EventType == MessageEventSubscriptionEntityFields.EVENT_TYPE && eventSubscription.EventName.Equals(messageEventDefinition.MessageRef))
{
eventSubscriptionEntityManager.Delete(eventSubscription);
}
}
return(execution);
}
public virtual object Execute(ICommandContext commandContext)
{
IEventSubscriptionEntityManager eventSubscriptionEntityManager = commandContext.EventSubscriptionEntityManager;
IList <ISignalEventSubscriptionEntity> signalEvents;
if (executionId is null)
{
signalEvents = eventSubscriptionEntityManager.FindSignalEventSubscriptionsByEventName(eventName, tenantId);
}
else
{
IExecutionEntity execution = commandContext.ExecutionEntityManager.FindById <IExecutionEntity>(executionId);
if (execution == null)
{
throw new ActivitiObjectNotFoundException("Cannot find execution with id '" + executionId + "'", typeof(IExecution));
}
if (execution.Suspended)
{
throw new ActivitiException("Cannot throw signal event '" + eventName + "' because execution '" + executionId + "' is suspended");
}
signalEvents = eventSubscriptionEntityManager.FindSignalEventSubscriptionsByNameAndExecution(eventName, executionId);
if (signalEvents.Count == 0)
{
throw new ActivitiException("Execution '" + executionId + "' has not subscribed to a signal event with name '" + eventName + "'.");
}
}
foreach (ISignalEventSubscriptionEntity signalEventSubscriptionEntity in signalEvents)
{
// We only throw the event to globally scoped signals.
// Process instance scoped signals must be thrown within the process itself
if (signalEventSubscriptionEntity.GlobalScoped)
{
Context.ProcessEngineConfiguration.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateSignalEvent(ActivitiEventType.ACTIVITY_SIGNALED, signalEventSubscriptionEntity.ActivityId, eventName, payload, signalEventSubscriptionEntity.ExecutionId, signalEventSubscriptionEntity.ProcessInstanceId, signalEventSubscriptionEntity.ProcessDefinitionId));
eventSubscriptionEntityManager.EventReceived(signalEventSubscriptionEntity, payload, async);
}
}
return(null);
}
public override void OnEvent(IActivitiEvent @event)
{
if (IsValidEvent(@event))
{
if (@event.ProcessInstanceId is null)
{
throw new ActivitiIllegalArgumentException("Cannot throw process-instance scoped message, since the dispatched event is not part of an ongoing process instance");
}
IEventSubscriptionEntityManager eventSubscriptionEntityManager = Context.CommandContext.EventSubscriptionEntityManager;
IList <IMessageEventSubscriptionEntity> subscriptionEntities = eventSubscriptionEntityManager.FindMessageEventSubscriptionsByProcessInstanceAndEventName(@event.ProcessInstanceId, messageName);
foreach (IEventSubscriptionEntity messageEventSubscriptionEntity in subscriptionEntities)
{
eventSubscriptionEntityManager.EventReceived(messageEventSubscriptionEntity, null, false);
}
}
}
public override void Trigger(IExecutionEntity execution, string triggerName, object triggerData, bool throwError = true)
{
BoundaryEvent boundaryEvent = (BoundaryEvent)execution.CurrentFlowElement;
if (boundaryEvent.CancelActivity)
{
IEventSubscriptionEntityManager eventSubscriptionEntityManager = Context.CommandContext.EventSubscriptionEntityManager;
IList <IEventSubscriptionEntity> eventSubscriptions = execution.EventSubscriptions;
foreach (IEventSubscriptionEntity eventSubscription in eventSubscriptions)
{
if (eventSubscription.EventType == CompensateEventSubscriptionEntityFields.EVENT_TYPE && eventSubscription.ActivityId.Equals(compensateEventDefinition.ActivityRef))
{
eventSubscriptionEntityManager.Delete(eventSubscription);
}
}
}
base.Trigger(execution, triggerName, triggerData, throwError);
}
public override void Trigger(IExecutionEntity execution, string triggerName, object triggerData, bool throwError = true)
{
ICommandContext commandContext = Context.CommandContext;
IExecutionEntityManager executionEntityManager = commandContext.ExecutionEntityManager;
StartEvent startEvent = (StartEvent)execution.CurrentFlowElement;
if (startEvent.Interrupting)
{
IList <IExecutionEntity> childExecutions = executionEntityManager.FindChildExecutionsByParentExecutionId(execution.ParentId);
foreach (IExecutionEntity childExecution in childExecutions)
{
if (!childExecution.Id.Equals(execution.Id))
{
executionEntityManager.DeleteExecutionAndRelatedData(childExecution, History.DeleteReasonFields.EVENT_SUBPROCESS_INTERRUPTING + "(" + startEvent.Id + ")", false);
}
}
}
IEventSubscriptionEntityManager eventSubscriptionEntityManager = Context.CommandContext.EventSubscriptionEntityManager;
IList <IEventSubscriptionEntity> eventSubscriptions = execution.EventSubscriptions;
foreach (IEventSubscriptionEntity eventSubscription in eventSubscriptions)
{
if (eventSubscription.EventType == MessageEventSubscriptionEntityFields.EVENT_TYPE && eventSubscription.EventName.Equals(messageEventDefinition.MessageRef))
{
eventSubscriptionEntityManager.Delete(eventSubscription);
}
}
execution.CurrentFlowElement = (SubProcess)execution.CurrentFlowElement.ParentContainer;
execution.IsScope = true;
IExecutionEntity outgoingFlowExecution = executionEntityManager.CreateChildExecution(execution);
outgoingFlowExecution.CurrentFlowElement = startEvent;
Leave(outgoingFlowExecution);
}
protected internal override object Execute(ICommandContext commandContext, IExecutionEntity execution)
{
if (messageName is null)
{
throw new ActivitiIllegalArgumentException("messageName cannot be null");
}
IEventSubscriptionEntityManager eventSubscriptionEntityManager = commandContext.EventSubscriptionEntityManager;
IList <IEventSubscriptionEntity> eventSubscriptions = eventSubscriptionEntityManager.FindEventSubscriptionsByNameAndExecution(MessageEventHandler.EVENT_HANDLER_TYPE, messageName, executionId);
if (eventSubscriptions.Count == 0)
{
throw new ActivitiException("Execution with id '" + executionId + "' does not have a subscription to a message event with name '" + messageName + "'");
}
// there can be only one:
IEventSubscriptionEntity eventSubscriptionEntity = eventSubscriptions[0];
eventSubscriptionEntityManager.EventReceived(eventSubscriptionEntity, payload, async);
return(null);
}
public override void Execute(IExecutionEntity execution)
{
ICommandContext commandContext = Context.CommandContext;
string eventSubscriptionName;
if (signalEventName is object)
{
eventSubscriptionName = signalEventName;
}
else
{
IExpression expressionObject = commandContext.ProcessEngineConfiguration.ExpressionManager.CreateExpression(signalExpression);
eventSubscriptionName = expressionObject.GetValue(execution).ToString();
}
IEventSubscriptionEntityManager eventSubscriptionEntityManager = commandContext.EventSubscriptionEntityManager;
IList <ISignalEventSubscriptionEntity> subscriptionEntities;
if (processInstanceScope)
{
subscriptionEntities = eventSubscriptionEntityManager.FindSignalEventSubscriptionsByProcessInstanceAndEventName(execution.ProcessInstanceId, eventSubscriptionName);
}
else
{
subscriptionEntities = eventSubscriptionEntityManager.FindSignalEventSubscriptionsByEventName(eventSubscriptionName, execution.TenantId);
}
foreach (ISignalEventSubscriptionEntity signalEventSubscriptionEntity in subscriptionEntities)
{
Context.ProcessEngineConfiguration.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateSignalEvent(ActivitiEventType.ACTIVITY_SIGNALED, signalEventSubscriptionEntity.ActivityId, eventSubscriptionName, null, signalEventSubscriptionEntity.ExecutionId, signalEventSubscriptionEntity.ProcessInstanceId, signalEventSubscriptionEntity.ProcessDefinitionId));
eventSubscriptionEntityManager.EventReceived(signalEventSubscriptionEntity, null, signalEventDefinition.Async);
}
Context.Agenda.PlanTakeOutgoingSequenceFlowsOperation(execution, true);
}
protected internal virtual void deleteEventSubscriptions(IProcessDefinition processDefinition)
{
IEventSubscriptionEntityManager eventSubscriptionEntityManager = EventSubscriptionEntityManager;
eventSubscriptionEntityManager.DeleteEventSubscriptionsForProcessDefinition(processDefinition.Id);
}
public virtual void DeleteDataForExecution(IExecutionEntity executionEntity, string deleteReason, bool cancel)
{
// To start, deactivate the current incoming execution
executionEntity.Ended = true;
executionEntity.IsActive = false;
bool enableExecutionRelationshipCounts = IsExecutionRelatedEntityCountEnabled(executionEntity);
if (executionEntity.Id.Equals(executionEntity.ProcessInstanceId) && (!enableExecutionRelationshipCounts || (enableExecutionRelationshipCounts && ((ICountingExecutionEntity)executionEntity).IdentityLinkCount > 0)))
{
IIdentityLinkEntityManager identityLinkEntityManager = IdentityLinkEntityManager;
ICollection <IIdentityLinkEntity> identityLinks = identityLinkEntityManager.FindIdentityLinksByProcessInstanceId(executionEntity.ProcessInstanceId);
foreach (IIdentityLinkEntity identityLink in identityLinks)
{
identityLinkEntityManager.Delete(identityLink);
}
}
// Get variables related to execution and delete them
if (!enableExecutionRelationshipCounts || (enableExecutionRelationshipCounts && ((ICountingExecutionEntity)executionEntity).VariableCount > 0))
{
ICollection <IVariableInstance> executionVariables = executionEntity.VariableInstancesLocal.Values;
foreach (IVariableInstance variableInstance in executionVariables)
{
if (variableInstance is IVariableInstanceEntity variableInstanceEntity)
{
IVariableInstanceEntityManager variableInstanceEntityManager = VariableInstanceEntityManager;
variableInstanceEntityManager.Delete(variableInstanceEntity);
if (variableInstanceEntity.ByteArrayRef != null && variableInstanceEntity.ByteArrayRef.Id is object)
{
ByteArrayEntityManager.DeleteByteArrayById(variableInstanceEntity.ByteArrayRef.Id);
}
}
}
}
// Delete current user tasks
if (!enableExecutionRelationshipCounts || (enableExecutionRelationshipCounts && ((ICountingExecutionEntity)executionEntity).TaskCount > 0))
{
ITaskEntityManager taskEntityManager = TaskEntityManager;
ICollection <ITaskEntity> tasksForExecution = taskEntityManager.FindTasksByExecutionId(executionEntity.Id);
foreach (ITaskEntity taskEntity in tasksForExecution)
{
taskEntityManager.DeleteTask(taskEntity, deleteReason, false, cancel);
}
}
// Delete jobs
if (!enableExecutionRelationshipCounts || (enableExecutionRelationshipCounts && ((ICountingExecutionEntity)executionEntity).TimerJobCount > 0))
{
ITimerJobEntityManager timerJobEntityManager = TimerJobEntityManager;
ICollection <ITimerJobEntity> timerJobsForExecution = timerJobEntityManager.FindJobsByExecutionId(executionEntity.Id);
foreach (ITimerJobEntity job in timerJobsForExecution)
{
timerJobEntityManager.Delete(job);
if (EventDispatcher.Enabled)
{
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.JOB_CANCELED, job));
}
}
}
if (!enableExecutionRelationshipCounts || (enableExecutionRelationshipCounts && ((ICountingExecutionEntity)executionEntity).JobCount > 0))
{
IJobEntityManager jobEntityManager = JobEntityManager;
ICollection <IJobEntity> jobsForExecution = jobEntityManager.FindJobsByExecutionId(executionEntity.Id);
foreach (IJobEntity job in jobsForExecution)
{
JobEntityManager.Delete(job);
if (EventDispatcher.Enabled)
{
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.JOB_CANCELED, job));
}
}
}
if (!enableExecutionRelationshipCounts || (enableExecutionRelationshipCounts && ((ICountingExecutionEntity)executionEntity).SuspendedJobCount > 0))
{
ISuspendedJobEntityManager suspendedJobEntityManager = SuspendedJobEntityManager;
ICollection <ISuspendedJobEntity> suspendedJobsForExecution = suspendedJobEntityManager.FindJobsByExecutionId(executionEntity.Id);
foreach (ISuspendedJobEntity job in suspendedJobsForExecution)
{
suspendedJobEntityManager.Delete(job);
if (EventDispatcher.Enabled)
{
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.JOB_CANCELED, job));
}
}
}
if (!enableExecutionRelationshipCounts || (enableExecutionRelationshipCounts && ((ICountingExecutionEntity)executionEntity).DeadLetterJobCount > 0))
{
IDeadLetterJobEntityManager deadLetterJobEntityManager = DeadLetterJobEntityManager;
ICollection <IDeadLetterJobEntity> deadLetterJobsForExecution = deadLetterJobEntityManager.FindJobsByExecutionId(executionEntity.Id);
foreach (IDeadLetterJobEntity job in deadLetterJobsForExecution)
{
deadLetterJobEntityManager.Delete(job);
if (EventDispatcher.Enabled)
{
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.JOB_CANCELED, job));
}
}
}
// Delete event subscriptions
if (!enableExecutionRelationshipCounts || (enableExecutionRelationshipCounts && ((ICountingExecutionEntity)executionEntity).EventSubscriptionCount > 0))
{
IEventSubscriptionEntityManager eventSubscriptionEntityManager = EventSubscriptionEntityManager;
IList <IEventSubscriptionEntity> eventSubscriptions = eventSubscriptionEntityManager.FindEventSubscriptionsByExecution(executionEntity.Id);
foreach (IEventSubscriptionEntity eventSubscription in eventSubscriptions)
{
eventSubscriptionEntityManager.Delete(eventSubscription);
}
}
}
