コード例 #1
0
        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);
            }
        }
コード例 #2
0
ファイル: _AttributeRepository.cs プロジェクト: ephebe/netbpm
        public AttributeInstanceImpl FindAttributeInstanceInScope(String attributeName, FlowImpl scope,DbSession dbSession)
        {
            AttributeInstanceImpl attributeInstance = null;

            while (attributeInstance == null)
            {
                IList attributes = this.FindAttributeInstanceByName(attributeName, scope.Id, dbSession);
                IEnumerator iter = attributes.GetEnumerator();
                if (iter.MoveNext())
                {
                    attributeInstance = (AttributeInstanceImpl)iter.Current;
                    if (iter.MoveNext())
                    {
                        throw new NetBpm.Util.DB.DbException("duplicate value");
                    }
                }
                else
                {
                    if (!scope.IsRootFlow())
                    {
                        scope = (FlowImpl)scope.Parent;
                    }
                    else
                    {
                        log.Warn("couldn't find attribute-instance '" + attributeName + "' in scope of flow '" + scope + "'");
                        break;
                    }
                }
            }
            return attributeInstance;
        }
コード例 #3
0
        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);
        }
コード例 #4
0
        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);
        }
コード例 #5
0
 public ExecutionContextImpl(String actorId, FlowImpl flow, DbSession dbSession, IOrganisationService organisationComponent)
 {
     this._actorId               = actorId;
     this._flow                  = flow;
     this._processInstance       = (ProcessInstanceImpl)flow.ProcessInstance;
     this._processDefinition     = (ProcessDefinitionImpl)_processInstance.ProcessDefinition;
     this._dbSession             = dbSession;
     this._organisationComponent = organisationComponent;
     this._assignedFlows         = new ArrayList();
 }
コード例 #6
0
 public ActivityFormImpl(FlowImpl flow, IList fields, IDictionary attributeValues)
 {
     this._flow              = flow;
     this._processInstance   = flow.ProcessInstance;
     this._processDefinition = _processInstance.ProcessDefinition;
     this._activityState     = (IActivityState)flow.Node;
     this._fields            = fields;
     this._attributeValues   = attributeValues;
     InitTransitionNames(flow.Node);
 }
コード例 #7
0
 public ExecutionContextImpl(String actorId, FlowImpl flow, DbSession dbSession, IOrganisationService organisationComponent)
 {
     this._actorId = actorId;
     this._flow = flow;
     this._processInstance = (ProcessInstanceImpl) flow.ProcessInstance;
     this._processDefinition = (ProcessDefinitionImpl) _processInstance.ProcessDefinition;
     this._dbSession = dbSession;
     this._organisationComponent = organisationComponent;
     this._assignedFlows = new ArrayList();
 }
コード例 #8
0
ファイル: ActivityFormImpl.cs プロジェクト: qwinner/NetBPM
		public ActivityFormImpl(FlowImpl flow, IList fields, IDictionary attributeValues)
		{
			this._flow = flow;
			this._processInstance = flow.ProcessInstance;
			this._processDefinition = _processInstance.ProcessDefinition;
			this._activityState = (IActivityState) flow.Node;
			this._fields = fields;
			this._attributeValues = attributeValues;
			InitTransitionNames(flow.Node);
		}
コード例 #9
0
        private void CancelFlowRecursive(FlowImpl flow, DateTime now)
        {
            flow.End     = now;
            flow.ActorId = null;
            IEnumerator iter = flow.Children.GetEnumerator();

            while (iter.MoveNext())
            {
                CancelFlowRecursive((FlowImpl)iter.Current, now);
            }
        }
コード例 #10
0
ファイル: TransitionService.cs プロジェクト: ephebe/netbpm
        public ForkedFlow ForkFlow(TransitionImpl transition, FlowImpl parentFlow, IDictionary attributeValues)
        {
            // create the subflow
            FlowImpl subFlow = new FlowImpl(transition.Name, parentFlow, (ProcessBlockImpl)transition.From.ProcessBlock);
            parentFlow.Children.Add(subFlow);

            // save it
            //_dbSession.SaveOrUpdate(subFlow);

            // add the transition and the flow to the set of created sub-flows
            return new ForkedFlow(transition, subFlow);
        }
