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