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