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 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 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 TransitionImpl DelegateDecision(DelegationImpl delegation, ExecutionContextImpl executionContext) { TransitionImpl selectedTransition = null; try { IDecisionHandler decision = (IDecisionHandler) GetDelegate(delegation); executionContext.SetConfiguration(ParseConfiguration(delegation)); String transitionName = decision.Decide(executionContext); if ((Object) transitionName == null) { throw new SystemException("Decision-delegate for decision '" + executionContext.GetNode() + "' returned null instead of a transition-name : " + decision.GetType().FullName); } try { Object[] args = new Object[] {executionContext.GetNode().Id, transitionName}; IType[] types = new IType[] {DbType.LONG, DbType.STRING}; selectedTransition = (TransitionImpl) executionContext.DbSession.FindOne(queryFindLeavingTransitionByName, args, types); } catch (Exception t) { throw new SystemException("couldn't find transition '" + transitionName + "' that was selected by the decision-delegate of activity '" + executionContext.GetNode().Name + "' : " + t.Message); } } catch (Exception t) { HandleException(delegation, executionContext, t); } return selectedTransition; }
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 SaveActivity(String authenticatedActorId, Int64 flowId, IDictionary attributeValues, DbSession dbSession, IOrganisationService organisationComponent) { // get the flow FlowImpl flow = (FlowImpl)dbSession.Load(typeof(FlowImpl), flowId); // create the execution-context ExecutionContextImpl executionContext = new ExecutionContextImpl(authenticatedActorId, flow, dbSession, organisationComponent); executionContext.StoreAttributeValues(attributeValues); }
public void ProcessDecision(DecisionImpl decision, ExecutionContextImpl executionContext, DbSession dbSession) { // trigger actions, scheduled before the decision actually is made delegationService.RunActionsForEvent(EventType.BEFORE_DECISION, decision.Id, executionContext, dbSession); // delegate the decision TransitionImpl selectedTransition = delegationHelper.DelegateDecision(decision.DecisionDelegation, executionContext); // process the selected transition ProcessTransition(selectedTransition, executionContext, dbSession); // trigger actions, scheduled after the decision is made delegationService.RunActionsForEvent(EventType.AFTER_DECISION, decision.Id, executionContext, 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); } }
//private const String queryFindActionsByEventType = "select a from a in class NetBpm.Workflow.Definition.Impl.ActionImpl " + // "where a.EventType = ? " + // " and a.DefinitionObjectId = ? "; //public void RunActionsForEvent(EventType eventType, Int64 definitionObjectId, ExecutionContextImpl executionContext) //{ // log.Debug("processing '" + eventType + "' events for executionContext " + executionContext); // DbSession dbSession = executionContext.DbSession; // // find all actions for definitionObject on the given eventType // Object[] values = new Object[] {eventType, definitionObjectId}; // IType[] types = new IType[] {DbType.INTEGER, DbType.LONG}; // IList actions = dbSession.Find(queryFindActionsByEventType, values, types); // IEnumerator iter = actions.GetEnumerator(); // log.Debug("list" + actions); // while (iter.MoveNext()) // { // ActionImpl action = (ActionImpl) iter.Current; // log.Debug("action: " + action); // delegationHelper.DelegateAction(action.ActionDelegation, executionContext); // } // log.Debug("ende runActionsForEvent!"); //} public void ProcessTransition(TransitionImpl transition, ExecutionContextImpl executionContext, DbSession dbSession) { log.Debug("processing transition '" + transition + "' for flow '" + executionContext.GetFlow() + "'"); // trigger all the actions scheduled for this transition delegationService.RunActionsForEvent(EventType.TRANSITION, transition.Id, executionContext, dbSession); // first set the state of the execution context and the flow // to the node that is going to be processed FlowImpl flow = (FlowImpl)executionContext.GetFlow(); NodeImpl destination = (NodeImpl)transition.To; flow.Node = destination; executionContext.SetNode(destination); // note : I want to keep the engine methods grouped in this class, that is why I // didn't use inheritance but used an instanceof-switch instead. if (destination is ActivityStateImpl) { ProcessActivityState((ActivityStateImpl)destination, executionContext, dbSession); } else if (destination is ProcessStateImpl) { ProcessProcessState((ProcessStateImpl)destination, executionContext, dbSession); } else if (destination is DecisionImpl) { ProcessDecision((DecisionImpl)destination, executionContext, dbSession); } else if (destination is ForkImpl) { ProcessFork((ForkImpl)destination, executionContext, dbSession); } else if (destination is JoinImpl) { ProcessJoin((JoinImpl)destination, executionContext, dbSession); } else if (destination is EndStateImpl) { ProcessEndState((EndStateImpl)destination, executionContext, dbSession); } else { throw new SystemException(""); } }
public void ProcessTransition(TransitionImpl transition, ExecutionContextImpl executionContext) { log.Debug("processing transition '" + transition + "' for flow '" + executionContext.GetFlow() + "'"); // trigger all the actions scheduled for this transition RunActionsForEvent(EventType.TRANSITION, transition.Id, executionContext); // first set the state of the execution context and the flow // to the node that is going to be processed FlowImpl flow = (FlowImpl) executionContext.GetFlow(); NodeImpl destination = (NodeImpl) transition.To; flow.Node = destination; executionContext.SetNode(destination); // note : I want to keep the engine methods grouped in this class, that is why I // didn't use inheritance but used an instanceof-switch instead. if (destination is ActivityStateImpl) { ProcessActivityState((ActivityStateImpl) destination, executionContext); } else if (destination is ProcessStateImpl) { ProcessProcessState((ProcessStateImpl) destination, executionContext); } else if (destination is DecisionImpl) { ProcessDecision((DecisionImpl) destination, executionContext); } else if (destination is ForkImpl) { ProcessFork((ForkImpl) destination, executionContext); } else if (destination is JoinImpl) { ProcessJoin((JoinImpl) destination, executionContext); } else if (destination is EndStateImpl) { ProcessEndState((EndStateImpl) destination, executionContext); } else { throw new SystemException(""); } }
public void RunActionsForEvent(EventType eventType, long definitionObjectId, ExecutionContextImpl executionContext,DbSession dbSession) { log.Debug("processing '" + eventType + "' events for executionContext " + executionContext); // find all actions for definitionObject on the given eventType Object[] values = new Object[] { eventType, definitionObjectId }; IType[] types = new IType[] { DbType.INTEGER, DbType.LONG }; IList actions = dbSession.Find(queryFindActionsByEventType, values, types); IEnumerator iter = actions.GetEnumerator(); log.Debug("list" + actions); while (iter.MoveNext()) { ActionImpl action = (ActionImpl)iter.Current; log.Debug("action: " + action); delegationHelper.DelegateAction(action.ActionDelegation, executionContext); } log.Debug("ende runActionsForEvent!"); }
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 IActivityForm GetActivityForm(String authenticatedActorId, Int64 flowId, DbSession dbSession, IOrganisationService organisationComponent) { IActivityForm activityForm = null; // First check if the actor is allowed to get this form authorizationHelper.CheckGetActivityForm(authenticatedActorId, flowId, dbSession); FlowImpl flow = (FlowImpl)dbSession.Load(typeof(FlowImpl), flowId); StateImpl state = (StateImpl)flow.Node; // create an executionContext for easy attributeValue retrieval ExecutionContextImpl executionContext = new ExecutionContextImpl(null, flow, dbSession, organisationComponent); // create a convenient map from the attribute-names to the fields IList fields = fieldRepository.FindFieldsByState(state.Id, dbSession); IDictionary attributeValues = new Hashtable(); IEnumerator iter = fields.GetEnumerator(); while (iter.MoveNext()) { FieldImpl field = (FieldImpl)iter.Current; if (FieldAccessHelper.IsReadable(field.Access) || FieldAccessHelper.IsWritable(field.Access)) { // activity form contains only readable or writeable fields String attributeName = field.Attribute.Name; if (executionContext.GetAttribute(attributeName) != null) { // attribute might not exist (this will cause a warning already being logged previusly) attributeValues[attributeName] = executionContext.GetAttribute(attributeName); } } } activityForm = new ActivityFormImpl(flow, fields, attributeValues); return(activityForm); }
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 Object[] DelegateProcessInvocation(DelegationImpl delegation, ExecutionContextImpl executionContext) { Object[] invocationData = new Object[2]; try { IProcessInvocationHandler processInvoker = (IProcessInvocationHandler) delegation.GetDelegate(); log.Debug("requesting the attributeValues from the process invoker..."); executionContext.SetConfiguration(ParseConfiguration(delegation)); invocationData[0] = processInvoker.GetStartTransitionName(executionContext); invocationData[1] = processInvoker.GetStartAttributeValues(executionContext); log.Debug("process invoker specified transition '" + invocationData[0] + "' and supplied attributeValues '" + invocationData[1] + "'"); } catch (Exception t) { HandleException(delegation, executionContext, t); } return invocationData; }
public void ProcessDecision(DecisionImpl decision, ExecutionContextImpl executionContext,DbSession dbSession) { // trigger actions, scheduled before the decision actually is made delegationService.RunActionsForEvent(EventType.BEFORE_DECISION, decision.Id, executionContext,dbSession); // delegate the decision TransitionImpl selectedTransition = delegationHelper.DelegateDecision(decision.DecisionDelegation, executionContext); // process the selected transition ProcessTransition(selectedTransition, executionContext,dbSession); // trigger actions, scheduled after the decision is made delegationService.RunActionsForEvent(EventType.AFTER_DECISION, decision.Id, executionContext,dbSession); }
public void SaveActivity(String authenticatedActorId, Int64 flowId, IDictionary attributeValues, DbSession dbSession, IOrganisationService organisationComponent) { // get the flow FlowImpl flow = (FlowImpl) dbSession.Load(typeof (FlowImpl), flowId); // create the execution-context ExecutionContextImpl executionContext = new ExecutionContextImpl(authenticatedActorId, flow, dbSession, organisationComponent); executionContext.StoreAttributeValues(attributeValues); }
public IActivityForm GetActivityForm(String authenticatedActorId, Int64 flowId, DbSession dbSession, IOrganisationService organisationComponent) { IActivityForm activityForm = null; // First check if the actor is allowed to get this form authorizationHelper.CheckGetActivityForm(authenticatedActorId, flowId, dbSession); FlowImpl flow = (FlowImpl) dbSession.Load(typeof (FlowImpl), flowId); StateImpl state = (StateImpl) flow.Node; // create an executionContext for easy attributeValue retrieval ExecutionContextImpl executionContext = new ExecutionContextImpl(null, flow, dbSession, organisationComponent); // create a convenient map from the attribute-names to the fields IList fields = fieldRepository.FindFieldsByState(state.Id,dbSession); IDictionary attributeValues = new Hashtable(); IEnumerator iter = fields.GetEnumerator(); while (iter.MoveNext()) { FieldImpl field = (FieldImpl) iter.Current; if (FieldAccessHelper.IsReadable(field.Access) || FieldAccessHelper.IsWritable(field.Access)) { // activity form contains only readable or writeable fields String attributeName = field.Attribute.Name; if (executionContext.GetAttribute(attributeName) != null) { // attribute might not exist (this will cause a warning already being logged previusly) attributeValues[attributeName] = executionContext.GetAttribute(attributeName); } } } activityForm = new ActivityFormImpl(flow, fields, attributeValues); return activityForm; }
public Object ResolveArgumentGroup(IActor resolvedActor, String[] parameters, ExecutionContextImpl executionContext) { log.Debug("resolvedActor inside resolveArgumentGroup: " + resolvedActor); if (resolvedActor == null) { if (parameters.Length != 1) throw new SystemException("argument group expects exactly one parameter instead of " + parameters.Length); String groupId = parameters[0]; IGroup group = null; try { group = executionContext.GetOrganisationComponent().FindGroupById(groupId); } catch (OrganisationRuntimeException e) { throw new SystemException("can't resolve group-argument with parameter " + groupId + " : " + e.Message); } return group; } else { if (parameters.Length != 1) throw new SystemException("argument group expects exactly one parameter (membership-type) instead of " + parameters.Length); IUser user = null; IGroup group = null; String membershipType = parameters[0]; try { group = executionContext.GetOrganisationComponent().FindGroupByMembership(resolvedActor.Id, membershipType); } catch (InvalidCastException e) { throw new SystemException("can't resolve group-argument : a group must be calculated from a User, not a " + resolvedActor.GetType().FullName, e); } catch (OrganisationRuntimeException e) { throw new SystemException("can't resolve group-argument : can't find the hierarchy-memberschip of User " + user.Id + " and membership-type " + membershipType + " : " + e.Message, e); } return group; } }
private void HandleException(DelegationImpl delegation, ExecutionContextImpl executionContext, Exception exception) { log.Debug("handling delegation exception :", exception); String exceptionClassName = exception.GetType().FullName; String delegationClassName = delegation.ClassName; ExceptionHandlingType exceptionHandlingType = delegation.ExceptionHandlingType; if (exceptionHandlingType != 0) { if (exceptionHandlingType == ExceptionHandlingType.IGNORE) { log.Debug("ignoring '" + exceptionClassName + "' in delegation '" + delegationClassName + "' : " + exception.Message); } else if (exceptionHandlingType == ExceptionHandlingType.LOG) { log.Debug("logging '" + exceptionClassName + "' in delegation '" + delegationClassName + "' : " + exception.Message); executionContext.AddLogDetail(new ExceptionReportImpl(exception)); } else if (exceptionHandlingType == ExceptionHandlingType.ROLLBACK) { log.Debug("rolling back for '" + exceptionClassName + "' in delegation '" + delegationClassName + "' : " + exception.Message); throw new SystemException("rolling back for '" + exceptionClassName + "' in delegation '" + delegationClassName + "' : " + exception.Message); } else { throw new SystemException("unknown exception handler '" + exceptionHandlingType + "' : " + exception.Message); } } else { log.Debug("'" + exceptionClassName + "' in delegation '" + delegationClassName + "' : " + exception.Message); executionContext.AddLogDetail(new ExceptionReportImpl(exception)); } }
public bool DelegateJoin(DelegationImpl delegation, ExecutionContextImpl executionContext) { bool reactivateParent = false; try { IJoinHandler joiner = (IJoinHandler) delegation.GetDelegate(); executionContext.SetConfiguration(ParseConfiguration(delegation)); reactivateParent = joiner.Join(executionContext); } catch (Exception t) { HandleException(delegation, executionContext, t); } return reactivateParent; }
public Object ResolveArgumentProcessInitiator(IActor resolvedActor, String[] parameters, ExecutionContextImpl executionContext) { return executionContext.GetProcessInstance().GetInitiator(); }
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 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 ProcessJoin(JoinImpl join, ExecutionContextImpl executionContext,DbSession dbSession) { // First set the state of the flow to finished FlowImpl joiningFlow = (FlowImpl) executionContext.GetFlow(); joiningFlow.End = DateTime.Now; joiningFlow.ActorId = null; joiningFlow.Node = join; // setting the node is not necessary if this method is called // from processTransition, but it is necessary if this method is // called from cancelFlow in the component-impl. // if parent-reactivation of the flow is true, this means that the parent-flow // not yet has been reactivated. In that case we have to see if it needs to be // reactivated. In the other case (parent-reactivation is false) we don't // need to do anything because this means that the parent-flow was already // reactivated before. if (!false.Equals(joiningFlow.ParentReactivation)) { // check if the parent needs to be reactivated bool parentReactivation = false; IList concurrentFlows = executionContext.GetOtherActiveConcurrentFlows(); if (concurrentFlows.Count == 0) { // if no concurrent flows are present any more, reactivation is forced parentReactivation = true; } else { // if other concurrent flows are present, the decision to reactivate is left // to the join-delegation (if there is one specified) DelegationImpl joinDelegation = join.JoinDelegation; // if no joinDelegation was specified, parentReactivation remains false // so the behaviour is like an and-join. (=sunchronizing merge) if (joinDelegation != null) { parentReactivation = delegationHelper.DelegateJoin(join.JoinDelegation, executionContext); } } if (parentReactivation) { // make sure the other concurrent flows will not reactivate the // parent again IEnumerator iter = concurrentFlows.GetEnumerator(); while (iter.MoveNext()) { //UPGRADE_TODO: Methode "java.util.Iterator.next" wurde in 'IEnumerator.Current' konvertiert und weist ein anderes Verhalten auf. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1073_javautilIteratornext"' FlowImpl concurrentFlow = (FlowImpl) iter.Current; concurrentFlow.ParentReactivation = false; } // reactivate the parent by first setting the parentflow into the executionContext FlowImpl parentFlow = (FlowImpl) joiningFlow.Parent; executionContext.SetFlow(parentFlow); // and then process the (single, checked at process-archive-parsing-time) leaving transition. ISet leavingTransitions = join.LeavingTransitions; iter = leavingTransitions.GetEnumerator(); if (iter.MoveNext()) { TransitionImpl leavingTransition = (TransitionImpl) iter.Current; ProcessTransition(leavingTransition, executionContext,dbSession); } else { // no transition throw exception? } } } }
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 Object[] DelegateProcessTermination(DelegationImpl delegation, ExecutionContextImpl executionContext) { Object[] completionData = new Object[2]; try { IProcessInvocationHandler processInvoker = (IProcessInvocationHandler) delegation.GetDelegate(); log.Debug("collecting results from the sub-process..."); executionContext.SetConfiguration(ParseConfiguration(delegation)); completionData[0] = processInvoker.CollectResults(executionContext); completionData[1] = processInvoker.GetCompletionTransitionName(executionContext); } catch (Exception t) { HandleException(delegation, executionContext, t); } return completionData; }
public void DelegateFork(DelegationImpl delegation, ExecutionContextImpl executionContext) { try { // delegate the fork IForkHandler forker = (IForkHandler) delegation.GetDelegate(); executionContext.SetConfiguration(ParseConfiguration(delegation)); forker.Fork(executionContext); } catch (Exception t) { HandleException(delegation, executionContext, t); } }
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 String DelegateAssignment(DelegationImpl delegation, ExecutionContextImpl executionContext) { String actorId = null; try { IAssignmentHandler assigner = (IAssignmentHandler) delegation.GetDelegate(); executionContext.SetConfiguration(ParseConfiguration(delegation)); actorId = assigner.SelectActor(executionContext); } catch (Exception t) { HandleException(delegation, executionContext, t); } return actorId; }
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 Object ResolveArgumentRole(IActor resolvedActor, String[] parameters, ExecutionContextImpl executionContext) { if (parameters.Length != 1) throw new SystemException("argument role expects exactly one parameter (role-name) instead of " + parameters.Length); IActor actor = null; if (resolvedActor == null) { try { actor = (IActor) executionContext.GetAttribute(parameters[0]); } catch (InvalidCastException e) { throw new SystemException("argument attribute(" + parameters[0] + ") does not contain an actor : " + executionContext.GetAttribute(parameters[0]).GetType().FullName, e); } } else { String roleName = parameters[0].Trim(); try { IList users = executionContext.GetOrganisationComponent().FindUsersByGroupAndRole(resolvedActor.Id, roleName); if (users.Count < 1) throw new SystemException("no users have role " + roleName + " for group " + resolvedActor.Id); actor = (IUser) users[0]; // TODO : create a new group if more then one user is returned on the query... } catch (InvalidCastException e) { throw new SystemException("can't resolve role-argument : a role must be calculated from a Group, not a " + resolvedActor.GetType().FullName, e); } catch (OrganisationRuntimeException e) { throw new SystemException("can't resolve role-argument : can't find the users that perform role " + roleName + " for group " + resolvedActor.Id + " : " + e.Message); } } return actor; }
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 Object ResolveArgumentActor(IActor resolvedActor, String[] parameters, ExecutionContextImpl executionContext) { if (parameters.Length != 1) throw new SystemException("argument actor expects exactly one (the actor-id) parameter instead of " + parameters.Length); IActor actor = null; try { actor = executionContext.GetOrganisationComponent().FindActorById(parameters[0]); } catch (OrganisationRuntimeException e) { throw new SystemException("can't resolve actor-argument with parameter " + parameters[0], e); } return actor; }
public Object ResolveArgumentParentGroup(IActor resolvedActor, String[] parameters, ExecutionContextImpl executionContext) { if (parameters.Length != 0) throw new SystemException("argument parentGroup expects exactly zero parameters instead of " + parameters.Length); IGroup group = null; try { group = (IGroup) resolvedActor; group = group.Parent; } catch (InvalidCastException e) { throw new SystemException("can't resolve parentGroup-argument : a role must be calculated from a Group, not a " + resolvedActor.GetType().FullName, e); } return group; }
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 long ExecuteTask(DbSession dbSession, IOrganisationSessionLocal organisationComponent) { long millisToWait = DEFAULT_INTERVAL; DateTime now = DateTime.Now; IEnumerator iter = dbSession.Iterate(queryFindJobsToBeExecuted, now, DbType.TIMESTAMP).GetEnumerator(); if (iter.MoveNext()) { JobImpl job = (JobImpl) iter.Current; try { log.Debug("executing activation '" + job.Id + "' scheduled for " + job.Date.ToString()); log.Debug("activation's flow-context is :" + job.Context); String userId = job.UserId; DelegationImpl actionDelegation = job.ActionDelegation; ExecutionContextImpl executionContext = new ExecutionContextImpl(userId, dbSession, organisationComponent); IFlow context = job.Context; if (context != null) { executionContext.SetFlow(context); executionContext.SetProcessInstance(context.ProcessInstance); executionContext.SetProcessDefinition(context.ProcessInstance.ProcessDefinition); } else { executionContext.SetProcessDefinition(job.ProcessDefinition); } delegationHelper.DelegateScheduledAction(actionDelegation, executionContext); } catch (Exception t) { log.Error("scheduler-exception : couldn't perform task : " + t.Message, t); } dbSession.Delete(job); dbSession.Flush(); if (iter.MoveNext()) { return 0; } } iter = dbSession.Iterate(queryFindJobsInTheFuture, now, DbType.TIMESTAMP).GetEnumerator(); if (iter.MoveNext()) { JobImpl activation = (JobImpl) iter.Current; long activationDate = activation.Date.Ticks; millisToWait = activationDate - now.Ticks; log.Debug("next activation is scheduled at " + activation.Date.ToString() + ", (in " + millisToWait + " millis)"); if (millisToWait < 0) millisToWait = 0; if (millisToWait > DEFAULT_INTERVAL) millisToWait = DEFAULT_INTERVAL; } return millisToWait; }
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 void ProcessJoin(JoinImpl join, ExecutionContextImpl executionContext, DbSession dbSession) { // First set the state of the flow to finished FlowImpl joiningFlow = (FlowImpl)executionContext.GetFlow(); joiningFlow.End = DateTime.Now; joiningFlow.ActorId = null; joiningFlow.Node = join; // setting the node is not necessary if this method is called // from processTransition, but it is necessary if this method is // called from cancelFlow in the component-impl. // if parent-reactivation of the flow is true, this means that the parent-flow // not yet has been reactivated. In that case we have to see if it needs to be // reactivated. In the other case (parent-reactivation is false) we don't // need to do anything because this means that the parent-flow was already // reactivated before. if (!false.Equals(joiningFlow.ParentReactivation)) { // check if the parent needs to be reactivated bool parentReactivation = false; IList concurrentFlows = executionContext.GetOtherActiveConcurrentFlows(); if (concurrentFlows.Count == 0) { // if no concurrent flows are present any more, reactivation is forced parentReactivation = true; } else { // if other concurrent flows are present, the decision to reactivate is left // to the join-delegation (if there is one specified) DelegationImpl joinDelegation = join.JoinDelegation; // if no joinDelegation was specified, parentReactivation remains false // so the behaviour is like an and-join. (=sunchronizing merge) if (joinDelegation != null) { parentReactivation = delegationHelper.DelegateJoin(join.JoinDelegation, executionContext); } } if (parentReactivation) { // make sure the other concurrent flows will not reactivate the // parent again IEnumerator iter = concurrentFlows.GetEnumerator(); while (iter.MoveNext()) { //UPGRADE_TODO: Methode "java.util.Iterator.next" wurde in 'IEnumerator.Current' konvertiert und weist ein anderes Verhalten auf. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1073_javautilIteratornext"' FlowImpl concurrentFlow = (FlowImpl)iter.Current; concurrentFlow.ParentReactivation = false; } // reactivate the parent by first setting the parentflow into the executionContext FlowImpl parentFlow = (FlowImpl)joiningFlow.Parent; executionContext.SetFlow(parentFlow); // and then process the (single, checked at process-archive-parsing-time) leaving transition. ISet leavingTransitions = join.LeavingTransitions; iter = leavingTransitions.GetEnumerator(); if (iter.MoveNext()) { TransitionImpl leavingTransition = (TransitionImpl)iter.Current; ProcessTransition(leavingTransition, executionContext, dbSession); } else { // no transition throw exception? } } } }
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 Object ResolveArgumentPreviousActor(IActor resolvedActor, String[] parameters, ExecutionContextImpl executionContext) { if (parameters.Length != 0) throw new SystemException("argument previousActor expects exactly zero parameters instead of " + parameters.Length); IActor actor = executionContext.GetPreviousActor(); if (actor == null) throw new SystemException("argument previousActor could not be resolve because there is no previous actor"); return actor; }