コード例 #11
0
 public FlowImpl(String name, FlowImpl parent, ProcessBlockImpl processBlock)
 {
     this._name                = name;
     this._start               = DateTime.Now;
     this._processInstance     = parent.ProcessInstance;
     this._subProcessInstances = null;
     this._parent              = parent;
     this._children            = null;
     this._logs                = new ListSet();
     this._parentReactivation  = true;
     CreateAttributeInstances(processBlock.Attributes);
 }
コード例 #12
0
ファイル: FlowImpl.cs プロジェクト: JackWangCUMT/netbpm
 public FlowImpl(String name, FlowImpl parent, ProcessBlockImpl processBlock)
 {
     this._name = name;
     this._start = DateTime.Now;
     this._processInstance = parent.ProcessInstance;
     this._subProcessInstances = null;
     this._parent = parent;
     this._children = null;
     this._logs = new ListSet();
     this._parentReactivation = true;
     CreateAttributeInstances(processBlock.Attributes);
 }
コード例 #13
0
ファイル: TransitionService.cs プロジェクト: ephebe/netbpm
        public void ProcessActivityState(ActivityStateImpl activityState, FlowImpl flow, DbSession dbSession)
        {
            String actorId = null;
            String role = activityState.ActorRoleName;

            DelegationImpl assignmentDelegation = activityState.AssignmentDelegation;

            if (assignmentDelegation != null)
            {
                var delegateParameters = activityState.AssignmentDelegation.ParseConfiguration();
                actorExpressionResolverService.CurrentScope = flow;
                actorExpressionResolverService.DbSession = dbSession;
                actorId = actorExpressionResolverService.ResolveArgument(delegateParameters["expression"].ToString()).Id;

                if ((Object)actorId == null)
                {
                    throw new SystemException("invalid process definition : assigner of activity-state '" + activityState.Name + "' returned null instead of a valid actorId");
                }
            }
            else
            {
                if ((Object)role != null)
                {
                    IActor actor = null;
                    var attr = attributeRepository.FindAttributeInstanceInScope(role, flow, dbSession);
                    if (attr != null)
                        actor = (IActor)attr.GetValue();

                    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);
        }
コード例 #14
0
        //@todo delete parameter organisationComponent
        public void DelegateActivity(String authenticatedActorId, Int64 flowId, String delegateActorId, DbSession dbSession, IOrganisationService organisationComponent)
        {
            // first check if the actor is allowed to delegate this activity
            authorizationHelper.CheckDelegateActivity(authenticatedActorId, flowId, delegateActorId, dbSession);

            // reassign the flow
            FlowImpl flow = (FlowImpl)dbSession.Load(typeof(FlowImpl), flowId);

            flow.ActorId = delegateActorId;

            // flush the updates to the db
            dbSession.Update(flow);
            dbSession.Flush();
        }
コード例 #15
0
        public IFlow GetFlow(String authenticatedActorId, Int64 flowId, Relations relations, DbSession dbSession)
        {
            // first check if the actor is allowed to get this flow
            authorizationHelper.CheckGetFlow(authenticatedActorId, flowId, dbSession);

            FlowImpl flow = null;

            flow = (FlowImpl)dbSession.Load(typeof(FlowImpl), flowId);

            if (relations != null)
            {
                relations.Resolve(flow);
            }

            return(flow);
        }
コード例 #16
0
        //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("");
            }
        }
コード例 #17
0
        public void ForkFlow(TransitionImpl transition, IDictionary attributeValues)
        {
            // create the subflow
            FlowImpl subFlow = new FlowImpl(transition.Name, _flow, (ProcessBlockImpl)_node.ProcessBlock);

            _flow.Children.Add(subFlow);

            // save it
            _dbSession.SaveOrUpdate(subFlow);

            // store the attributeValues
            this._flow = subFlow;
            StoreAttributeValues(attributeValues);
            this._flow = (FlowImpl)this._flow.Parent;

            // add the transition and the flow to the set of created sub-flows
            this._forkedFlows.Add(new ForkedFlow(transition, subFlow));
        }
コード例 #18
0
        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);
        }
コード例 #19
0
        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();
            }
        }
コード例 #20
0
        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);
            }
        }
コード例 #21
0
        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?
                    }
                }
            }
        }
コード例 #22
0
 public void SetFlow(IFlow flow)
 {
     this._flow = (FlowImpl) flow;
 }
