Example #1
0
        protected internal virtual void RemoveObsoleteTimers(ESS.FW.Bpm.Engine.Persistence.Entity.ProcessDefinitionEntity processDefinition)
        {
            IList <JobEntity> jobsToDelete = JobManager.FindJobsByConfiguration(TimerStartEventJobHandler.TYPE, processDefinition.Key, processDefinition.TenantId);

            foreach (JobEntity job in jobsToDelete)
            {
                (new DeleteJobsCmd(job.Id)).Execute(Context.CommandContext);
            }
        }
Example #2
0
        protected internal virtual void AddEventSubscriptions(ESS.FW.Bpm.Engine.Persistence.Entity.ProcessDefinitionEntity processDefinition)
        {
            IDictionary <string, EventSubscriptionDeclaration> eventDefinitions = processDefinition.Properties.Get(BpmnProperties.EventSubscriptionDeclarations);

            foreach (EventSubscriptionDeclaration eventDefinition in eventDefinitions.Values)
            {
                AddEventSubscription(processDefinition, eventDefinition);
            }
        }
Example #3
0
 protected internal override void HandlePersistedDefinition(ESS.FW.Bpm.Engine.Persistence.Entity.ProcessDefinitionEntity definition, ESS.FW.Bpm.Engine.Persistence.Entity.ProcessDefinitionEntity persistedDefinition, DeploymentEntity deployment, Core.Model.Properties properties)
 {
     //check if persisted definition is not null, since the process definition can be deleted by the user
     //in such cases we don't want to handle them
     //we can't do this in the parent method, since other siblings want to handle them like {@link DecisionDefinitionDeployer}
     if (persistedDefinition != null)
     {
         base.HandlePersistedDefinition(definition, persistedDefinition, deployment, properties);
     }
 }
Example #4
0
        protected internal virtual void AddTimerDeclarations(ESS.FW.Bpm.Engine.Persistence.Entity.ProcessDefinitionEntity processDefinition)
        {
            IList <TimerDeclarationImpl> timerDeclarations = (IList <TimerDeclarationImpl>)processDefinition.GetProperty(BpmnParse.PropertynameStartTimer);

            if (timerDeclarations != null)
            {
                foreach (TimerDeclarationImpl timerDeclaration in timerDeclarations)
                {
                    string deploymentId = processDefinition.DeploymentId;
                    timerDeclaration.CreateStartTimerInstance(deploymentId);
                }
            }
        }
 /// <summary>
 /// Updates all modifiable fields from another process definition entity. </summary>
 /// <param name="updatingProcessDefinition"> </param>
 public virtual void UpdateModifiedFieldsFromEntity(ProcessDefinitionEntity updatingProcessDefinition)
 {
     //TODO
     if ((this.Key == updatingProcessDefinition.Key) && this.DeploymentId == updatingProcessDefinition.DeploymentId)
     {
         // TODO: add a guard once the mismatch between revisions in deployment cache and database has been resolved
         this.Revision        = updatingProcessDefinition.Revision;
         this.SuspensionState = updatingProcessDefinition.SuspensionState;
     }
     else
     {
         Log.LogUpdateUnrelatedProcessDefinitionEntity(this.Key, updatingProcessDefinition.Key, this.DeploymentId, updatingProcessDefinition.DeploymentId);
     }
 }
Example #6
0
        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);
                }
            }
        }
Example #7
0
        public override void ParseConfiguration(Element activityElement, DeploymentEntity deployment,
                                                ESS.FW.Bpm.Engine.Persistence.Entity.ProcessDefinitionEntity processDefinition, BpmnParse bpmnParse)
        {
            base.ParseConfiguration(activityElement, deployment, processDefinition, bpmnParse);

            var expressionManager = context.Impl.Context.ProcessEngineConfiguration.ExpressionManager;

            var formKeyAttribute = activityElement.GetAttributeNS(BpmnParse.CamundaBpmnExtensionsNs,
                                                                  "formKey");

            if (!ReferenceEquals(formKeyAttribute, null))
            {
                formKey = expressionManager.CreateExpression(formKeyAttribute);
            }

            if (formKey != null)
            {
                processDefinition.StartFormKey = true;
            }
        }
