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