コード例 #23
0
        public void ForkFlow(TransitionImpl transition, IDictionary attributeValues)
        {
            // create the subflow
            FlowImpl subFlow = new FlowImpl(transition.Name, _flow, (ProcessBlockImpl) _node.ProcessBlock);
            _flow.Children.Add(subFlow);

            // save it
            _dbSession.Save(subFlow);

            // store the attributeValues
            this._flow = subFlow;
            StoreAttributeValues(attributeValues);
            this._flow = (FlowImpl) this._flow.Parent;

            // add the transition and the flow to the set of created sub-flows
            this._forkedFlows.Add(new ForkedFlow(transition, subFlow));
        }
コード例 #24
0
ファイル: ForkedFlow.cs プロジェクト: qwinner/NetBPM
		public ForkedFlow(TransitionImpl transition, FlowImpl flow)
		{
			this._transition = transition;
			this._flow = flow;
		}
コード例 #25
0
 public void SetFlow(IFlow flow)
 {
     this._flow = (FlowImpl)flow;
 }
コード例 #26
0
ファイル: TransitionService.cs プロジェクト: ephebe/netbpm
 private void ProcessEndState(EndStateImpl endState, FlowImpl flow,DbSession dbSession)
 {
     flow.ActorId = null;
     flow.End = DateTime.Now;
     flow.Node = endState;
 }
コード例 #27
0
        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);
        }
コード例 #28
0
ファイル: TransitionService.cs プロジェクト: ephebe/netbpm
        public void ProcessTransition(TransitionImpl transition, FlowImpl flow, DbSession dbSession)
        {
            NodeImpl destination = (NodeImpl)transition.To;
            flow.Node = destination;

            if (destination is ActivityStateImpl)
            {
                ProcessActivityState((ActivityStateImpl)destination, flow, dbSession);
            }
            else if (destination is ProcessStateImpl)
            {
                //ProcessProcessState((ProcessStateImpl)destination, executionContext, dbSession);
            }
            else if (destination is DecisionImpl)
            {
                ProcessDecision((DecisionImpl)destination, flow, dbSession);
            }
            else if (destination is ForkImpl)
            {
                ProcessFork((ForkImpl)destination, flow, dbSession);
            }
            else if (destination is JoinImpl)
            {
                ProcessJoin((JoinImpl)destination, flow, dbSession);
            }
            else if (destination is EndStateImpl)
            {
                ProcessEndState((EndStateImpl)destination, flow,dbSession);
            }
            else
            {
                throw new SystemException("");
            }
        }
コード例 #29
0
ファイル: TransitionService.cs プロジェクト: ephebe/netbpm
        public void ProcessJoin(JoinImpl join, FlowImpl joiningFlow, DbSession dbSession)
        {
            joiningFlow.End = DateTime.Now;
            joiningFlow.ActorId = null;
            joiningFlow.Node = join;

            if (false != joiningFlow.ParentReactivation)
            {
                bool parentReactivation = false;
                IList concurrentFlows = flowRepository.GetOtherActiveConcurrentFlows(joiningFlow.Id, dbSession);
                if (concurrentFlows.Count == 0)
                {
                    parentReactivation = true;
                }
                else
                {

                    //DelegationImpl joinDelegation = join.JoinDelegation;

                    //if (joinDelegation != null)
                    //{
                    //    IJoinHandler joiner = (IJoinHandler)joinDelegation.GetDelegate();
                    //    IDictionary attributes = joinDelegation.ParseConfiguration();
                    //    parentReactivation = delegationHelper.DelegateJoin(join.JoinDelegation, executionContext);
                    //}
                }

                if (parentReactivation)
                {
                    IEnumerator iter = concurrentFlows.GetEnumerator();
                    while (iter.MoveNext())
                    {
                        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, parentFlow, dbSession);
                    }
                    else
                    {
                        // no transition throw exception?
                    }
                }
            }
        }
コード例 #30
0
        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();
        }
