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