public virtual void CheckReadProcessInstance(ExecutionEntity execution)
{
var processDefinition = (ProcessDefinitionEntity)execution.GetProcessDefinition();
// necessary permissions:
// - READ on PROCESS_INSTANCE
var firstCheck = new PermissionCheck();
firstCheck.Permission = Permissions.Read;
firstCheck.Resource = Resources.ProcessInstance;
firstCheck.ResourceId = execution.ProcessInstanceId;
// ... OR ...
// - READ_INSTANCE on PROCESS_DEFINITION
var secondCheck = new PermissionCheck();
secondCheck.Permission = Permissions.ReadInstance;
secondCheck.Resource = Resources.ProcessDefinition;
secondCheck.ResourceId = processDefinition.Key;
secondCheck.AuthorizationNotFoundReturnValue = 0L;
AuthorizationManager.CheckAuthorization(firstCheck, secondCheck);
}
// form Properties ///////////////////////////
public virtual HistoryEvent CreateFormPropertyUpdateEvt(ExecutionEntity execution, string propertyId, string propertyValue, string taskId)
{
IDGenerator idGenerator = Context.ProcessEngineConfiguration.IdGenerator;
HistoricFormPropertyEventEntity historicFormPropertyEntity = NewHistoricFormPropertyEvent();
historicFormPropertyEntity.Id = idGenerator.NewGuid();//.NextId;
historicFormPropertyEntity.EventType = HistoryEventTypes.FormPropertyUpdate.EventName;
historicFormPropertyEntity.TimeStamp = ClockUtil.CurrentTime;
historicFormPropertyEntity.ActivityInstanceId = execution.ActivityInstanceId;
historicFormPropertyEntity.ExecutionId = execution.Id;
historicFormPropertyEntity.ProcessDefinitionId = execution.ProcessDefinitionId;
historicFormPropertyEntity.ProcessInstanceId = execution.ProcessInstanceId;
historicFormPropertyEntity.PropertyId = propertyId;
historicFormPropertyEntity.PropertyValue = propertyValue;
historicFormPropertyEntity.TaskId = taskId;
historicFormPropertyEntity.TenantId = execution.TenantId;
ProcessDefinitionEntity definition = execution.GetProcessDefinition();
if (definition != null)
{
historicFormPropertyEntity.ProcessDefinitionKey = definition.Key;
}
// initialize sequence counter
InitSequenceCounter(execution, historicFormPropertyEntity);
return(historicFormPropertyEntity);
}
public MigratingInstanceParseContext(MigratingInstanceParser parser, IMigrationPlan migrationPlan,
ExecutionEntity processInstance, ProcessDefinitionEntity targetProcessDefinition)
{
this.Parser = parser;
sourceProcessDefinition = processInstance.GetProcessDefinition();//.ProcessDefinition;
this.targetProcessDefinition = targetProcessDefinition;
migratingProcessInstance = new MigratingProcessInstance(processInstance.Id, sourceProcessDefinition,
targetProcessDefinition);
mapping = new ActivityExecutionTreeMapping(context.Impl.Context.CommandContext, processInstance.Id);
InstructionsBySourceScope = OrganizeInstructionsBySourceScope(migrationPlan);
}
protected internal virtual void InitHistoricVariableUpdateEvt(HistoricVariableUpdateEventEntity evt, VariableInstanceEntity variableInstance, IHistoryEventType eventType)
{
// init properties
evt.EventType = eventType.EventName;
evt.TimeStamp = ClockUtil.CurrentTime;
evt.VariableInstanceId = variableInstance.Id;
evt.ProcessInstanceId = variableInstance.ProcessInstanceId;
evt.ExecutionId = variableInstance.ExecutionId;
evt.CaseInstanceId = variableInstance.CaseInstanceId;
evt.CaseExecutionId = variableInstance.CaseExecutionId;
evt.TaskId = variableInstance.TaskId;
evt.Revision = variableInstance.Revision;
evt.VariableName = variableInstance.Name;
evt.SerializerName = variableInstance.SerializerName;
evt.TenantId = variableInstance.TenantId;
ExecutionEntity execution = variableInstance.Execution;
if (execution != null)
{
ProcessDefinitionEntity definition = execution.GetProcessDefinition();
if (definition != null)
{
evt.ProcessDefinitionId = definition.Id;
evt.ProcessDefinitionKey = definition.Key;
}
}
//CaseExecutionEntity caseExecution = variableInstance.CaseExecution;
//if (caseExecution != null)
//{
// CaseDefinitionEntity definition = (CaseDefinitionEntity)caseExecution.CaseDefinition;
// if (definition != null)
// {
// evt.CaseDefinitionId = definition.Id;
// evt.CaseDefinitionKey = definition.Key;
// }
//}
// copy value
evt.TextValue = variableInstance.TextValue;
evt.TextValue2 = variableInstance.TextValue2;
evt.DoubleValue = variableInstance.DoubleValue;
evt.LongValue = variableInstance.LongValue;
if (variableInstance.ByteArrayId != null)
{
evt.ByteValue = variableInstance.ByteArrayValue;
//evt.Value = variableInstance.Value;
//evt.ByteArrayValue = variableInstance.ByteArrayValue;
var r = evt.Value;
}
}
protected internal virtual void Initialize()
{
ExecutionEntity processInstance = CommandContext.ExecutionManager.FindExecutionById(ProcessInstanceId);
this.ProcessDefinition = processInstance.GetProcessDefinition();
IList <IActivityExecution> executions = FetchExecutionsForProcessInstance(processInstance);
executions.Add(processInstance);
IList <IActivityExecution> leaves = FindLeaves(executions);
AssignExecutionsToActivities(leaves);
}
public virtual void CheckUpdateTask(TaskEntity task)
{
var taskId = task.Id;
var executionId = task.ExecutionId;
if (!ReferenceEquals(executionId, null))
{
// if ITask exists in context of a process instance
// then check the following permissions:
// - UPDATE on ITask
// - UPDATE_TASK on PROCESS_DEFINITION
ExecutionEntity execution = task.GetExecution();
var processDefinition = (ProcessDefinitionEntity)execution.GetProcessDefinition();
var updatePermissionCheck = new PermissionCheck();
updatePermissionCheck.Permission = Permissions.Update;
updatePermissionCheck.Resource = Resources.Task;
updatePermissionCheck.ResourceId = taskId;
var updateTaskPermissionCheck = new PermissionCheck();
updateTaskPermissionCheck.Permission = Permissions.UpdateTask;
updateTaskPermissionCheck.Resource = Resources.ProcessDefinition;
updateTaskPermissionCheck.ResourceId = processDefinition.Key;
updateTaskPermissionCheck.AuthorizationNotFoundReturnValue = 0L;
AuthorizationManager.CheckAuthorization(updatePermissionCheck, updateTaskPermissionCheck);
}
else
{
// if ITask does not exist in context of process
// instance, then it is either a (a) standalone ITask
// or (b) it exists in context of a case instance.
// (a) standalone ITask: check following permission
// - READ on ITask
// (b) ITask in context of a case instance, in this
// case it is not necessary to check any permission,
// because such tasks can always be updated
var caseExecutionId = task.CaseExecutionId;
if (ReferenceEquals(caseExecutionId, null))
{
// standalone ITask
AuthorizationManager.CheckAuthorization(Permissions.Update, Resources.Task, taskId);
}
}
}
/// <summary>
/// Creates and inserts a subscription entity depending on the message type of this declaration.
/// </summary>
public virtual EventSubscriptionEntity CreateSubscriptionForExecution(ExecutionEntity execution)
{
var eventSubscriptionEntity = new EventSubscriptionEntity(execution, eventType);
eventSubscriptionEntity.EventName = ResolveExpressionOfEventName(execution);
if (activityId != null)
{
ActivityImpl activity = execution.GetProcessDefinition().FindActivity(activityId) as ActivityImpl;
eventSubscriptionEntity.Activity = activity;
}
eventSubscriptionEntity.Insert();
LegacyBehavior.RemoveLegacySubscriptionOnParent(execution, eventSubscriptionEntity);
return(eventSubscriptionEntity);
//return null;
}
public static IProcessApplicationReference GetTargetProcessApplication(ExecutionEntity execution)
{
if (execution == null)
{
return(null);
}
IProcessApplicationReference processApplicationForDeployment =
GetTargetProcessApplication(execution.GetProcessDefinition());
//logg application context switch details
if (Log.ContextSwitchLoggable && processApplicationForDeployment == null)
{
//打印 ENGINE-07023 no target process application found for...
LoggContextSwitchDetails(execution);
}
return(processApplicationForDeployment);
}
protected internal virtual void InitActivityInstanceEvent(HistoricActivityInstanceEventEntity evt, ExecutionEntity execution, IPvmScope eventSource, string activityInstanceId, string parentActivityInstanceId, IHistoryEventType eventType)
{
evt.Id = activityInstanceId;
evt.EventType = eventType.EventName;
evt.ActivityInstanceId = activityInstanceId;
evt.ParentActivityInstanceId = parentActivityInstanceId;
evt.ProcessDefinitionId = execution.ProcessDefinitionId;
evt.ProcessInstanceId = execution.ProcessInstanceId;
evt.ExecutionId = execution.Id;
evt.TenantId = execution.TenantId;
ProcessDefinitionEntity definition = execution.GetProcessDefinition();
if (definition != null)
{
evt.ProcessDefinitionKey = definition.Key;
}
evt.ActivityId = eventSource.Id;
evt.ActivityName = (string)eventSource.GetProperty("name");
evt.ActivityType = (string)eventSource.GetProperty("type");
// update sub process reference
ExecutionEntity subProcessInstance = execution.GetSubProcessInstance();
if (subProcessInstance != null)
{
evt.CalledProcessInstanceId = subProcessInstance.Id;
}
// update sub case reference
//CaseExecutionEntity subCaseInstance = execution.GetSubCaseInstance();
//if (subCaseInstance != null)
//{
// evt.CalledCaseInstanceId = subCaseInstance.Id;
//}
}
protected internal virtual void InitProcessInstanceEvent(HistoricProcessInstanceEventEntity evt, ExecutionEntity execution, IHistoryEventType eventType)
{
string processDefinitionId = execution.ProcessDefinitionId;
string processInstanceId = execution.ProcessInstanceId;
string executionId = execution.Id;
// the given execution is the process instance!
string caseInstanceId = execution.CaseInstanceId;
string tenantId = execution.TenantId;
ProcessDefinitionEntity definition = execution.GetProcessDefinition();
string processDefinitionKey = null;
if (definition != null)
{
processDefinitionKey = definition.Key;
}
evt.Id = processInstanceId;
evt.EventType = eventType.EventName;
evt.ProcessDefinitionKey = processDefinitionKey;
evt.ProcessDefinitionId = processDefinitionId;
evt.ProcessInstanceId = processInstanceId;
evt.ExecutionId = executionId;
evt.BusinessKey = execution.ProcessBusinessKey;
evt.CaseInstanceId = caseInstanceId;
evt.TenantId = tenantId;
//if (execution.GetSuperCaseExecution() != null)
//{
// evt.SuperCaseInstanceId = execution.GetSuperCaseExecution().CaseInstanceId;
//}
if (execution.SuperExecution != null)
{
evt.SuperProcessInstanceId = execution.SuperExecution.ProcessInstanceId;
}
}
public override void Execute(IJobHandlerConfiguration _configuration, ExecutionEntity execution,
CommandContext commandContext, string tenantId)
{
TimerJobConfiguration configuration = _configuration as TimerJobConfiguration;
var activityId = configuration.TimerElementKey;
ActivityImpl intermediateEventActivity = execution.GetProcessDefinition().FindActivity(activityId) as ActivityImpl;
EnsureUtil.EnsureNotNull(
"Error while firing timer: intermediate event activity " + configuration + " not found",
"intermediateEventActivity", intermediateEventActivity);
try
{
if (activityId.Equals(execution.ActivityId))
{
// Regular Intermediate timer catch
execution.Signal("signal", null);
}
}
catch (System.Exception e)
{
throw new ProcessEngineException("exception during timer execution: " + e.Message, e);
}
}
public override void Execute(IJobHandlerConfiguration _configuration, ExecutionEntity execution,
CommandContext commandContext, string tenantId)
{
TimerJobConfiguration configuration = _configuration as TimerJobConfiguration;
var activityId = configuration.TimerElementKey;
ActivityImpl activity = execution.GetProcessDefinition().FindActivity(activityId) as ActivityImpl;
EnsureUtil.EnsureNotNull(
"Error while firing timer: boundary event activity " + configuration + " not found",
"boundary event activity", activity);
try
{
execution.ExecuteEventHandlerActivity(activity);
}
//catch (Exception e)
//{
// throw e;
//}
catch (System.Exception e)
{
throw new ProcessEngineException("exception during timer execution: " + e.Message, e);
}
}
public override object Execute(CommandContext commandContext)
{
ExecutionEntity processInstance = commandContext.ExecutionManager.FindExecutionById(processInstanceId);
ProcessDefinitionImpl processDefinition = processInstance.GetProcessDefinition();
CoreModelElement elementToInstantiate = GetTargetElement(processDefinition);
EnsureUtil.EnsureNotNull(typeof(NotValidException), DescribeFailure("Element '" + TargetElementId + "' does not exist in process '" + processDefinition.Id + "'"), "element", elementToInstantiate);
// rebuild the mapping because the execution tree changes with every iteration
var mapping = new ActivityExecutionTreeMapping(commandContext, processInstanceId);
// before instantiating an activity, two things have to be determined:
//
// activityStack:
// For the activity to instantiate, we build a stack of parent flow scopes
// for which no executions exist yet and that have to be instantiated
//
// scopeExecution:
// This is typically the execution under which a new sub tree has to be created.
// if an explicit ancestor activity instance is set:
// - this is the scope execution for that ancestor activity instance
// - throws exception if that scope execution is not in the parent hierarchy
// of the activity to be started
// if no explicit ancestor activity instance is set:
// - this is the execution of the first parent/ancestor flow scope that has an execution
// - throws an exception if there is more than one such execution
var targetFlowScope = GetTargetFlowScope(processDefinition);
// prepare to walk up the flow scope hierarchy and collect the flow scope activities
var stackCollector = new ActivityStackCollector();
var walker = new FlowScopeWalker(targetFlowScope);
walker.AddPreVisitor(stackCollector);
ExecutionEntity scopeExecution = null;
// if no explicit ancestor activity instance is set
if (ReferenceEquals(AncestorActivityInstanceId, null))
{
// walk until a scope is reached for which executions exist
walker.WalkWhile((element) => mapping.GetExecutions(element)
.Count > 0 || element == processDefinition);
var flowScopeExecutions = mapping.GetExecutions(walker.CurrentElement);
if (flowScopeExecutions.Count > 1)
{
throw new ProcessEngineException("Ancestor activity execution is ambiguous for activity " +
targetFlowScope);
}
//scopeExecution = flowScopeExecutions.GetEnumerator().Next();
scopeExecution = flowScopeExecutions.First();
}
var activitiesToInstantiate = stackCollector.ActivityStack;
activitiesToInstantiate.Reverse();
// We have to make a distinction between
// - "regular" activities for which the activity stack can be instantiated and started
// right away
// - interrupting or cancelling activities for which we have to ensure that
// the interruption and cancellation takes place before we instantiate the activity stack
ActivityImpl topMostActivity = null;
ScopeImpl flowScope = null;
if (activitiesToInstantiate.Count > 0)
{
topMostActivity = (ActivityImpl)activitiesToInstantiate[0];
flowScope = topMostActivity.FlowScope;
}
else if (elementToInstantiate is ActivityImpl)
{
topMostActivity = (ActivityImpl)elementToInstantiate;
flowScope = topMostActivity.FlowScope;
}
else if (elementToInstantiate is TransitionImpl)
{
var transitionToInstantiate = (TransitionImpl)elementToInstantiate;
flowScope = transitionToInstantiate.Source.FlowScope;
}
if (!SupportsConcurrentChildInstantiation(flowScope))
{
throw new ProcessEngineException("Concurrent instantiation not possible for " + "activities in scope " +
flowScope.Id);
}
var startBehavior = ActivityStartBehavior.ConcurrentInFlowScope;
if (topMostActivity != null)
{
startBehavior = topMostActivity.ActivityStartBehavior;
if (activitiesToInstantiate.Count > 0)
{
// this is in BPMN relevant if there is an interrupting event sub process.
// we have to distinguish between instantiation of the start event and any other activity.
// instantiation of the start event means interrupting behavior; instantiation
// of any other ITask means no interruption.
IPvmActivity initialActivity = topMostActivity.Properties.Get(BpmnProperties.InitialActivity);
IPvmActivity secondTopMostActivity = null;
if (activitiesToInstantiate.Count > 1)
{
secondTopMostActivity = activitiesToInstantiate[1];
}
else if (elementToInstantiate.GetType().IsSubclassOf(typeof(ActivityImpl)))
{
secondTopMostActivity = (IPvmActivity)elementToInstantiate;
}
if (initialActivity != secondTopMostActivity)
{
startBehavior = ActivityStartBehavior.ConcurrentInFlowScope;
}
}
}
//throw new Exception("startBehavior值："+(int)startBehavior);//2
switch (startBehavior)
{
case ActivityStartBehavior.CancelEventScope:
{
ScopeImpl scopeToCancel = (ScopeImpl)topMostActivity.EventScope;
var executionToCancel = GetSingleExecutionForScope(mapping, scopeToCancel);
if (executionToCancel != null)
{
executionToCancel.DeleteCascade("Cancelling activity " + topMostActivity + " executed.",
skipCustomListeners, skipIoMappings);
Instantiate(executionToCancel.Parent, activitiesToInstantiate, elementToInstantiate);
}
else
{
var flowScopeExecution = GetSingleExecutionForScope(mapping, topMostActivity.FlowScope);
InstantiateConcurrent(flowScopeExecution, activitiesToInstantiate, elementToInstantiate);
}
break;
}
case ActivityStartBehavior.InterruptEventScope:
{
ScopeImpl scopeToCancel = (ScopeImpl)topMostActivity.EventScope;
var executionToCancel = GetSingleExecutionForScope(mapping, scopeToCancel);
executionToCancel.Interrupt("Interrupting activity " + topMostActivity + " executed.",
skipCustomListeners, skipIoMappings);
executionToCancel.SetActivity(null);
executionToCancel.LeaveActivityInstance();
Instantiate(executionToCancel, activitiesToInstantiate, elementToInstantiate);
break;
}
case ActivityStartBehavior.InterruptFlowScope:
{
var scopeToCancel = topMostActivity.FlowScope;
var executionToCancel = GetSingleExecutionForScope(mapping, scopeToCancel);
executionToCancel.Interrupt("Interrupting activity " + topMostActivity + " executed.",
skipCustomListeners, skipIoMappings);
executionToCancel.SetActivity(null);
executionToCancel.LeaveActivityInstance();
Instantiate(executionToCancel, activitiesToInstantiate, elementToInstantiate);
break;
}
default:
{
// if all child executions have been cancelled
// or this execution has ended executing its scope, it can be reused
if (!scopeExecution.HasChildren() && (scopeExecution.GetActivity() == null || scopeExecution.IsEnded))
{
// reuse the scope execution
Instantiate(scopeExecution, activitiesToInstantiate, elementToInstantiate);
}
else
{
// if the activity is not cancelling/interrupting, it can simply be instantiated as
// a concurrent child of the scopeExecution
InstantiateConcurrent(scopeExecution, activitiesToInstantiate, elementToInstantiate);
}
break;
}
}
return(null);
}
protected internal override long?GetProcessDefinitionPriority(ExecutionEntity execution,
ExternalTaskActivityBehavior param)
{
return(GetProcessDefinedPriority(execution.GetProcessDefinition(), BpmnParse.PropertynameTaskPriority, execution, ""));
}
protected internal virtual string GetProcessDefinitionTenantId(ExecutionEntity execution)
{
var processDefinition = execution.GetProcessDefinition();
return(processDefinition.TenantId);
}