public void CancelProcessInstance(String authenticatedActorId, Int64 processInstanceId, DbSession dbSession, IOrganisationService organisationComponent) { // first check if the actor is allowed to cancel this process instance authorizationHelper.CheckCancelProcessInstance(authenticatedActorId, processInstanceId, dbSession); ProcessInstanceImpl processInstance = (ProcessInstanceImpl)dbSession.Load(typeof(ProcessInstanceImpl), processInstanceId); log.Info("actor '" + authenticatedActorId + "' cancels processInstance '" + processInstanceId + "'..."); if (!processInstance.EndHasValue) { CancelFlowRecursive((FlowImpl)processInstance.RootFlow, DateTime.Now); ExecutionContextImpl executionContext = new ExecutionContextImpl(authenticatedActorId, (FlowImpl)processInstance.RootFlow, dbSession, organisationComponent); executionContext.CreateLog(authenticatedActorId, EventType.PROCESS_INSTANCE_CANCEL); EndStateImpl endState = (EndStateImpl)processInstance.ProcessDefinition.EndState; engine.ProcessEndState(endState, executionContext, dbSession); processInstance.End = DateTime.Now; // flush the updates to the db dbSession.Update(processInstance); dbSession.Flush(); } else { throw new SystemException("couldn't cancel process instance : process instance '" + processInstanceId + "' was already finished"); } }
public void ProcessActivityState(ActivityStateImpl activityState, ExecutionContextImpl executionContext, DbSession dbSession) { // first set the flow-state to the activity-state FlowImpl flow = (FlowImpl)executionContext.GetFlow(); log.Debug("processing activity-state '" + activityState + "' for flow '" + executionContext.GetFlow() + "'"); // execute the actions scheduled for this assignment delegationService.RunActionsForEvent(EventType.BEFORE_ACTIVITYSTATE_ASSIGNMENT, activityState.Id, executionContext, dbSession); String actorId = null; String role = activityState.ActorRoleName; DelegationImpl assignmentDelegation = activityState.AssignmentDelegation; if (assignmentDelegation != null) { // delegate the assignment of the activity-state actorId = delegationHelper.DelegateAssignment(activityState.AssignmentDelegation, executionContext); if ((Object)actorId == null) { throw new SystemException("invalid process definition : assigner of activity-state '" + activityState.Name + "' returned null instead of a valid actorId"); } log.Debug("setting actor of flow " + flow + " to " + actorId); } else { // get the assigned actor from the specified attribute instance if ((Object)role != null) { IActor actor = (IActor)executionContext.GetAttribute(role); if (actor == null) { throw new SystemException("invalid process definition : activity-state must be assigned to role '" + role + "' but that attribute instance is null"); } actorId = actor.Id; } else { throw new SystemException("invalid process definition : activity-state '" + activityState.Name + "' does not have an assigner or a role"); } } flow.ActorId = actorId; // If necessary, store the actor in the role if ((string.IsNullOrEmpty(role) == false) && (assignmentDelegation != null)) { executionContext.StoreRole(actorId, activityState); } // the client of performActivity wants to be Informed of the people in charge of the process executionContext.AssignedFlows.Add(flow); // log the assignment executionContext.CreateLog(actorId, EventType.AFTER_ACTIVITYSTATE_ASSIGNMENT); executionContext.AddLogDetail(new ObjectReferenceImpl(activityState)); // execute the actions scheduled for this assignment delegationService.RunActionsForEvent(EventType.AFTER_ACTIVITYSTATE_ASSIGNMENT, activityState.Id, executionContext, dbSession); }
public void ProcessEndState(EndStateImpl endState, ExecutionContextImpl executionContext, DbSession dbSession) { delegationService.RunActionsForEvent(EventType.PROCESS_INSTANCE_END, endState.ProcessDefinition.Id, executionContext, dbSession); executionContext.CreateLog(EventType.PROCESS_INSTANCE_END); FlowImpl rootFlow = (FlowImpl)executionContext.GetFlow(); rootFlow.ActorId = null; rootFlow.End = DateTime.Now; rootFlow.Node = endState; // setting the node is not necessary if this method is called // from processTransition, but it is necessary if this method is // called from cancelProcessInstance in the component-impl. ProcessInstanceImpl processInstance = (ProcessInstanceImpl)executionContext.GetProcessInstance(); FlowImpl superProcessFlow = (FlowImpl)processInstance.SuperProcessFlow; if (superProcessFlow != null) { log.Debug("reactivating the super process..."); // create the execution context for the parent-process ExecutionContextImpl superExecutionContext = new ExecutionContextImpl(executionContext.PreviousActorId, superProcessFlow, executionContext.DbSession, executionContext.GetOrganisationComponent()); superExecutionContext.SetInvokedProcessContext(executionContext); // delegate the attributeValues ProcessStateImpl processState = (ProcessStateImpl)superProcessFlow.Node; Object[] completionData = delegationHelper.DelegateProcessTermination(processState.ProcessInvokerDelegation, superExecutionContext); IDictionary attributeValues = (IDictionary)completionData[0]; String transitionName = (String)completionData[1]; TransitionImpl transition = transitionRepository.GetTransition(transitionName, processState, executionContext.DbSession); // process the super process transition ProcessTransition(transition, superExecutionContext, dbSession); } }
public void DelegateAction(DelegationImpl delegation, ExecutionContextImpl executionContext) { try { executionContext.CreateLog(EventType.ACTION); executionContext.AddLogDetail(new DelegateCallImpl(delegation, typeof (IAction))); IActionHandler actionHandler = (IActionHandler) GetDelegate(delegation); executionContext.SetConfiguration(ParseConfiguration(delegation)); actionHandler.Run(executionContext); } catch (Exception t) { HandleException(delegation, executionContext, t); } }
public void DelegateScheduledAction(DelegationImpl delegation, ExecutionContextImpl executionContext) { try { /* can't add logs because of a integritiy constraint violation... * can you find why ? */ if (executionContext.GetFlow() != null) { executionContext.CreateLog(EventType.ACTION); executionContext.AddLogDetail(new DelegateCallImpl(delegation, typeof (IAction))); } IActionHandler actionHandler = (IActionHandler) GetDelegate(delegation); executionContext.SetConfiguration(ParseConfiguration(delegation)); actionHandler.Run(executionContext); } catch (Exception t) { HandleException(delegation, executionContext, t); } }
public void CancelFlow(String authenticatedActorId, Int64 flowId, DbSession dbSession, IOrganisationService organisationComponent) { // first check if the actor is allowed to cancel this flow authorizationHelper.CheckCancelFlow(authenticatedActorId, flowId, dbSession); FlowImpl flow = (FlowImpl) dbSession.Load(typeof (FlowImpl), flowId); log.Info("actor '" + authenticatedActorId + "' cancels flow '" + flowId + "'..."); // only perform the cancel if this flow is not finished yet if (!flow.EndHasValue) { ExecutionContextImpl executionContext = new ExecutionContextImpl(authenticatedActorId, flow, dbSession, organisationComponent); executionContext.CreateLog(authenticatedActorId, EventType.FLOW_CANCEL); if (flow.IsRootFlow()) { // set the flow in the end-state log.Debug("setting root flow to the end state..."); EndStateImpl endState = (EndStateImpl) flow.ProcessInstance.ProcessDefinition.EndState; engine.ProcessEndState(endState, executionContext, dbSession); } else { // set the flow in the join ConcurrentBlockImpl concurrentBlock = (ConcurrentBlockImpl) flow.Node.ProcessBlock; JoinImpl join = (JoinImpl) concurrentBlock.Join; log.Debug("setting concurrent flow to join '" + join + "'"); engine.ProcessJoin(join, executionContext, dbSession); } // flush the updates to the db dbSession.Update(flow); dbSession.Flush(); } }
public void CancelFlow(String authenticatedActorId, Int64 flowId, DbSession dbSession, IOrganisationService organisationComponent) { // first check if the actor is allowed to cancel this flow authorizationHelper.CheckCancelFlow(authenticatedActorId, flowId, dbSession); FlowImpl flow = (FlowImpl)dbSession.Load(typeof(FlowImpl), flowId); log.Info("actor '" + authenticatedActorId + "' cancels flow '" + flowId + "'..."); // only perform the cancel if this flow is not finished yet if (!flow.EndHasValue) { ExecutionContextImpl executionContext = new ExecutionContextImpl(authenticatedActorId, flow, dbSession, organisationComponent); executionContext.CreateLog(authenticatedActorId, EventType.FLOW_CANCEL); if (flow.IsRootFlow()) { // set the flow in the end-state log.Debug("setting root flow to the end state..."); EndStateImpl endState = (EndStateImpl)flow.ProcessInstance.ProcessDefinition.EndState; engine.ProcessEndState(endState, executionContext, dbSession); } else { // set the flow in the join ConcurrentBlockImpl concurrentBlock = (ConcurrentBlockImpl)flow.Node.ProcessBlock; JoinImpl join = (JoinImpl)concurrentBlock.Join; log.Debug("setting concurrent flow to join '" + join + "'"); engine.ProcessJoin(join, executionContext, dbSession); } // flush the updates to the db dbSession.Update(flow); dbSession.Flush(); } }
public void CancelProcessInstance(String authenticatedActorId, Int64 processInstanceId, DbSession dbSession, IOrganisationService organisationComponent) { // first check if the actor is allowed to cancel this process instance authorizationHelper.CheckCancelProcessInstance(authenticatedActorId, processInstanceId, dbSession); ProcessInstanceImpl processInstance = (ProcessInstanceImpl) dbSession.Load(typeof (ProcessInstanceImpl), processInstanceId); log.Info("actor '" + authenticatedActorId + "' cancels processInstance '" + processInstanceId + "'..."); if (!processInstance.EndHasValue) { CancelFlowRecursive((FlowImpl) processInstance.RootFlow, DateTime.Now); ExecutionContextImpl executionContext = new ExecutionContextImpl(authenticatedActorId, (FlowImpl) processInstance.RootFlow, dbSession, organisationComponent); executionContext.CreateLog(authenticatedActorId, EventType.PROCESS_INSTANCE_CANCEL); EndStateImpl endState = (EndStateImpl) processInstance.ProcessDefinition.EndState; engine.ProcessEndState(endState, executionContext, dbSession); processInstance.End = DateTime.Now; // flush the updates to the db dbSession.Update(processInstance); dbSession.Flush(); } else { throw new SystemException("couldn't cancel process instance : process instance '" + processInstanceId + "' was already finished"); } }
public IProcessInstance StartProcessInstance(String authenticatedActorId, Int64 processDefinitionId, IDictionary attributeValues, String transitionName, Relations relations, DbSession dbSession, IOrganisationService organisationComponent) { ProcessInstanceImpl processInstance = null; // First check if the actor is allowed to start this instance authorizationHelper.CheckStartProcessInstance(authenticatedActorId, processDefinitionId, attributeValues, transitionName, dbSession); // get the process-definition and its start-state ProcessDefinitionImpl processDefinition = (ProcessDefinitionImpl)definitionRepository.GetProcessDefinition(processDefinitionId, null, dbSession); StartStateImpl startState = (StartStateImpl) processDefinition.StartState; log.Info("actor '" + authenticatedActorId + "' starts an instance of process '" + processDefinition.Name + "'..."); processInstance = new ProcessInstanceImpl(authenticatedActorId, processDefinition); FlowImpl rootFlow = (FlowImpl) processInstance.RootFlow; ExecutionContextImpl executionContext = new ExecutionContextImpl(authenticatedActorId, rootFlow, dbSession, organisationComponent); MyExecutionContext myExecutionContext = new MyExecutionContext(); // save the process instance to allow hibernate queries dbSession.Save(processInstance); //dbSession.Lock(processInstance,LockMode.Upgrade); delegationService.RunActionsForEvent(EventType.BEFORE_PERFORM_OF_ACTIVITY, startState.Id, executionContext,dbSession); // store the attributes executionContext.CreateLog(authenticatedActorId, EventType.PROCESS_INSTANCE_START); //LogImpl logImpl = rootFlow.CreateLog(authenticatedActorId, EventType.PROCESS_INSTANCE_START);//new add executionContext.CheckAccess(attributeValues, startState); //startState.CheckAccess(attributeValues); //�ݨӤ]�䤣��AttributeInstance executionContext.StoreAttributeValues(attributeValues); // if this activity has a role-name, save the actor in the corresponding attribute executionContext.StoreRole(authenticatedActorId, startState); // run the actions delegationService.RunActionsForEvent(EventType.PROCESS_INSTANCE_START, processDefinitionId, executionContext,dbSession); // from here on, we consider the actor as being the previous actor executionContext.SetActorAsPrevious(); // process the start-transition TransitionImpl startTransition = transitionRepository.GetTransition(transitionName, startState, dbSession); engine.ProcessTransition(startTransition, executionContext, dbSession); // run the actions delegationService.RunActionsForEvent(EventType.AFTER_PERFORM_OF_ACTIVITY, startState.Id, executionContext,dbSession); // flush the updates to the db dbSession.Update(processInstance); dbSession.Flush(); //@portme /* if (relations != null) { relations.resolve(processInstance); } */ return processInstance; }
public IList PerformActivity(String authenticatedActorId, Int64 flowId, IDictionary attributeValues, String transitionName, Relations relations, DbSession dbSession, IOrganisationService organisationComponent) { IList assignedFlows = null; // get the flow FlowImpl flow = (FlowImpl) dbSession.Load(typeof (FlowImpl), flowId); dbSession.Lock(flow.ProcessInstance, LockMode.Upgrade); ActivityStateImpl activityState = (ActivityStateImpl) flow.Node; // TODO : check which part can move to the DefaultAuthorizationHandler if ((Object) flow.ActorId == null) { throw new SystemException("the flow on which you try to perform an activity is not assigned to an actor"); } else { if ((Object) authenticatedActorId == null) { throw new AuthorizationException("you can't perform an activity because you are not authenticated"); } // else if ( ! authenticatedActorId.equals( flow.getActorId() ) ) { // throw new AuthorizationException( "activity '" + activityState.getName() + "' in flow " + flow.getId() + " is not assigned to the authenticated actor (" + authenticatedActorId + ") but to " + flow.getActorId() ); // } } // first check if the actor is allowed to perform this activity authorizationHelper.CheckPerformActivity(authenticatedActorId, flowId, attributeValues, transitionName, dbSession); log.Info("actor '" + authenticatedActorId + "' performs activity '" + activityState.Name + "'..."); // create the execution-context ExecutionContextImpl executionContext = new ExecutionContextImpl(authenticatedActorId, flow, dbSession, organisationComponent); // if this activity has a role-name, save the actor in the corresponding attribute // attributeValues = state.addRoleAttributeValue( attributeValues, authenticatedActorId, organisationComponent ); // log event & trigger actions delegationService.RunActionsForEvent(EventType.BEFORE_PERFORM_OF_ACTIVITY, activityState.Id, executionContext,dbSession); // store the supplied attribute values executionContext.CreateLog(authenticatedActorId, EventType.PERFORM_OF_ACTIVITY); executionContext.AddLogDetail(new ObjectReferenceImpl(activityState)); executionContext.CheckAccess(attributeValues, activityState); executionContext.StoreAttributeValues(attributeValues); // log event & trigger actions delegationService.RunActionsForEvent(EventType.PERFORM_OF_ACTIVITY, activityState.Id, executionContext,dbSession); // from here on, we consider the actor as being the previous actor executionContext.SetActorAsPrevious(); // select and process the transition TransitionImpl startTransition = transitionRepository.GetTransition(transitionName, activityState, dbSession); engine.ProcessTransition(startTransition, executionContext, dbSession); // log event & trigger actions delegationService.RunActionsForEvent(EventType.AFTER_PERFORM_OF_ACTIVITY, activityState.Id, executionContext,dbSession); assignedFlows = executionContext.AssignedFlows; // flush the updates to the db dbSession.Update(flow.ProcessInstance); dbSession.Flush(); if (relations != null) { relations.Resolve(assignedFlows); } dbSession.Update(flow.ProcessInstance); return assignedFlows; }
public IProcessInstance StartProcessInstance(String authenticatedActorId, Int64 processDefinitionId, IDictionary attributeValues, String transitionName, Relations relations, DbSession dbSession, IOrganisationService organisationComponent) { ProcessInstanceImpl processInstance = null; // First check if the actor is allowed to start this instance authorizationHelper.CheckStartProcessInstance(authenticatedActorId, processDefinitionId, attributeValues, transitionName, dbSession); // get the process-definition and its start-state ProcessDefinitionImpl processDefinition = (ProcessDefinitionImpl)definitionRepository.GetProcessDefinition(processDefinitionId, null, dbSession); StartStateImpl startState = (StartStateImpl)processDefinition.StartState; log.Info("actor '" + authenticatedActorId + "' starts an instance of process '" + processDefinition.Name + "'..."); processInstance = new ProcessInstanceImpl(authenticatedActorId, processDefinition); FlowImpl rootFlow = (FlowImpl)processInstance.RootFlow; ExecutionContextImpl executionContext = new ExecutionContextImpl(authenticatedActorId, rootFlow, dbSession, organisationComponent); // save the process instance to allow hibernate queries dbSession.Save(processInstance); //dbSession.Lock(processInstance,LockMode.Upgrade); delegationService.RunActionsForEvent(EventType.BEFORE_PERFORM_OF_ACTIVITY, startState.Id, executionContext, dbSession); // store the attributes executionContext.CreateLog(authenticatedActorId, EventType.PROCESS_INSTANCE_START); //LogImpl logImpl = rootFlow.CreateLog(authenticatedActorId, EventType.PROCESS_INSTANCE_START);//new add executionContext.CheckAccess(attributeValues, startState); //startState.CheckAccess(attributeValues); //看來也找不到AttributeInstance executionContext.StoreAttributeValues(attributeValues); // if this activity has a role-name, save the actor in the corresponding attribute executionContext.StoreRole(authenticatedActorId, startState); // run the actions delegationService.RunActionsForEvent(EventType.PROCESS_INSTANCE_START, processDefinitionId, executionContext, dbSession); // from here on, we consider the actor as being the previous actor executionContext.SetActorAsPrevious(); // process the start-transition TransitionImpl startTransition = transitionRepository.GetTransition(transitionName, startState, dbSession); engine.ProcessTransition(startTransition, executionContext, dbSession); // run the actions delegationService.RunActionsForEvent(EventType.AFTER_PERFORM_OF_ACTIVITY, startState.Id, executionContext, dbSession); // flush the updates to the db dbSession.Update(processInstance); dbSession.Flush(); //@portme /* if (relations != null) * { * relations.resolve(processInstance); * } */ return(processInstance); }
public void ProcessProcessState(ProcessStateImpl processState, ExecutionContextImpl executionContext, DbSession dbSession) { // TODO : try to group similarities between this method and ExecutionComponentImpl.startProcessInstance and // group them in a common method // provide a convenient local var for the database session //DbSession dbSession = executionContext.DbSession; // get the sub-process-definition and its start-state ProcessDefinitionImpl subProcessDefinition = (ProcessDefinitionImpl)processState.SubProcess; StartStateImpl startState = (StartStateImpl)subProcessDefinition.StartState; log.Info("processState '" + processState.Name + "' starts an instance of process '" + subProcessDefinition.Name + "'..."); // get the actor that is supposed to start this process instance IActor subProcessStarter = actorExpressionResolver.ResolveArgument(processState.ActorExpression, executionContext); String subProcessStarterId = subProcessStarter.Id; // create the process-instance ProcessInstanceImpl subProcessInstance = new ProcessInstanceImpl(subProcessStarterId, subProcessDefinition); FlowImpl rootFlow = (FlowImpl)subProcessInstance.RootFlow; // attach the subProcesInstance to the parentFlow FlowImpl superProcessFlow = (FlowImpl)executionContext.GetFlow(); superProcessFlow.SetSubProcessInstance(subProcessInstance); subProcessInstance.SuperProcessFlow = superProcessFlow; // create the execution context for the sub-process ExecutionContextImpl subExecutionContext = new ExecutionContextImpl(subProcessStarterId, rootFlow, dbSession, executionContext.GetOrganisationComponent()); // save the process instance to allow hibernate queries dbSession.Save(subProcessInstance); // add the log executionContext.CreateLog(EventType.SUB_PROCESS_INSTANCE_START); executionContext.AddLogDetail(new ObjectReferenceImpl(subProcessInstance)); // delegate the attributeValues Object[] processInvocationData = delegationHelper.DelegateProcessInvocation(processState.ProcessInvokerDelegation, subExecutionContext); String transitionName = (String)processInvocationData[0]; IDictionary attributeValues = (IDictionary)processInvocationData[1]; // store the attributes subExecutionContext.CreateLog(subProcessStarterId, EventType.PROCESS_INSTANCE_START); subExecutionContext.StoreAttributeValues(attributeValues); subExecutionContext.StoreRole(subProcessStarterId, startState); // log event & trigger actions delegationService.RunActionsForEvent(EventType.SUB_PROCESS_INSTANCE_START, processState.Id, subExecutionContext, dbSession); delegationService.RunActionsForEvent(EventType.PROCESS_INSTANCE_START, subProcessDefinition.Id, subExecutionContext, dbSession); // from here on, we consider the actor as being the previous actor subExecutionContext.SetActorAsPrevious(); // process the start-transition TransitionImpl startTransition = transitionRepository.GetTransition(transitionName, startState, dbSession); ProcessTransition(startTransition, subExecutionContext, dbSession); // add the assigned flows of the subContext to the parentContext executionContext.AssignedFlows.AddRange(subExecutionContext.AssignedFlows); // flush the updates to the db dbSession.Update(subProcessInstance); dbSession.Flush(); }
public IList PerformActivity(String authenticatedActorId, Int64 flowId, IDictionary attributeValues, String transitionName, Relations relations, DbSession dbSession, IOrganisationService organisationComponent) { IList assignedFlows = null; // get the flow FlowImpl flow = (FlowImpl)dbSession.Load(typeof(FlowImpl), flowId); dbSession.Lock(flow.ProcessInstance, LockMode.Upgrade); ActivityStateImpl activityState = (ActivityStateImpl)flow.Node; // TODO : check which part can move to the DefaultAuthorizationHandler if ((Object)flow.ActorId == null) { throw new SystemException("the flow on which you try to perform an activity is not assigned to an actor"); } else { if ((Object)authenticatedActorId == null) { throw new AuthorizationException("you can't perform an activity because you are not authenticated"); } // else if ( ! authenticatedActorId.equals( flow.getActorId() ) ) { // throw new AuthorizationException( "activity '" + activityState.getName() + "' in flow " + flow.getId() + " is not assigned to the authenticated actor (" + authenticatedActorId + ") but to " + flow.getActorId() ); // } } // first check if the actor is allowed to perform this activity authorizationHelper.CheckPerformActivity(authenticatedActorId, flowId, attributeValues, transitionName, dbSession); log.Info("actor '" + authenticatedActorId + "' performs activity '" + activityState.Name + "'..."); // create the execution-context ExecutionContextImpl executionContext = new ExecutionContextImpl(authenticatedActorId, flow, dbSession, organisationComponent); // if this activity has a role-name, save the actor in the corresponding attribute // attributeValues = state.addRoleAttributeValue( attributeValues, authenticatedActorId, organisationComponent ); // log event & trigger actions delegationService.RunActionsForEvent(EventType.BEFORE_PERFORM_OF_ACTIVITY, activityState.Id, executionContext, dbSession); // store the supplied attribute values executionContext.CreateLog(authenticatedActorId, EventType.PERFORM_OF_ACTIVITY); executionContext.AddLogDetail(new ObjectReferenceImpl(activityState)); executionContext.CheckAccess(attributeValues, activityState); executionContext.StoreAttributeValues(attributeValues); // log event & trigger actions delegationService.RunActionsForEvent(EventType.PERFORM_OF_ACTIVITY, activityState.Id, executionContext, dbSession); // from here on, we consider the actor as being the previous actor //因為繼續往下跑,ActorId就有可能轉換成下一關卡的處理人員 //所以previousActorId就是現在的登入人員 executionContext.SetActorAsPrevious(); // select and process the transition TransitionImpl startTransition = transitionRepository.GetTransition(transitionName, activityState, dbSession); engine.ProcessTransition(startTransition, executionContext, dbSession); // log event & trigger actions delegationService.RunActionsForEvent(EventType.AFTER_PERFORM_OF_ACTIVITY, activityState.Id, executionContext, dbSession); assignedFlows = executionContext.AssignedFlows; // flush the updates to the db dbSession.Update(flow.ProcessInstance); dbSession.Flush(); if (relations != null) { relations.Resolve(assignedFlows); } dbSession.Update(flow.ProcessInstance); return(assignedFlows); }
public void ProcessActivityState(ActivityStateImpl activityState, ExecutionContextImpl executionContext,DbSession dbSession) { // first set the flow-state to the activity-state FlowImpl flow = (FlowImpl) executionContext.GetFlow(); log.Debug("processing activity-state '" + activityState + "' for flow '" + executionContext.GetFlow() + "'"); // execute the actions scheduled for this assignment delegationService.RunActionsForEvent(EventType.BEFORE_ACTIVITYSTATE_ASSIGNMENT, activityState.Id, executionContext,dbSession); String actorId = null; String role = activityState.ActorRoleName; DelegationImpl assignmentDelegation = activityState.AssignmentDelegation; if (assignmentDelegation != null) { // delegate the assignment of the activity-state actorId = delegationHelper.DelegateAssignment(activityState.AssignmentDelegation, executionContext); if ((Object) actorId == null) { throw new SystemException("invalid process definition : assigner of activity-state '" + activityState.Name + "' returned null instead of a valid actorId"); } log.Debug("setting actor of flow " + flow + " to " + actorId); } else { // get the assigned actor from the specified attribute instance if ((Object) role != null) { IActor actor = (IActor) executionContext.GetAttribute(role); if (actor == null) { throw new SystemException("invalid process definition : activity-state must be assigned to role '" + role + "' but that attribute instance is null"); } actorId = actor.Id; } else { throw new SystemException("invalid process definition : activity-state '" + activityState.Name + "' does not have an assigner or a role"); } } flow.ActorId = actorId; // If necessary, store the actor in the role if ((string.IsNullOrEmpty(role) == false) && (assignmentDelegation != null)) { executionContext.StoreRole(actorId, activityState); } // the client of performActivity wants to be Informed of the people in charge of the process executionContext.AssignedFlows.Add(flow); // log the assignment executionContext.CreateLog(actorId, EventType.AFTER_ACTIVITYSTATE_ASSIGNMENT); executionContext.AddLogDetail(new ObjectReferenceImpl(activityState)); // execute the actions scheduled for this assignment delegationService.RunActionsForEvent(EventType.AFTER_ACTIVITYSTATE_ASSIGNMENT, activityState.Id, executionContext,dbSession); }
public void ProcessProcessState(ProcessStateImpl processState, ExecutionContextImpl executionContext,DbSession dbSession) { // TODO : try to group similarities between this method and ExecutionComponentImpl.startProcessInstance and // group them in a common method // provide a convenient local var for the database session //DbSession dbSession = executionContext.DbSession; // get the sub-process-definition and its start-state ProcessDefinitionImpl subProcessDefinition = (ProcessDefinitionImpl) processState.SubProcess; StartStateImpl startState = (StartStateImpl) subProcessDefinition.StartState; log.Info("processState '" + processState.Name + "' starts an instance of process '" + subProcessDefinition.Name + "'..."); // get the actor that is supposed to start this process instance IActor subProcessStarter = actorExpressionResolver.ResolveArgument(processState.ActorExpression, executionContext); String subProcessStarterId = subProcessStarter.Id; // create the process-instance ProcessInstanceImpl subProcessInstance = new ProcessInstanceImpl(subProcessStarterId, subProcessDefinition); FlowImpl rootFlow = (FlowImpl) subProcessInstance.RootFlow; // attach the subProcesInstance to the parentFlow FlowImpl superProcessFlow = (FlowImpl) executionContext.GetFlow(); superProcessFlow.SetSubProcessInstance(subProcessInstance); subProcessInstance.SuperProcessFlow = superProcessFlow; // create the execution context for the sub-process ExecutionContextImpl subExecutionContext = new ExecutionContextImpl(subProcessStarterId, rootFlow, dbSession, executionContext.GetOrganisationComponent()); // save the process instance to allow hibernate queries dbSession.Save(subProcessInstance); // add the log executionContext.CreateLog(EventType.SUB_PROCESS_INSTANCE_START); executionContext.AddLogDetail(new ObjectReferenceImpl(subProcessInstance)); // delegate the attributeValues Object[] processInvocationData = delegationHelper.DelegateProcessInvocation(processState.ProcessInvokerDelegation, subExecutionContext); String transitionName = (String) processInvocationData[0]; IDictionary attributeValues = (IDictionary) processInvocationData[1]; // store the attributes subExecutionContext.CreateLog(subProcessStarterId, EventType.PROCESS_INSTANCE_START); subExecutionContext.StoreAttributeValues(attributeValues); subExecutionContext.StoreRole(subProcessStarterId, startState); // log event & trigger actions delegationService.RunActionsForEvent(EventType.SUB_PROCESS_INSTANCE_START, processState.Id, subExecutionContext,dbSession); delegationService.RunActionsForEvent(EventType.PROCESS_INSTANCE_START, subProcessDefinition.Id, subExecutionContext,dbSession); // from here on, we consider the actor as being the previous actor subExecutionContext.SetActorAsPrevious(); // process the start-transition TransitionImpl startTransition = transitionRepository.GetTransition(transitionName, startState, dbSession); ProcessTransition(startTransition, subExecutionContext,dbSession); // add the assigned flows of the subContext to the parentContext executionContext.AssignedFlows.AddRange(subExecutionContext.AssignedFlows); // flush the updates to the db dbSession.Update(subProcessInstance); dbSession.Flush(); }
public void ProcessFork(ForkImpl fork, ExecutionContextImpl executionContext,DbSession dbSession) { log.Debug("forking flow " + executionContext.GetFlow()); // First initialize the children of the flow to be forked FlowImpl flow = (FlowImpl) executionContext.GetFlow(); flow.Children = new ListSet(); // Then initialise the forked flows in the execution context executionContext.ForkedFlows = new ArrayList(); DelegationImpl delegation = fork.ForkDelegation; if (delegation != null) { delegationHelper.DelegateFork(fork.ForkDelegation, executionContext); } else { // execute the default fork behaviour IEnumerator iter = fork.LeavingTransitions.GetEnumerator(); while (iter.MoveNext()) { TransitionImpl transition = (TransitionImpl) iter.Current; executionContext.ForkFlow(transition, null); } } // create the fork event & remember the parent flow FlowImpl parentFlow = (FlowImpl) executionContext.GetFlow(); executionContext.CreateLog(EventType.FORK); // log the event executionContext.SetFlow(parentFlow); IList forkedFlows = executionContext.ForkedFlows; IEnumerator iter2 = forkedFlows.GetEnumerator(); while (iter2.MoveNext()) { ForkedFlow forkedFlow = (ForkedFlow) iter2.Current; log.Debug("adding object reference [" + forkedFlow.Flow + "] to flow [" + parentFlow + "]"); executionContext.AddLogDetail(new ObjectReferenceImpl(forkedFlow.Flow)); } // loop over all flows that were forked in the ForkHandler implementation iter2 = forkedFlows.GetEnumerator(); while (iter2.MoveNext()) { ForkedFlow forkedFlow = (ForkedFlow) iter2.Current; // trigger actions, scheduled after the creation and setting of the attributeValues // but before the fork is being processed delegationService.RunActionsForEvent(EventType.FORK, fork.Id, executionContext,dbSession); // then process the forked flow transition executionContext.SetFlow(forkedFlow.Flow); ProcessTransition(forkedFlow.Transition, executionContext,dbSession); } }
public void ProcessEndState(EndStateImpl endState, ExecutionContextImpl executionContext,DbSession dbSession) { delegationService.RunActionsForEvent(EventType.PROCESS_INSTANCE_END, endState.ProcessDefinition.Id, executionContext,dbSession); executionContext.CreateLog(EventType.PROCESS_INSTANCE_END); FlowImpl rootFlow = (FlowImpl) executionContext.GetFlow(); rootFlow.ActorId = null; rootFlow.End = DateTime.Now; rootFlow.Node = endState; // setting the node is not necessary if this method is called // from processTransition, but it is necessary if this method is // called from cancelProcessInstance in the component-impl. ProcessInstanceImpl processInstance = (ProcessInstanceImpl) executionContext.GetProcessInstance(); FlowImpl superProcessFlow = (FlowImpl) processInstance.SuperProcessFlow; if (superProcessFlow != null) { log.Debug("reactivating the super process..."); // create the execution context for the parent-process ExecutionContextImpl superExecutionContext = new ExecutionContextImpl(executionContext.PreviousActorId, superProcessFlow, executionContext.DbSession, executionContext.GetOrganisationComponent()); superExecutionContext.SetInvokedProcessContext(executionContext); // delegate the attributeValues ProcessStateImpl processState = (ProcessStateImpl) superProcessFlow.Node; Object[] completionData = delegationHelper.DelegateProcessTermination(processState.ProcessInvokerDelegation, superExecutionContext); IDictionary attributeValues = (IDictionary) completionData[0]; String transitionName = (String) completionData[1]; TransitionImpl transition = transitionRepository.GetTransition(transitionName, processState, executionContext.DbSession); // process the super process transition ProcessTransition(transition, superExecutionContext,dbSession); } }
public void ProcessFork(ForkImpl fork, ExecutionContextImpl executionContext, DbSession dbSession) { log.Debug("forking flow " + executionContext.GetFlow()); // First initialize the children of the flow to be forked FlowImpl flow = (FlowImpl)executionContext.GetFlow(); flow.Children = new ListSet(); // Then initialise the forked flows in the execution context executionContext.ForkedFlows = new ArrayList(); DelegationImpl delegation = fork.ForkDelegation; if (delegation != null) { delegationHelper.DelegateFork(fork.ForkDelegation, executionContext); } else { // execute the default fork behaviour IEnumerator iter = fork.LeavingTransitions.GetEnumerator(); while (iter.MoveNext()) { TransitionImpl transition = (TransitionImpl)iter.Current; executionContext.ForkFlow(transition, null); } } // create the fork event & remember the parent flow FlowImpl parentFlow = (FlowImpl)executionContext.GetFlow(); executionContext.CreateLog(EventType.FORK); // log the event executionContext.SetFlow(parentFlow); IList forkedFlows = executionContext.ForkedFlows; IEnumerator iter2 = forkedFlows.GetEnumerator(); while (iter2.MoveNext()) { ForkedFlow forkedFlow = (ForkedFlow)iter2.Current; log.Debug("adding object reference [" + forkedFlow.Flow + "] to flow [" + parentFlow + "]"); executionContext.AddLogDetail(new ObjectReferenceImpl(forkedFlow.Flow)); } // loop over all flows that were forked in the ForkHandler implementation iter2 = forkedFlows.GetEnumerator(); while (iter2.MoveNext()) { ForkedFlow forkedFlow = (ForkedFlow)iter2.Current; // trigger actions, scheduled after the creation and setting of the attributeValues // but before the fork is being processed delegationService.RunActionsForEvent(EventType.FORK, fork.Id, executionContext, dbSession); // then process the forked flow transition executionContext.SetFlow(forkedFlow.Flow); ProcessTransition(forkedFlow.Transition, executionContext, dbSession); } }