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); } } }