protected internal virtual bool IsSameMessageEventSubscriptionAlreadyPresent(EventSubscriptionDeclaration eventSubscription, string tenantId)
{
// look for subscriptions for the same name in db:
IList <EventSubscriptionEntity> subscriptionsForSameMessageName = EventSubscriptionManager.FindEventSubscriptionsByNameAndTenantId(EventType.Message.Name, eventSubscription.UnresolvedEventName, tenantId);
//TODO 缓存差异
// also look for subscriptions created in the session: 源码有值
IList <EventSubscriptionEntity> cachedSubscriptions = DbEntityCache.GetEntitiesByType <EventSubscriptionEntity>(typeof(EventSubscriptionEntity));
foreach (EventSubscriptionEntity cachedSubscription in cachedSubscriptions)
{
//TODO HasTenantId subscriptions
if (eventSubscription.UnresolvedEventName.Equals(cachedSubscription.EventName) && HasTenantId(cachedSubscription, tenantId) && !subscriptionsForSameMessageName.Contains(cachedSubscription))
{
subscriptionsForSameMessageName.Add(cachedSubscription);
}
}
// remove subscriptions deleted in the same command
//subscriptionsForSameMessageName = DbEntityManager.PruneDeletedEntities(subscriptionsForSameMessageName);
subscriptionsForSameMessageName = Context.CommandContext.PruneDeletedEntities <EventSubscriptionEntity>(subscriptionsForSameMessageName);
// remove subscriptions for different type of event (i.e. remove intermediate message event subscriptions)
subscriptionsForSameMessageName = FilterSubscriptionsOfDifferentType(eventSubscription, subscriptionsForSameMessageName);
return(subscriptionsForSameMessageName.Count > 0);
}
protected internal virtual IDictionary <string, EventSubscriptionDeclaration> GetDeclarationsByTriggeringActivity
(ScopeImpl eventScope)
{
var declarations = EventSubscriptionDeclaration.GetDeclarationsForScope(eventScope);
return(new Dictionary <string, EventSubscriptionDeclaration>(declarations));
}
public MigratingEventSubscriptionInstance(EventSubscriptionEntity eventSubscriptionEntity, ScopeImpl targetScope,
bool updateEvent, EventSubscriptionDeclaration targetDeclaration)
{
this.EventSubscriptionEntity = eventSubscriptionEntity;
this.TargetScope = targetScope;
this.UpdateEvent = updateEvent;
this.TargetDeclaration = targetDeclaration;
}
public static bool DefinesPersistentEventTrigger(IPvmScope activity)
{
var eventScope = (ScopeImpl)activity.EventScope;
if (eventScope != null)
{
return(TimerDeclarationImpl.GetDeclarationsForScope(eventScope).ContainsKey(activity.Id) ||
EventSubscriptionDeclaration.GetDeclarationsForScope(eventScope).ContainsKey(activity.Id));
}
return(false);
}
protected internal virtual string findStartActivityIdByMessage(ProcessDefinitionEntity processDefinition, string messageName)
{
foreach (EventSubscriptionDeclaration declaration in EventSubscriptionDeclaration.getDeclarationsForScope(processDefinition).Values)
{
if (isMessageStartEventWithName(declaration, messageName))
{
return(declaration.ActivityId);
}
}
return(null);
}
protected internal virtual void AddMessageStartEventSubscription(EventSubscriptionDeclaration messageEventDefinition, ESS.FW.Bpm.Engine.Persistence.Entity.ProcessDefinitionEntity processDefinition)
{
string tenantId = processDefinition.TenantId;
if (IsSameMessageEventSubscriptionAlreadyPresent(messageEventDefinition, tenantId))
{
throw Log.MessageEventSubscriptionWithSameNameExists(processDefinition.ResourceName, messageEventDefinition.UnresolvedEventName);
}
EventSubscriptionEntity newSubscription = messageEventDefinition.CreateSubscriptionForStartEvent(processDefinition);
newSubscription.Insert();
}
protected internal virtual void addEmergingEventSubscriptions(MigratingActivityInstance owningInstance, IDictionary <string, EventSubscriptionDeclaration> targetDeclarations)
{
foreach (string key in targetDeclarations.Keys)
{
// the event subscription will be created
EventSubscriptionDeclaration declaration = targetDeclarations[key];
if (!declaration.StartEvent)
{
owningInstance.addEmergingDependentInstance(new MigratingEventSubscriptionInstance(declaration));
}
}
}
public virtual void handle(MigratingInstanceParseContext parseContext, MigratingActivityInstance owningInstance, IList <EventSubscriptionEntity> elements)
{
IDictionary <string, EventSubscriptionDeclaration> targetDeclarations = getDeclarationsByTriggeringActivity(owningInstance.TargetScope);
foreach (EventSubscriptionEntity eventSubscription in elements)
{
if (!SupportedEventTypes.Contains(eventSubscription.EventType))
{
// ignore unsupported event subscriptions
continue;
}
MigrationInstruction migrationInstruction = parseContext.findSingleMigrationInstruction(eventSubscription.ActivityId);
ActivityImpl targetActivity = parseContext.getTargetActivity(migrationInstruction);
if (targetActivity != null && owningInstance.migratesTo(targetActivity.EventScope))
{
// the event subscription is migrated
EventSubscriptionDeclaration targetDeclaration = targetDeclarations.Remove(targetActivity.Id);
owningInstance.addMigratingDependentInstance(new MigratingEventSubscriptionInstance(eventSubscription, targetActivity, migrationInstruction.UpdateEventTrigger, targetDeclaration));
}
else
{
// the event subscription will be removed
owningInstance.addRemovingDependentInstance(new MigratingEventSubscriptionInstance(eventSubscription));
}
parseContext.consume(eventSubscription);
}
if (owningInstance.migrates())
{
addEmergingEventSubscriptions(owningInstance, targetDeclarations);
}
}
public EventSubscriptionJobDeclaration(EventSubscriptionDeclaration eventSubscriptionDeclaration)
: base(ProcessEventJobHandler.TYPE)
{
EnsureUtil.EnsureNotNull("eventSubscriptionDeclaration", eventSubscriptionDeclaration);
this.EventSubscriptionDeclaration = eventSubscriptionDeclaration;
}
public ThrowSignalEventActivityBehavior(EventSubscriptionDeclaration signalDefinition)
{
this.SignalDefinition = signalDefinition;
}
protected internal virtual bool isConditionStartEvent(EventSubscriptionDeclaration declaration)
{
return(EventType.CONDITONAL.name().Equals(declaration.EventType) && declaration.StartEvent);
}
/// <summary>
/// EventSubscriptionEntity
/// </summary>
/// <param name="signalEventDefinition"></param>
/// <param name="processDefinition"></param>
protected internal virtual void AddSignalStartEventSubscription(EventSubscriptionDeclaration signalEventDefinition, ESS.FW.Bpm.Engine.Persistence.Entity.ProcessDefinitionEntity processDefinition)
{
EventSubscriptionEntity newSubscription = signalEventDefinition.CreateSubscriptionForStartEvent(processDefinition);
newSubscription.Insert();
}
protected internal virtual bool IsSubscriptionOfDifferentTypeAsDeclaration(EventSubscriptionEntity subscriptionEntity, EventSubscriptionDeclaration declaration)
{
return((declaration.StartEvent && IsSubscriptionForIntermediateEvent(subscriptionEntity)) || (!declaration.StartEvent && IsSubscriptionForStartEvent(subscriptionEntity)));
}
/// <summary>
/// It is possible to deploy a process containing a start and intermediate
/// message event that wait for the same message or to have two processes, one
/// with a message start event and the other one with a message intermediate
/// event, that subscribe for the same message. Therefore we have to find out
/// if there are subscriptions for the other type of event and remove those.
/// </summary>
/// <param name="eventSubscription"> </param>
/// <param name="subscriptionsForSameMessageName"> </param>
protected internal virtual IList <EventSubscriptionEntity> FilterSubscriptionsOfDifferentType(EventSubscriptionDeclaration eventSubscription, IList <EventSubscriptionEntity> subscriptionsForSameMessageName)
{
List <EventSubscriptionEntity> filteredSubscriptions = new List <EventSubscriptionEntity>(subscriptionsForSameMessageName);
foreach (EventSubscriptionEntity subscriptionEntity in new List <EventSubscriptionEntity>(subscriptionsForSameMessageName))
{
if (IsSubscriptionOfDifferentTypeAsDeclaration(subscriptionEntity, eventSubscription))
{
filteredSubscriptions.Remove(subscriptionEntity);
}
}
return(filteredSubscriptions);
}
public MigratingEventSubscriptionInstance(EventSubscriptionDeclaration eventSubscriptionDeclaration)
{
this.EventSubscriptionDeclaration = eventSubscriptionDeclaration;
}
protected internal virtual bool IsMessageStartEventWithName(EventSubscriptionDeclaration declaration,
string messageName)
{
return(EventType.Message.Name.Equals(declaration.EventType) && declaration.StartEvent &&
messageName.Equals(declaration.UnresolvedEventName));
}
protected internal virtual void AddEventSubscription(ESS.FW.Bpm.Engine.Persistence.Entity.ProcessDefinitionEntity processDefinition, EventSubscriptionDeclaration eventDefinition)
{
if (eventDefinition.StartEvent)
{
string eventType = eventDefinition.EventType;
if (eventType == EventType.Message.Name)
{
AddMessageStartEventSubscription(eventDefinition, processDefinition);
}
else if (eventType == EventType.Signal.Name)
{
AddSignalStartEventSubscription(eventDefinition, processDefinition);
}
}
}
