Example #1
0
        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);
            }
        }
Example #2
0
        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);
                }
            }
        }
Example #3
0
        protected internal virtual void DispatchActivityCancelledForChildExecution(IEventSubscriptionEntity eventSubscription, IExecutionEntity parentExecutionEntity, IExecutionEntity boundaryEventExecution, ICommandContext commandContext)
        {
            IList <IExecutionEntity> executionEntities = commandContext.ExecutionEntityManager.FindChildExecutionsByParentExecutionId(parentExecutionEntity.Id);

            foreach (IExecutionEntity childExecution in executionEntities)
            {
                if (!boundaryEventExecution.Id.Equals(childExecution.Id) && childExecution.CurrentFlowElement != null && childExecution.CurrentFlowElement is FlowNode)
                {
                    FlowNode flowNode = (FlowNode)childExecution.CurrentFlowElement;
                    commandContext.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateActivityCancelledEvent(flowNode.Id, flowNode.Name, childExecution.Id, childExecution.ProcessInstanceId, childExecution.ProcessDefinitionId, ParseActivityType(flowNode), eventSubscription));

                    if (childExecution.IsScope)
                    {
                        DispatchActivityCancelledForChildExecution(eventSubscription, childExecution, boundaryEventExecution, commandContext);
                    }
                }
            }
        }
Example #4
0
        public virtual void DeleteTask(ITaskEntity task, string deleteReason, bool cascade, bool cancel)
        {
            if (!task.Deleted)
            {
                ProcessEngineConfiguration.ListenerNotificationHelper.ExecuteTaskListeners(task, BaseTaskListenerFields.EVENTNAME_DELETE);
                task.Deleted = true;

                string taskId = task.Id;

                IList <ITask> subTasks = FindTasksByParentTaskId(taskId);
                foreach (ITask subTask in subTasks)
                {
                    DeleteTask((ITaskEntity)subTask, deleteReason, cascade, cancel);
                }

                IdentityLinkEntityManager.DeleteIdentityLinksByTaskId(taskId);
                VariableInstanceEntityManager.DeleteVariableInstanceByTask(task);

                if (cascade)
                {
                    HistoricTaskInstanceEntityManager.Delete(new KeyValuePair <string, object>("id", taskId));
                }
                else
                {
                    HistoryManager.RecordTaskEnd(taskId, deleteReason);
                }

                Delete(task, false);

                if (EventDispatcher.Enabled)
                {
                    if (cancel && !task.Canceled)
                    {
                        task.Canceled = true;
                        EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateActivityCancelledEvent(task.Execution?.ActivityId, task.Name, task.ExecutionId, task.ProcessInstanceId, task.ProcessDefinitionId, "userTask", deleteReason));
                    }

                    EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.ENTITY_DELETED, task));
                }
            }
        }
 protected internal virtual void DispatchActivityCancelled(IExecutionEntity execution, FlowElement terminateEndEvent)
 {
     Context.ProcessEngineConfiguration.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateActivityCancelledEvent(execution.CurrentFlowElement.Id, execution.CurrentFlowElement.Name, execution.Id, execution.ProcessInstanceId, execution.ProcessDefinitionId, ParseActivityType((FlowNode)execution.CurrentFlowElement), terminateEndEvent));
 }
 protected internal virtual void DispatchActivityTimeOut(IJobEntity timerEntity, FlowNode flowNode, IExecutionEntity execution, ICommandContext commandContext)
 {
     commandContext.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateActivityCancelledEvent(flowNode.Id, flowNode.Name, execution.Id, execution.ProcessInstanceId, execution.ProcessDefinitionId, ParseActivityType(flowNode), timerEntity));
 }