public virtual void LogProcessInstanceOperation(string operation, string processInstanceId, string processDefinitionId, string processDefinitionKey, IList <PropertyChange> propertyChanges)
{
if (UserOperationLogEnabled)
{
UserOperationLogContext context = new UserOperationLogContext();
UserOperationLogContextEntryBuilder entryBuilder = UserOperationLogContextEntryBuilder.Entry(operation, EntityTypes.ProcessInstance).PropertyChanges(propertyChanges).ProcessInstanceId(processInstanceId).ProcessDefinitionId(processDefinitionId).ProcessDefinitionKey(processDefinitionKey);
if (processInstanceId != null)
{
ExecutionEntity instance = processInstanceManager.FindExecutionById(processInstanceId);
if (instance != null)
{
entryBuilder.InContextOf(instance);
}
}
else if (processDefinitionId != null)
{
ProcessDefinitionEntity definition = processDefinitionManager.FindLatestProcessDefinitionById(processDefinitionId);
if (definition != null)
{
entryBuilder.InContextOf(definition);
}
}
context.AddEntry(entryBuilder.Create());
FireUserOperationLog(context);
}
}
public virtual ProcessInstanceWithVariables execute(CommandContext commandContext)
{
ProcessDefinitionEntity processDefinition = (new GetDeployedProcessDefinitionCmd(instantiationBuilder, false)).execute(commandContext);
foreach (CommandChecker checker in commandContext.ProcessEngineConfiguration.CommandCheckers)
{
checker.checkCreateProcessInstance(processDefinition);
}
ProcessInstanceModificationBuilderImpl modificationBuilder = instantiationBuilder.ModificationBuilder;
ensureNotEmpty("At least one instantiation instruction required (e.g. by invoking startBefore(..), startAfter(..) or startTransition(..))", "instructions", modificationBuilder.ModificationOperations);
// instantiate the process
ActivityImpl initialActivity = determineFirstActivity(processDefinition, modificationBuilder);
ExecutionEntity processInstance = processDefinition.createProcessInstance(instantiationBuilder.BusinessKey, instantiationBuilder.CaseInstanceId, initialActivity);
if (!string.ReferenceEquals(instantiationBuilder.TenantId, null))
{
processInstance.TenantId = instantiationBuilder.TenantId;
}
processInstance.SkipCustomListeners = modificationBuilder.SkipCustomListeners;
VariableMap variables = modificationBuilder.ProcessVariables;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.impl.persistence.entity.ExecutionVariableSnapshotObserver variablesListener = new org.camunda.bpm.engine.impl.persistence.entity.ExecutionVariableSnapshotObserver(processInstance);
ExecutionVariableSnapshotObserver variablesListener = new ExecutionVariableSnapshotObserver(processInstance);
processInstance.startWithoutExecuting(variables);
// prevent ending of the process instance between instructions
processInstance.PreserveScope = true;
// apply modifications
IList <AbstractProcessInstanceModificationCommand> instructions = modificationBuilder.ModificationOperations;
for (int i = 0; i < instructions.Count; i++)
{
AbstractProcessInstanceModificationCommand instruction = instructions[i];
LOG.debugStartingInstruction(processInstance.Id, i, instruction.describe());
instruction.ProcessInstanceId = processInstance.Id;
instruction.SkipCustomListeners = modificationBuilder.SkipCustomListeners;
instruction.SkipIoMappings = modificationBuilder.SkipIoMappings;
instruction.execute(commandContext);
}
if (!processInstance.hasChildren() && processInstance.Ended)
{
// process instance has ended regularly but this has not been propagated yet
// due to preserveScope setting
processInstance.propagateEnd();
}
commandContext.OperationLogManager.logProcessInstanceOperation(org.camunda.bpm.engine.history.UserOperationLogEntry_Fields.OPERATION_TYPE_CREATE, processInstance.Id, processInstance.ProcessDefinitionId, processInstance.getProcessDefinition().Key, Collections.singletonList(PropertyChange.EMPTY_CHANGE));
return(new ProcessInstanceWithVariablesImpl(processInstance, variablesListener.Variables));
}
protected internal virtual BusinessProcessEvent createEvent(DelegateTask task)
{
ExecutionContext executionContext = Context.ExecutionContext;
ProcessDefinitionEntity processDefinition = null;
if (executionContext != null)
{
processDefinition = executionContext.ProcessDefinition;
}
// map type
string eventName = task.EventName;
BusinessProcessEventType type = null;
if ([email protected]_Fields.EVENTNAME_CREATE.Equals(eventName))
{
type = org.camunda.bpm.engine.cdi.BusinessProcessEventType_Fields.CREATE_TASK;
}
else if ([email protected]_Fields.EVENTNAME_ASSIGNMENT.Equals(eventName))
{
type = org.camunda.bpm.engine.cdi.BusinessProcessEventType_Fields.ASSIGN_TASK;
}
else if ([email protected]_Fields.EVENTNAME_COMPLETE.Equals(eventName))
{
type = org.camunda.bpm.engine.cdi.BusinessProcessEventType_Fields.COMPLETE_TASK;
}
else if ([email protected]_Fields.EVENTNAME_DELETE.Equals(eventName))
{
type = org.camunda.bpm.engine.cdi.BusinessProcessEventType_Fields.DELETE_TASK;
}
return(new CdiBusinessProcessEvent(task, processDefinition, type, ClockUtil.CurrentTime));
}
protected internal virtual IList <ConditionHandlerResult> evaluateConditionStartByEventSubscription(CommandContext commandContext, ConditionSet conditionSet)
{
IList <EventSubscriptionEntity> subscriptions = findConditionalStartEventSubscriptions(commandContext, conditionSet);
if (subscriptions.Count == 0)
{
throw LOG.exceptionWhenEvaluatingConditionalStartEvent();
}
IList <ConditionHandlerResult> results = new List <ConditionHandlerResult>();
foreach (EventSubscriptionEntity subscription in subscriptions)
{
ProcessDefinitionEntity processDefinition = subscription.ProcessDefinition;
if (!processDefinition.Suspended)
{
ActivityImpl activity = subscription.Activity;
if (evaluateCondition(conditionSet, activity))
{
results.Add(new ConditionHandlerResult(processDefinition, activity));
}
}
}
return(results);
}
// 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);
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: public Void execute(final org.camunda.bpm.engine.impl.interceptor.CommandContext commandContext)
public override Void execute(CommandContext commandContext)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.migration.MigrationPlan migrationPlan = executionBuilder.getMigrationPlan();
MigrationPlan migrationPlan = executionBuilder.MigrationPlan;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.Collection<String> processInstanceIds = collectProcessInstanceIds(commandContext);
ICollection <string> processInstanceIds = collectProcessInstanceIds(commandContext);
ensureNotNull(typeof(BadUserRequestException), "Migration plan cannot be null", "migration plan", migrationPlan);
ensureNotEmpty(typeof(BadUserRequestException), "Process instance ids cannot empty", "process instance ids", processInstanceIds);
ensureNotContainsNull(typeof(BadUserRequestException), "Process instance ids cannot be null", "process instance ids", processInstanceIds);
ProcessDefinitionEntity sourceDefinition = resolveSourceProcessDefinition(commandContext);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.impl.persistence.entity.ProcessDefinitionEntity targetDefinition = resolveTargetProcessDefinition(commandContext);
ProcessDefinitionEntity targetDefinition = resolveTargetProcessDefinition(commandContext);
checkAuthorizations(commandContext, sourceDefinition, targetDefinition, processInstanceIds);
if (writeOperationLog)
{
writeUserOperationLog(commandContext, sourceDefinition, targetDefinition, processInstanceIds.Count, false);
}
commandContext.runWithoutAuthorization(new CallableAnonymousInnerClass(this, commandContext, migrationPlan, processInstanceIds, targetDefinition));
return(null);
}
public virtual object execute(CommandContext commandContext)
{
ProcessEngineConfigurationImpl processEngineConfiguration = Context.ProcessEngineConfiguration;
DeploymentCache deploymentCache = processEngineConfiguration.DeploymentCache;
ProcessDefinitionEntity processDefinition = deploymentCache.findDeployedProcessDefinitionById(processDefinitionId);
ensureNotNull("Process Definition '" + processDefinitionId + "' not found", "processDefinition", processDefinition);
foreach (CommandChecker checker in commandContext.ProcessEngineConfiguration.CommandCheckers)
{
checker.checkReadProcessDefinition(processDefinition);
}
StartFormHandler startFormHandler = processDefinition.StartFormHandler;
if (startFormHandler == null)
{
return null;
}
FormEngine formEngine = Context.ProcessEngineConfiguration.FormEngines[formEngineName];
ensureNotNull("No formEngine '" + formEngineName + "' defined process engine configuration", "formEngine", formEngine);
StartFormData startForm = startFormHandler.createStartFormData(processDefinition);
object renderedStartForm = null;
try
{
renderedStartForm = formEngine.renderStartForm(startForm);
}
catch (ScriptEvaluationException e)
{
LOG.exceptionWhenStartFormScriptEvaluation(processDefinitionId, e);
}
return renderedStartForm;
}
public override IBatch Execute(CommandContext commandContext)
{
IList <AbstractProcessInstanceModificationCommand> instructions = builder.Instructions;
ICollection <string> processInstanceIds = CollectProcessInstanceIds(commandContext);
EnsureUtil.EnsureNotEmpty(typeof(BadUserRequestException), "Modification instructions cannot be empty", instructions);
EnsureUtil.EnsureNotEmpty(typeof(BadUserRequestException), "Process instance ids cannot be empty", "Process instance ids", processInstanceIds);
EnsureUtil.EnsureNotContainsNull(typeof(BadUserRequestException), "Process instance ids cannot be null", "Process instance ids", processInstanceIds);
commandContext.AuthorizationManager.CheckAuthorization(Permissions.Create, Resources.Batch);
ProcessDefinitionEntity processDefinition = GetProcessDefinition(commandContext, builder.ProcessDefinitionId);
EnsureUtil.EnsureNotNull(typeof(BadUserRequestException), "Process definition id cannot be null", processDefinition);
WriteUserOperationLog(commandContext, processDefinition, processInstanceIds.Count, true);
BatchEntity batch = CreateBatch(commandContext, instructions, processInstanceIds, processDefinition);
batch.CreateSeedJobDefinition();
batch.CreateMonitorJobDefinition();
batch.CreateBatchJobDefinition();
batch.FireHistoricStartEvent();
batch.CreateSeedJob();
return(batch);
}
public override Batch execute(CommandContext commandContext)
{
MigrationPlan migrationPlan = executionBuilder.MigrationPlan;
ICollection <string> processInstanceIds = collectProcessInstanceIds(commandContext);
ensureNotNull(typeof(BadUserRequestException), "Migration plan cannot be null", "migration plan", migrationPlan);
ensureNotEmpty(typeof(BadUserRequestException), "Process instance ids cannot empty", "process instance ids", processInstanceIds);
ensureNotContainsNull(typeof(BadUserRequestException), "Process instance ids cannot be null", "process instance ids", processInstanceIds);
ProcessDefinitionEntity sourceProcessDefinition = resolveSourceProcessDefinition(commandContext);
ProcessDefinitionEntity targetProcessDefinition = resolveTargetProcessDefinition(commandContext);
checkAuthorizations(commandContext, sourceProcessDefinition, targetProcessDefinition, processInstanceIds);
writeUserOperationLog(commandContext, sourceProcessDefinition, targetProcessDefinition, processInstanceIds.Count, true);
BatchEntity batch = createBatch(commandContext, migrationPlan, processInstanceIds, sourceProcessDefinition);
batch.createSeedJobDefinition();
batch.createMonitorJobDefinition();
batch.createBatchJobDefinition();
batch.fireHistoricStartEvent();
batch.createSeedJob();
return(batch);
}
protected internal virtual IDictionary <string, ProcessDefinitionEntity> GetProcessDefinitionsOfSubscriptions(
IList <EventSubscriptionEntity> startSignalEventSubscriptions)
{
DeploymentCache deploymentCache = context.Impl.Context.ProcessEngineConfiguration.DeploymentCache;
IDictionary <string, ProcessDefinitionEntity> processDefinitions =
new Dictionary <string, ProcessDefinitionEntity>();
foreach (var eventSubscription in startSignalEventSubscriptions)
{
var processDefinitionId = eventSubscription.Configuration;
EnsureUtil.EnsureNotNull(
"Configuration of signal start event subscription '" + eventSubscription.Id +
"' contains no process definition id.", processDefinitionId);
ProcessDefinitionEntity processDefinition =
deploymentCache.FindDeployedProcessDefinitionById(processDefinitionId);
if (processDefinition != null && !processDefinition.Suspended)
{
processDefinitions[eventSubscription.Id] = processDefinition;
}
}
return(processDefinitions);
}
public static void InitFormPropertiesOnScope(IVariableMap variables, IActivityExecution execution)
{
ProcessDefinitionEntity pd = (ProcessDefinitionEntity)((PvmExecutionImpl)execution).ProcessDefinition;
IStartFormHandler startFormHandler = pd.StartFormHandler;
startFormHandler.SubmitFormVariables(variables, execution);
}
[Deployment]//表达式解析相关
public virtual void TestParseNamespaceInConditionExpressionType()
{
ICommandExecutor commandExecutor = processEngineConfiguration.CommandExecutorTxRequired;
ProcessDefinitionEntity processDefinitionEntity = commandExecutor.Execute <ProcessDefinitionEntity>(new CommandAnonymousInnerClass2(this));
// Test that the process definition has been deployed
Assert.NotNull(processDefinitionEntity);
IPvmActivity activity = processDefinitionEntity.FindActivity("ExclusiveGateway_1");
Assert.NotNull(activity);
// Test that the conditions has been resolved
foreach (IPvmTransition transition in activity.OutgoingTransitions)
{
if (transition.Destination.Id.Equals("Task_2"))
{
Assert.AreEqual("#{approved}", transition.GetProperty("conditionText"));
//Assert.True(transition.GetProperty("conditionText").Equals("#{approved}"));
}
else if (transition.Destination.Id.Equals("Task_3"))
{
Assert.True(transition.GetProperty("conditionText").Equals("#{!approved}"));
}
else
{
Assert.Fail("Something went wrong");
}
}
}
public virtual ProcessInstanceWithVariables execute(CommandContext commandContext)
{
ProcessDefinitionEntity processDefinition = (new GetDeployedProcessDefinitionCmd(instantiationBuilder, false)).execute(commandContext);
foreach (CommandChecker checker in commandContext.ProcessEngineConfiguration.CommandCheckers)
{
checker.checkCreateProcessInstance(processDefinition);
}
// Start the process instance
ExecutionEntity processInstance = processDefinition.createProcessInstance(instantiationBuilder.BusinessKey, instantiationBuilder.CaseInstanceId);
if (!string.ReferenceEquals(instantiationBuilder.TenantId, null))
{
processInstance.TenantId = instantiationBuilder.TenantId;
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.impl.persistence.entity.ExecutionVariableSnapshotObserver variablesListener = new org.camunda.bpm.engine.impl.persistence.entity.ExecutionVariableSnapshotObserver(processInstance);
ExecutionVariableSnapshotObserver variablesListener = new ExecutionVariableSnapshotObserver(processInstance);
processInstance.start(instantiationBuilder.Variables);
commandContext.OperationLogManager.logProcessInstanceOperation(org.camunda.bpm.engine.history.UserOperationLogEntry_Fields.OPERATION_TYPE_CREATE, processInstance.Id, processInstance.ProcessDefinitionId, processInstance.getProcessDefinition().Key, Collections.singletonList(PropertyChange.EMPTY_CHANGE));
return(new ProcessInstanceWithVariablesImpl(processInstance, variablesListener.Variables));
}
public virtual void LogJobDefinitionOperation(string operation, string jobDefinitionId, string processDefinitionId, string processDefinitionKey, PropertyChange propertyChange)
{
if (UserOperationLogEnabled)
{
UserOperationLogContext context = new UserOperationLogContext();
UserOperationLogContextEntryBuilder entryBuilder = UserOperationLogContextEntryBuilder.Entry(operation, EntityTypes.JobDefinition).JobDefinitionId(jobDefinitionId).ProcessDefinitionId(processDefinitionId).ProcessDefinitionKey(processDefinitionKey).PropertyChanges(propertyChange);
if (jobDefinitionId != null)
{
JobDefinitionEntity jobDefinition = jobDefinitionManager.FindById(jobDefinitionId);
// Backward compatibility
if (jobDefinition != null)
{
entryBuilder.InContextOf(jobDefinition);
}
}
else if (processDefinitionId != null)
{
ProcessDefinitionEntity definition = processDefinitionManager.FindLatestProcessDefinitionById(processDefinitionId);
// Backward compatibility
if (definition != null)
{
entryBuilder.InContextOf(definition);
}
}
context.AddEntry(entryBuilder.Create());
FireUserOperationLog(context);
}
}
public virtual void parseProcess(Element processElement, ProcessDefinitionEntity processDefinition)
{
if (historyLevel.isHistoryEventProduced(HistoryEventTypes.PROCESS_INSTANCE_END, null))
{
processDefinition.addBuiltInListener(PvmEvent.EVENTNAME_END, PROCESS_INSTANCE_END_LISTENER);
}
}
public void CheckCreateProcessInstance(ProcessDefinitionEntity processDefinition)
{
if (!TenantManager.IsAuthenticatedTenant(processDefinition.TenantId))
{
throw Log.ExceptionCommandWithUnauthorizedTenant("create an instance of the process definition '" + processDefinition.Id + "'");
}
}
protected internal virtual IList <CorrelationHandlerResult> CorrelateStartMessageByEventSubscription(
CommandContext commandContext, string messageName, CorrelationSet correlationSet)
{
IList <CorrelationHandlerResult> results = new List <CorrelationHandlerResult>();
DeploymentCache deploymentCache = commandContext.ProcessEngineConfiguration.DeploymentCache;
var messageEventSubscriptions = FindMessageStartEventSubscriptions(commandContext, messageName,
correlationSet);
foreach (var messageEventSubscription in messageEventSubscriptions)
{
if (messageEventSubscription.Configuration != null)
{
var processDefinitionId = messageEventSubscription.Configuration;
ProcessDefinitionEntity processDefinition = deploymentCache.FindDeployedProcessDefinitionById(processDefinitionId);
// only an active process definition will be returned
if (processDefinition != null && !processDefinition.Suspended)
{
CorrelationHandlerResult result = CorrelationHandlerResult.MatchedProcessDefinition(processDefinition, messageEventSubscription.ActivityId);
results.Add(result);
}
else
{
Log.CouldNotFindProcessDefinitionForEventSubscription(messageEventSubscription, processDefinitionId);
}
}
}
return(results);
}
protected internal virtual ISet <ProcessDefinitionGroup> groupByKeyAndTenant(IList <ProcessDefinition> processDefinitions)
{
ISet <ProcessDefinitionGroup> groups = new HashSet <ProcessDefinitionGroup>();
IDictionary <ProcessDefinitionGroup, IList <ProcessDefinitionEntity> > map = new Dictionary <ProcessDefinitionGroup, IList <ProcessDefinitionEntity> >();
foreach (ProcessDefinition current in processDefinitions)
{
ProcessDefinitionEntity processDefinition = (ProcessDefinitionEntity)current;
ProcessDefinitionGroup group = new ProcessDefinitionGroup();
group.key = processDefinition.Key;
group.tenant = processDefinition.TenantId;
IList <ProcessDefinitionEntity> definitions = group.processDefinitions;
if (map.ContainsKey(group))
{
definitions = map[group];
}
else
{
groups.Add(group);
map[group] = definitions;
}
definitions.Add(processDefinition);
}
return(groups);
}
protected internal override void postProcessJob(ModificationBatchConfiguration configuration, JobEntity job)
{
CommandContext commandContext = Context.CommandContext;
ProcessDefinitionEntity processDefinitionEntity = commandContext.ProcessEngineConfiguration.DeploymentCache.findDeployedProcessDefinitionById(configuration.ProcessDefinitionId);
job.DeploymentId = processDefinitionEntity.DeploymentId;
}
public virtual UserOperationLogContextEntryBuilder inContextOf(ExecutionEntity processInstance, IList <PropertyChange> propertyChanges)
{
if (propertyChanges == null || propertyChanges.Count == 0)
{
if (OPERATION_TYPE_CREATE.Equals(entry_Renamed.OperationType))
{
propertyChanges = Arrays.asList(PropertyChange.EMPTY_CHANGE);
}
}
entry_Renamed.PropertyChanges = propertyChanges;
entry_Renamed.RootProcessInstanceId = processInstance.RootProcessInstanceId;
entry_Renamed.ProcessInstanceId = processInstance.ProcessInstanceId;
entry_Renamed.ProcessDefinitionId = processInstance.ProcessDefinitionId;
entry_Renamed.ExecutionId = processInstance.Id;
entry_Renamed.CaseInstanceId = processInstance.CaseInstanceId;
ProcessDefinitionEntity definition = processInstance.getProcessDefinition();
if (definition != null)
{
entry_Renamed.ProcessDefinitionKey = definition.Key;
entry_Renamed.DeploymentId = definition.DeploymentId;
}
return(this);
}
public override Batch execute(CommandContext commandContext)
{
IList <AbstractProcessInstanceModificationCommand> instructions = builder.Instructions;
ICollection <string> processInstanceIds = collectProcessInstanceIds();
ensureNotEmpty(typeof(BadUserRequestException), "Restart instructions cannot be empty", "instructions", instructions);
ensureNotEmpty(typeof(BadUserRequestException), "Process instance ids cannot be empty", "processInstanceIds", processInstanceIds);
ensureNotContainsNull(typeof(BadUserRequestException), "Process instance ids cannot be null", "processInstanceIds", processInstanceIds);
checkPermissions(commandContext);
ProcessDefinitionEntity processDefinition = getProcessDefinition(commandContext, builder.ProcessDefinitionId);
ensureNotNull(typeof(BadUserRequestException), "Process definition cannot be null", processDefinition);
ensureTenantAuthorized(commandContext, processDefinition);
writeUserOperationLog(commandContext, processDefinition, processInstanceIds.Count, true);
List <string> ids = new List <string>();
ids.AddRange(processInstanceIds);
BatchEntity batch = createBatch(commandContext, instructions, ids, processDefinition);
batch.createSeedJobDefinition();
batch.createMonitorJobDefinition();
batch.createBatchJobDefinition();
batch.fireHistoricStartEvent();
batch.createSeedJob();
return(batch);
}
public virtual object Execute(CommandContext commandContext)
{
var processEngineConfiguration = context.Impl.Context.ProcessEngineConfiguration;
DeploymentCache deploymentCache = processEngineConfiguration.DeploymentCache;
ProcessDefinitionEntity processDefinition = deploymentCache.FindDeployedProcessDefinitionById(ProcessDefinitionId);
EnsureUtil.EnsureNotNull("Process Definition '" + ProcessDefinitionId + "' not found", "processDefinition", processDefinition);
foreach (var checker in commandContext.ProcessEngineConfiguration.CommandCheckers)
{
checker.CheckReadProcessDefinition(processDefinition);
}
IStartFormHandler startFormHandler = processDefinition.StartFormHandler;
if (startFormHandler == null)
{
return(null);
}
var formEngine = context.Impl.Context.ProcessEngineConfiguration.FormEngines[FormEngineName];
EnsureUtil.EnsureNotNull("No formEngine '" + FormEngineName + "' defined process engine configuration",
"formEngine", formEngine);
IStartFormData startForm = startFormHandler.CreateStartFormData(processDefinition);
return(formEngine.RenderStartForm(startForm));
}
protected internal virtual void checkGetStartFormVariables(ProcessDefinitionEntity definition, CommandContext commandContext)
{
foreach (CommandChecker checker in commandContext.ProcessEngineConfiguration.CommandCheckers)
{
checker.checkReadProcessDefinition(definition);
}
}
public virtual void checkUpdateProcessInstanceSuspensionState(ExecutionEntity execution)
{
ProcessDefinitionEntity processDefinition = (ProcessDefinitionEntity)execution.getProcessDefinition();
CompositePermissionCheck suspensionStatePermission = (new PermissionCheckBuilder()).disjunctive().atomicCheckForResourceId(PROCESS_INSTANCE, execution.ProcessInstanceId, ProcessInstancePermissions.SUSPEND).atomicCheckForResourceId(PROCESS_DEFINITION, processDefinition.Key, ProcessDefinitionPermissions.SUSPEND_INSTANCE).atomicCheckForResourceId(PROCESS_INSTANCE, execution.ProcessInstanceId, UPDATE).atomicCheckForResourceId(PROCESS_DEFINITION, processDefinition.Key, UPDATE_INSTANCE).build();
AuthorizationManager.checkAuthorization(suspensionStatePermission);
}
protected internal virtual void HandleStartEvent(EventSubscriptionEntity eventSubscription, object payload,
CommandContext commandContext)
{
var processDefinitionId = eventSubscription.Configuration;
EnsureUtil.EnsureNotNull(
"Configuration of signal start event subscription '" + eventSubscription.Id +
"' contains no process definition id.", processDefinitionId);
DeploymentCache deploymentCache = Context.ProcessEngineConfiguration.DeploymentCache;
ProcessDefinitionEntity processDefinition =
deploymentCache.FindDeployedProcessDefinitionById(processDefinitionId);
if (processDefinition == null || processDefinition.Suspended)
{
// ignore event subscription
Log.DebugIgnoringEventSubscription(eventSubscription, processDefinitionId);
}
else
{
ActivityImpl signalStartEvent = (ActivityImpl)processDefinition.FindActivity(eventSubscription.ActivityId);
IPvmProcessInstance processInstance = processDefinition.CreateProcessInstanceForInitial(signalStartEvent);
processInstance.Start();
}
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: public java.io.InputStream execute(final org.camunda.bpm.engine.impl.interceptor.CommandContext commandContext)
public virtual Stream execute(CommandContext commandContext)
{
ProcessDefinitionEntity processDefinition = Context.ProcessEngineConfiguration.DeploymentCache.findDeployedProcessDefinitionById(processDefinitionId);
foreach (CommandChecker checker in commandContext.ProcessEngineConfiguration.CommandCheckers)
{
checker.checkReadProcessDefinition(processDefinition);
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final String deploymentId = processDefinition.getDeploymentId();
string deploymentId = processDefinition.DeploymentId;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final String resourceName = processDefinition.getDiagramResourceName();
string resourceName = processDefinition.DiagramResourceName;
if (string.ReferenceEquals(resourceName, null))
{
return(null);
}
else
{
Stream processDiagramStream = commandContext.runWithoutAuthorization(new CallableAnonymousInnerClass(this, commandContext, deploymentId, resourceName));
return(processDiagramStream);
}
}
public virtual void ParseProcess(Element processElement, ProcessDefinitionEntity processDefinition)
{
if (HistoryLevel.IsHistoryEventProduced(HistoryEventTypes.ProcessInstanceEnd, null))
{
processDefinition.AddBuiltInListener(PvmEvent.EventNameEnd, ProcessInstanceEndListener);
}
}
public virtual UserOperationLogContextEntryBuilder inContextOf(ProcessDefinitionEntity processDefinition)
{
entry_Renamed.ProcessDefinitionId = processDefinition.Id;
entry_Renamed.ProcessDefinitionKey = processDefinition.Key;
entry_Renamed.DeploymentId = processDefinition.DeploymentId;
return(this);
}
protected internal override void CheckAuthorizations(CommandContext commandContext,
ProcessDefinitionEntity sourceDefinition, ProcessDefinitionEntity targetDefinition,
ICollection <string> processInstanceIds)
{
//commandContext.AuthorizationManager.checkAuthorization(Permissions.CREATE, Resources.BATCH);
base.CheckAuthorizations(commandContext, sourceDefinition, targetDefinition, processInstanceIds);
}
protected internal virtual void CheckAuthorizations(CommandContext commandContext,
ProcessDefinitionEntity sourceDefinition, ProcessDefinitionEntity targetDefinition,
ICollection <string> processInstanceIds)
{
//CompositePermissionCheck migrateInstanceCheck = (new PermissionCheckBuilder()).conjunctive().atomicCheckForResourceId(Resources.PROCESS_DEFINITION, sourceDefinition.Key, Permissions.MIGRATE_INSTANCE).atomicCheckForResourceId(Resources.PROCESS_DEFINITION, targetDefinition.Key, Permissions.MIGRATE_INSTANCE).build();
//commandContext.AuthorizationManager.checkAuthorization(migrateInstanceCheck);
}