Example #8
0
        protected internal virtual void RemoveObsoleteEventSubscriptions(ESS.FW.Bpm.Engine.Persistence.Entity.ProcessDefinitionEntity processDefinition, ESS.FW.Bpm.Engine.Persistence.Entity.ProcessDefinitionEntity latestProcessDefinition)
        {
            // remove all subscriptions for the previous version
            if (latestProcessDefinition != null)
            {
                IEventSubscriptionManager eventSubscriptionManager = EventSubscriptionManager;

                IList <EventSubscriptionEntity> subscriptionsToDelete = new List <EventSubscriptionEntity>();

                IList <EventSubscriptionEntity> messageEventSubscriptions = eventSubscriptionManager.FindEventSubscriptionsByConfiguration(EventType.Message.Name, latestProcessDefinition.Id);
                ((List <EventSubscriptionEntity>)subscriptionsToDelete).AddRange(messageEventSubscriptions);

                IList <EventSubscriptionEntity> signalEventSubscriptions = eventSubscriptionManager.FindEventSubscriptionsByConfiguration(EventType.Signal.Name, latestProcessDefinition.Id);
                ((List <EventSubscriptionEntity>)subscriptionsToDelete).AddRange(signalEventSubscriptions);

                foreach (EventSubscriptionEntity eventSubscriptionEntity in subscriptionsToDelete)
                {
                    eventSubscriptionEntity.Delete();
                }
            }
        }
        /// <summary>
        /// Returns the cached version if exists; does not update the entity from the database in that case
        /// </summary>
        protected internal virtual ProcessDefinitionEntity LoadProcessDefinition(string processDefinitionId)
        {
            ProcessEngineConfigurationImpl configuration = Context.ProcessEngineConfiguration;
            DeploymentCache deploymentCache = configuration.DeploymentCache;

            ProcessDefinitionEntity processDefinition = deploymentCache.FindProcessDefinitionFromCache(processDefinitionId);

            if (processDefinition == null)
            {
                CommandContext           commandContext           = Context.CommandContext;
                ProcessDefinitionManager processDefinitionManager = commandContext.ProcessDefinitionManager as ProcessDefinitionManager;
                processDefinition = processDefinitionManager.FindLatestProcessDefinitionById(processDefinitionId);

                if (processDefinition != null)
                {
                    processDefinition = deploymentCache.ResolveProcessDefinition(processDefinition);
                }
            }

            return(processDefinition);
        }
Example #10
0
        public static ExternalTaskEntity CreateAndInsert(ExecutionEntity execution, string topic, long priority)
        {
            ExternalTaskEntity externalTask = new ExternalTaskEntity();

            externalTask.TopicName           = topic;
            externalTask.ExecutionId         = execution.Id;
            externalTask.ProcessInstanceId   = execution.ProcessInstanceId;
            externalTask.ProcessDefinitionId = execution.ProcessDefinitionId;
            externalTask.ActivityId          = execution.ActivityId;
            externalTask.ActivityInstanceId  = execution.ActivityInstanceId;
            externalTask.TenantId            = execution.TenantId;
            externalTask.Priority            = priority;

            ProcessDefinitionEntity processDefinition = (ProcessDefinitionEntity)execution.ProcessDefinition;

            externalTask.ProcessDefinitionKey = processDefinition.Key;

            externalTask.Insert();
            externalTask.ProduceHistoricExternalTaskCreatedEvent();

            return(externalTask);
        }
Example #11
0
 protected internal virtual void AddAuthorizations(ESS.FW.Bpm.Engine.Persistence.Entity.ProcessDefinitionEntity processDefinition)
 {
     AddAuthorizationsFromIterator(processDefinition.CandidateStarterUserIdExpressions, processDefinition, ExprType.User);
     AddAuthorizationsFromIterator(processDefinition.CandidateStarterGroupIdExpressions, processDefinition, ExprType.Group);
 }
Example #12
0
 public virtual void AddAuthorizationsFromIterator(ISet <IExpression> exprSet, ESS.FW.Bpm.Engine.Persistence.Entity.ProcessDefinitionEntity processDefinition, ExprType exprType)
 {
     if (exprSet != null)
     {
         foreach (IExpression expr in exprSet)
         {
             IdentityLinkEntity identityLink = new IdentityLinkEntity();
             identityLink.ProcessDef = processDefinition;
             if (exprType.Equals(ExprType.User))
             {
                 identityLink.UserId = expr.ToString();
             }
             else if (exprType.Equals(ExprType.Group))
             {
                 identityLink.GroupId = expr.ToString();
             }
             identityLink.Type = ESS.FW.Bpm.Engine.Task.IdentityLinkType.Candidate;
             identityLink.Insert();
         }
     }
 }
Example #13
0
        /// <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();
        }
Example #14
0
        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();
        }