public virtual void DispatchEvent(IActivitiEvent @event)
{
if (@event == null)
{
throw new ActivitiIllegalArgumentException("Event cannot be null.");
}
if (@event.Type == null)
{
throw new ActivitiIllegalArgumentException("Event type cannot be null.");
}
// Call global listeners
if (eventListeners.Count > 0)
{
foreach (IActivitiEventListener listener in eventListeners)
{
DispatchEvent(@event, listener);
}
}
// Call typed listeners, if any
typedListeners.TryGetValue(@event.Type, out IList <IActivitiEventListener> typed);
if (typed != null && typed.Count > 0)
{
foreach (IActivitiEventListener listener in typed)
{
DispatchEvent(@event, listener);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="activitiEvent"></param>
/// <returns></returns>
public static string GetPrefix(IActivitiEvent activitiEvent)
{
if (IsProcessEvent(activitiEvent))
{
return(PROCESS_EVENT_PREFIX);
}
else if (IsTaskEvent(activitiEvent))
{
return(TASK_EVENT_PREFIX);
}
else if (IsIdentityLinkEntityEvent(activitiEvent))
{
IIdentityLink identityLinkEntity = (IIdentityLink)((IActivitiEntityEvent)activitiEvent).Entity;
if (IsCandidateUserEntity(identityLinkEntity))
{
return(TASK_CANDIDATE_USER_EVENT_PREFIX);
}
else if (IsCandidateGroupEntity(identityLinkEntity))
{
return(TASK_CANDIDATE_GROUP_EVENT_PREFIX);
}
}
return(EVENT_PREFIX);
}
public override void OnEvent(IActivitiEvent @event)
{
if (IsValidEvent(@event))
{
//仅是为了执行一次退栈操作
_ = Context.CommandContext;
IExecutionEntity execution = null;
if (@event.ExecutionId is object)
{
// Get the execution based on the event's execution ID instead execution = Context.CommandContext.ExecutionEntityManager.findById<instead>(new KeyValuePair<string, object>("id", @event.ExecutionId));
}
if (execution == null)
{
throw new ActivitiException("No execution context active and event is not related to an execution. No compensation event can be thrown.");
}
try
{
ErrorPropagation.PropagateError(errorCode, execution);
}
catch (Exception e)
{
throw new ActivitiException("Error while propagating error-event", e);
}
}
}
public virtual void OnEvent(IActivitiEvent @event)
{
IEventLoggerEventHandler eventHandler = GetEventHandler(@event);
if (eventHandler != null)
{
// Events are flushed when command context is closed
ICommandContext currentCommandContext = Context.CommandContext;
IEventFlusher eventFlusher = (IEventFlusher)currentCommandContext.GetAttribute(EVENT_FLUSHER_KEY);
if (eventFlusher == null)
{
eventFlusher = CreateEventFlusher();
if (eventFlusher == null)
{
eventFlusher = new DatabaseEventFlusher(); // Default
}
currentCommandContext.AddAttribute(EVENT_FLUSHER_KEY, eventFlusher);
currentCommandContext.AddCloseListener(eventFlusher);
currentCommandContext.AddCloseListener(new CommandContextCloseListenerAnonymousInnerClass(this));
}
eventFlusher.AddEventHandler(eventHandler);
}
}
public override void OnEvent(IActivitiEvent @event)
{
if (IsValidEvent(@event))
{
DelegateInstance.OnEvent(@event);
}
}
public void OnEvent(IActivitiEvent @event)
{
if (IsValidEvent(@event))
{
// Check if this event
if (@event.Type == ActivitiEventType.ENTITY_CREATED)
{
OnCreate(@event);
}
else if (@event.Type == ActivitiEventType.ENTITY_INITIALIZED)
{
OnInitialized(@event);
}
else if (@event.Type == ActivitiEventType.ENTITY_DELETED)
{
OnDelete(@event);
}
else if (@event.Type == ActivitiEventType.ENTITY_UPDATED)
{
OnUpdate(@event);
}
else
{
// Entity-specific event
OnEntityEvent(@event);
}
}
}
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);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="event"></param>
public override void OnEvent(IActivitiEvent @event)
{
if (@event is CustomTaskCompletedEntityEventImpl taskEvent)
{
ITaskEntity taskEntity = taskEvent.Entity as ITaskEntity;
ICommandContext commandContext = Context.CommandContext;
IExecutionEntity execution = taskEntity.Execution;
UserTask userTask = execution.CurrentFlowElement as UserTask;
if (userTask.HasMultiInstanceLoopCharacteristics() &&
(taskEntity.IsAppend.GetValueOrDefault(false) ||
taskEntity.IsTransfer.GetValueOrDefault(false)))
{
IExecutionEntity parent = execution.FindMultiInstanceParentExecution();
var collection = userTask.LoopCharacteristics.GetCollectionVarName();
IList <string> users = parent.GetLoopVariable <IList <string> >(collection);
string usr = users.FirstOrDefault(x => x.Equals(taskEntity.Assignee, StringComparison.OrdinalIgnoreCase));
if (usr != null)
{
users.Remove(usr);
parent.SetLoopVariable(collection, users);
}
}
}
}
public virtual void DispatchEvent(IActivitiEvent @event)
{
if (enabled)
{
eventSupport.DispatchEvent(@event);
}
if (@event.Type == ActivitiEventType.ENTITY_DELETED && @event is IActivitiEntityEvent)
{
IActivitiEntityEvent entityEvent = (IActivitiEntityEvent)@event;
if (entityEvent.Entity is IProcessDefinition)
{
// process definition deleted event doesn't need to be dispatched to event listeners
return;
}
}
// Try getting hold of the Process definition, based on the process definition key, if a context is active
ICommandContext commandContext = Context.CommandContext;
if (commandContext != null)
{
BpmnModel bpmnModel = ExtractBpmnModelFromEvent(@event);
if (bpmnModel != null)
{
((ActivitiEventSupport)bpmnModel.EventSupport).DispatchEvent(@event);
}
}
}
public override void OnEvent(IActivitiEvent @event)
{
if (IsValidEvent(@event))
{
var commandContext = Context.CommandContext;
IExecutionEntity execution = null;
if (@event.ExecutionId is object)
{
// Get the execution based on the event's execution ID instead
execution = commandContext.ExecutionEntityManager.FindById <IExecutionEntity>(@event.ExecutionId);
}
if (execution is null)
{
throw new ActivitiException("No execution context active and event is not related to an execution. No compensation event can be thrown.");
}
try
{
ErrorPropagation.PropagateError(errorCode, execution);
}
catch (Exception e)
{
throw new ActivitiException("Error while propagating error-event", e);
}
}
}
public override void OnEvent(IActivitiEvent @event)
{
throw new NotImplementedException();
//if (isValidEvent(@event))
//{
// object @delegate = DelegateExpressionUtil.resolveDelegateExpression(expression, new NoExecutionVariableScope());
// if (@delegate is IActivitiEventListener)
// {
// // Cache result of isFailOnException() from delegate-instance
// // until next event is received. This prevents us from having to resolve
// // the expression twice when an error occurs.
// failOnException = ((IActivitiEventListener)@delegate).FailOnException;
// // Call the delegate
// ((IActivitiEventListener)@delegate).onEvent(@event);
// }
// else
// {
// // Force failing, since the exception we're about to throw
// // cannot be ignored, because it did not originate from the listener itself
// failOnException = true;
// throw new ActivitiIllegalArgumentException("Delegate expression " + expression + " did not resolve to an implementation of " + typeof(IActivitiEventListener).FullName);
// }
//}
}
/// <summary>
///
/// </summary>
/// <param name="event"></param>
public virtual void OnEvent(IActivitiEvent @event)
{
IProcessEngineEvent newEvent = converterContext.From(@event);
if (newEvent != null)
{
eventsAggregator.Add(newEvent);
}
}
/// <summary>
///
/// </summary>
public override IProcessEngineEvent From(IActivitiEvent @event)
{
return(new TaskCandidateGroupAddedEventImpl(RuntimeBundleProperties.AppName, RuntimeBundleProperties.AppVersion,
RuntimeBundleProperties.ServiceName,
RuntimeBundleProperties.ServiceFullName,
RuntimeBundleProperties.ServiceType,
RuntimeBundleProperties.ServiceVersion,
@event.ExecutionId,
@event.ProcessDefinitionId,
@event.ProcessInstanceId,
taskCandidateGroupConverter.From((IIdentityLink)((IActivitiEntityEvent)@event).Entity)));
}
/// <summary>
///
/// </summary>
public override IProcessEngineEvent From(IActivitiEvent @event)
{
return(new ProcessSuspendedEventImpl(RuntimeBundleProperties.AppName,
RuntimeBundleProperties.AppVersion,
RuntimeBundleProperties.ServiceName,
RuntimeBundleProperties.ServiceFullName,
RuntimeBundleProperties.ServiceType,
RuntimeBundleProperties.ServiceVersion,
@event.ExecutionId,
@event.ProcessDefinitionId,
@event.ProcessInstanceId,
processInstanceConverter.From(((IExecutionEntity)((IActivitiEntityEvent)@event).Entity).ProcessInstance)));
}
/// <summary>
///
/// </summary>
public override IProcessEngineEvent From(IActivitiEvent @event)
{
return(new VariableDeletedEventImpl(RuntimeBundleProperties.AppName,
RuntimeBundleProperties.AppVersion,
RuntimeBundleProperties.ServiceName,
RuntimeBundleProperties.ServiceFullName,
RuntimeBundleProperties.ServiceType,
RuntimeBundleProperties.ServiceVersion,
@event.ExecutionId,
@event.ProcessDefinitionId,
@event.ProcessInstanceId,
((IActivitiVariableEvent)@event).VariableName,
((IActivitiVariableEvent)@event).VariableType.TypeName,
((IActivitiVariableEvent)@event).TaskId));
}
/// <summary>
///
/// </summary>
public override IProcessEngineEvent From(IActivitiEvent @event)
{
return(new ActivityStartedEventImpl(RuntimeBundleProperties.AppName,
RuntimeBundleProperties.AppVersion,
RuntimeBundleProperties.ServiceName,
RuntimeBundleProperties.ServiceFullName,
RuntimeBundleProperties.ServiceType,
RuntimeBundleProperties.ServiceVersion,
@event.ExecutionId,
@event.ProcessDefinitionId,
@event.ProcessInstanceId,
((IActivitiActivityEvent)@event).ActivityId,
((IActivitiActivityEvent)@event).ActivityName,
((IActivitiActivityEvent)@event).ActivityType));
}
/// <summary>
/// In case no process-context is active, this method attempts to extract a process-definition based on the event. In case it's an event related to an entity, this can be deducted by inspecting the
/// entity, without additional queries to the database.
///
/// If not an entity-related event, the process-definition will be retrieved based on the processDefinitionId (if filled in). This requires an additional query to the database in case not already
/// cached. However, queries will only occur when the definition is not yet in the cache, which is very unlikely to happen, unless evicted.
/// </summary>
/// <param name="event">
/// @return </param>
protected internal virtual BpmnModel ExtractBpmnModelFromEvent(IActivitiEvent @event)
{
BpmnModel result = null;
if (result == null && !(@event.ProcessDefinitionId is null))
{
IProcessDefinition processDefinition = ProcessDefinitionUtil.GetProcessDefinition(@event.ProcessDefinitionId, true);
if (processDefinition != null)
{
result = Context.ProcessEngineConfiguration.DeploymentManager.ResolveProcessDefinition(processDefinition).BpmnModel;
}
}
return(result);
}
protected internal virtual IEventLoggerEventHandler InstantiateEventHandler(IActivitiEvent @event, Type eventHandlerClass)
{
try
{
IEventLoggerEventHandler eventHandler = Activator.CreateInstance(eventHandlerClass) as IEventLoggerEventHandler;
eventHandler.TimeStamp = clock.CurrentTime;
eventHandler.Event = @event;
eventHandler.ObjectMapper = objectMapper;
return(eventHandler);
}
catch (Exception)
{
log.LogWarning("Could not instantiate " + eventHandlerClass + ", this is most likely a programmatic error");
}
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="activitiEvent"></param>
/// <returns></returns>
public virtual IProcessEngineEvent From(IActivitiEvent activitiEvent)
{
IEventConverter converter = convertersMap[GetPrefix(activitiEvent) + activitiEvent.Type];
IProcessEngineEvent newEvent = null;
if (converter != null)
{
newEvent = converter.From(activitiEvent);
}
else
{
logger.LogDebug(">> Ommited Event Type: " + activitiEvent.GetType().FullName);
}
return(newEvent);
}
/// <returns> true, if the event is an <seealso cref="IActivitiEntityEvent"/> and (if needed) the entityClass set in this instance, is assignable from the entity class in the event. </returns>
protected internal virtual bool IsValidEvent(IActivitiEvent @event)
{
bool valid = false;
if (@event is IActivitiEntityEvent)
{
if (entityClass == null)
{
valid = true;
}
else
{
valid = entityClass.IsAssignableFrom(((IActivitiEntityEvent)@event).Entity.GetType());
}
}
return(valid);
}
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);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="activitiEvent"></param>
/// <returns></returns>
private static bool IsProcessEvent(IActivitiEvent activitiEvent)
{
bool isProcessEvent = false;
if (activitiEvent is IActivitiEntityEvent)
{
object entity = ((IActivitiEntityEvent)activitiEvent).Entity;
if (entity != null && entity.GetType().IsAssignableFrom(typeof(ProcessInstance)))
{
isProcessEvent = !IsExecutionEntityEvent(activitiEvent) || ((IExecutionEntity)entity).ProcessInstanceType;
}
}
else if (activitiEvent.Type == ActivitiEventType.PROCESS_CANCELLED)
{
isProcessEvent = true;
}
return(isProcessEvent);
}
protected internal virtual void DispatchEvent(IActivitiEvent @event, IActivitiEventListener listener)
{
try
{
listener.OnEvent(@event);
}
catch (Exception t)
{
if (listener.FailOnException)
{
throw new ActivitiException("Exception while executing event-listener", t);
}
else
{
// Ignore the exception and continue notifying remaining listeners. The listener
// explicitly states that the exception should not bubble up
log.LogError(t, $"Exception while executing event-listener, which was ignored");
}
}
}
/// <summary>
///
/// </summary>
public override IProcessEngineEvent From(IActivitiEvent @event)
{
var eventObj = (IActivitiSequenceFlowTakenEvent)@event;
return(new SequenceFlowTakenEventImpl(RuntimeBundleProperties.AppName,
RuntimeBundleProperties.AppVersion,
RuntimeBundleProperties.ServiceName,
RuntimeBundleProperties.ServiceFullName,
RuntimeBundleProperties.ServiceType,
RuntimeBundleProperties.ServiceVersion,
@event.ExecutionId,
@event.ProcessDefinitionId,
@event.ProcessInstanceId,
eventObj.Id,
eventObj.SourceActivityId,
eventObj.SourceActivityName,
eventObj.SourceActivityType,
eventObj.TargetActivityId,
eventObj.TargetActivityName,
eventObj.TargetActivityType));
}
// Subclasses can override this if defaults are not ok
protected internal virtual IEventLoggerEventHandler GetEventHandler(IActivitiEvent @event)
{
Type eventHandlerClass = null;
if (@event.Type.Equals(ActivitiEventType.ENTITY_INITIALIZED))
{
object entity = ((IActivitiEntityEvent)@event).Entity;
if (entity is IExecutionEntity executionEntity)
{
if (executionEntity.ProcessInstanceId.Equals(executionEntity.Id))
{
eventHandlerClass = typeof(ProcessInstanceStartedEventHandler);
}
}
}
else if (@event.Type.Equals(ActivitiEventType.ENTITY_DELETED))
{
object entity = ((IActivitiEntityEvent)@event).Entity;
if (entity is IExecutionEntity executionEntity)
{
if (executionEntity.ProcessInstanceId.Equals(executionEntity.Id))
{
eventHandlerClass = typeof(ProcessInstanceEndedEventHandler);
}
}
}
else
{
// Default: dedicated mapper for the type
eventHandlerClass = eventHandlers[@event.Type];
}
if (eventHandlerClass != null)
{
return(InstantiateEventHandler(@event, eventHandlerClass));
}
return(null);
}
protected internal virtual bool IsValidEvent(IActivitiEvent @event)
{
bool valid = false;
if (entityClass != null)
{
if (@event is IActivitiEntityEvent)
{
object entity = ((IActivitiEntityEvent)@event).Entity;
if (entity != null)
{
valid = entityClass.IsAssignableFrom(entity.GetType());
}
}
}
else
{
// If no class is specified, all events are valid
valid = true;
}
return(valid);
}
/// <inheritdoc />
public void OnEvent(IActivitiEvent @event)
{
WorkflowDebuggerEvent evt = @event as WorkflowDebuggerEvent;
ProcessEngineConfigurationImpl processEngineConfiguration = Context.ProcessEngineConfiguration;
if ((processEngineConfiguration?.EnableVerboseExecutionTreeLogging).GetValueOrDefault(false) && evt?.Execution != null)
{
string startUserId = evt.Execution.ProcessInstance.StartUserId;
if (startUserId != null && users.TryGetValue(startUserId, out HashSet <string> clients))
{
foreach (var clientId in clients)
{
this.HubContext.Clients.Client(clientId).SendAsync("loggerReceived", new
{
Date = DateTime.Now,
evt.Execution.ActivityId,
evt.ExecutionTrace,
Error = evt.Exception?.ToString(),
evt.LogLevel
});
}
}
}
}
/// <summary>
///
/// </summary>
public override IProcessEngineEvent From(IActivitiEvent @event)
{
return(new ProcessCancelledEventImpl(RuntimeBundleProperties.AppName, RuntimeBundleProperties.AppVersion, RuntimeBundleProperties.ServiceName, RuntimeBundleProperties.ServiceFullName, RuntimeBundleProperties.ServiceType, RuntimeBundleProperties.ServiceVersion, @event.ExecutionId, @event.ProcessDefinitionId, @event.ProcessInstanceId, ((IActivitiCancelledEvent)@event).Cause.ToString()));
}
public virtual void DispatchEvent(IActivitiEvent @event)
{
commandExecutor.Execute(new DispatchEventCommand(@event));
}
/// <summary>
///
/// </summary>
public override IProcessEngineEvent From(IActivitiEvent @event)
{
var eventObj = (IActivitiEntityEvent)@event;
return(new TaskActivatedEventImpl(RuntimeBundleProperties.AppName, RuntimeBundleProperties.AppVersion, RuntimeBundleProperties.ServiceName, RuntimeBundleProperties.ServiceFullName, RuntimeBundleProperties.ServiceType, RuntimeBundleProperties.ServiceVersion, @event.ExecutionId, @event.ProcessDefinitionId, @event.ProcessInstanceId, taskConverter.From((ITask)eventObj.Entity)));
}