コード例 #31
0
ファイル: LogComponentImpl.cs プロジェクト: qwinner/NetBPM
		private void Resolve(FlowImpl flow, Relations relations, DbSession dbSession)
		{
			// resolve the flow 
			if (relations != null)
			{
				log.Debug("resolving relations : '" + relations + "' on flow '" + flow + "'");
				relations.Resolve(flow);
			}

			// resolve the flow-details 
			IEnumerator iter = flow.Logs.GetEnumerator();
			while (iter.MoveNext())
			{
				LogImpl logImpl = (LogImpl) iter.Current;
				IEnumerator detailsIter = logImpl.Details.GetEnumerator();
				while (detailsIter.MoveNext())
				{
					LogDetailImpl LogDetailImpl = (LogDetailImpl) detailsIter.Current;
					LogDetailImpl.Resolve(dbSession);
				}
			}

			// resolve the attribute values
			iter = flow.AttributeInstances.GetEnumerator();
			while (iter.MoveNext())
			{
				AttributeInstanceImpl attributeInstance = (AttributeInstanceImpl) iter.Current;
				log.Debug("resolving attribute instance : " + attributeInstance.GetValue());
			}

			// resolve the child-flows 
			iter = flow.Children.GetEnumerator();
			while (iter.MoveNext())
			{
				FlowImpl subFlow = (FlowImpl) iter.Current;
				Resolve(subFlow, relations, dbSession);
			}

			// resolve the sub-process-flows 
			IProcessInstance subProcessInstance = flow.GetSubProcessInstance();
			if (subProcessInstance != null)
			{
				Resolve((FlowImpl) subProcessInstance.RootFlow, relations, dbSession);
			}
		}
コード例 #32
0
        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);
        }
コード例 #33
0
 private void CancelFlowRecursive(FlowImpl flow, DateTime now)
 {
     flow.End = now;
     flow.ActorId = null;
     IEnumerator iter = flow.Children.GetEnumerator();
     while (iter.MoveNext())
     {
         CancelFlowRecursive((FlowImpl) iter.Current, now);
     }
 }
コード例 #34
0
		public AttributeInstanceImpl(AttributeImpl attribute, FlowImpl scope)
		{
			this._valueText = attribute.InitialValue;
			this._attribute = attribute;
			this._scope = scope;
		}
コード例 #35
0
ファイル: TransitionService.cs プロジェクト: ephebe/netbpm
        public void ProcessDecision(DecisionImpl decision, FlowImpl flow, DbSession dbSession)
        {
            //var delegateParameters = delegationService.ParseConfiguration(decision.DecisionDelegation);

            //IDecisionHandler decisionHandler = (IDecisionHandler)delegationService.GetDelegate(decision.DecisionDelegation);
            var attributes = decision.DecisionDelegation.ParseConfiguration();
            string transiationName = new EvaluationDecision().Decide(attributes["attribute"].ToString());
            TransitionImpl selectedTransition = this.GetTransition(transiationName, decision, dbSession);
            //// delegate the decision
            //TransitionImpl selectedTransition = delegationHelper.DelegateDecision(decision.DecisionDelegation, executionContext);

            //// process the selected transition
            ProcessTransition(selectedTransition, flow, dbSession);
        }
コード例 #36
0
 public ForkedFlow(TransitionImpl transition, FlowImpl flow)
 {
     this._transition = transition;
     this._flow       = flow;
 }
コード例 #37
0
 public AttributeInstanceImpl(AttributeImpl attribute, FlowImpl scope)
 {
     this._valueText = attribute.InitialValue;
     this._attribute = attribute;
     this._scope     = scope;
 }
コード例 #38
0
ファイル: TransitionService.cs プロジェクト: ephebe/netbpm
        public void ProcessFork(ForkImpl fork, FlowImpl flow, DbSession dbSession)
        {
            // First initialize the children of the flow to be forked
            flow.Children = new ListSet();

            DelegationImpl delegation = fork.ForkDelegation;
            IList<ForkedFlow> forkedFlows = new List<ForkedFlow>();
            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;
                    forkedFlows.Add(this.ForkFlow(transition, flow,null));
                }
            }

            IEnumerator iter2 = forkedFlows.GetEnumerator();
            while (iter2.MoveNext())
            {
                ForkedFlow forkedFlow = (ForkedFlow)iter2.Current;
            }

            // loop over all flows that were forked in the ForkHandler implementation
            iter2 = forkedFlows.GetEnumerator();
            while (iter2.MoveNext())
            {
                ForkedFlow forkedFlow = (ForkedFlow)iter2.Current;

                ProcessTransition(forkedFlow.Transition, forkedFlow.Flow, dbSession);
            }
        }