Example #1
0
        /* package private */

        internal virtual TransitionImpl GetTransition(String transitionName, INode node, DbSession dbSession)
        {
            TransitionImpl transition = null;

            if ((Object)transitionName != null)
            {
                Object[] values = new Object[] { transitionName, node.Id };
                IType[]  types  = new IType[] { DbType.STRING, DbType.LONG };
                transition = (TransitionImpl)dbSession.FindOne(queryFindTransitionByName, values, types);
            }
            else
            {
                if (node is IState)
                {
                    IState state = node as IState;
                    ISet   leavingTransitions = state.LeavingTransitions;
                    if (leavingTransitions.Count == 1)
                    {
                        IEnumerator transEnum = leavingTransitions.GetEnumerator();
                        transEnum.MoveNext();
                        transition = (TransitionImpl)transEnum.Current;
                    }
                    else
                    {
                        throw new SystemException("no transitionName was specified : this is only allowed if the state (" + state.Name + ") has exactly 1 leaving transition (" + leavingTransitions.Count + ")");
                    }
                }
            }
            return(transition);
        }
Example #2
0
        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("");
            }
        }
Example #3
0
        public IProcessInstance StartProcessInstance(long processDefinitionId, IDictionary attributeValues = null, string transitionName = null, Relations relations = null)
        {
            ProcessInstanceImpl  processInstance     = null;
            IOrganisationService organisationService = null;

            using (ISession session = NHibernateHelper.OpenSession())
            {
                using (var tran = session.BeginTransaction())
                {
                    DbSession             dbSession         = new DbSession(session);
                    ProcessDefinitionImpl processDefinition = myProcessDefinitionService.GetProcessDefinition(processDefinitionId, dbSession);
                    processInstance = new ProcessInstanceImpl(ActorId, processDefinition);
                    processInstanceRepository.Save(processInstance, dbSession);//到這裏應該存了ProcessInstance,RootFlow

                    ExecutionContext executionContext = new ExecutionContext();
                    //logRepository.CreateLog();
                    processDefinition.StartState.CheckAccess(attributeValues);

                    attributeService = new AttributeService((FlowImpl)processInstance.RootFlow, dbSession);
                    attributeService.StoreAttributeValue(attributeValues);//儲存傳入的欄位值
                    attributeService.StoreRole(organisationService.FindActorById(ActorId), (ActivityStateImpl)processDefinition.StartState);

                    //flow的node推進到下一關卡
                    //flow的actor=解析出來的actor.Id
                    transitionService = new TransitionService(ActorId, dbSession);
                    TransitionImpl transitionTo = transitionService.GetTransition(transitionName, processDefinition.StartState, dbSession);
                    transitionService.ProcessTransition(transitionTo, (FlowImpl)processInstance.RootFlow, dbSession);

                    session.Flush();
                    tran.Commit();
                }
            }

            return(processInstance);
        }
Example #4
0
        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);
        }
Example #5
0
        private void node(XmlElement nodeElement, NodeImpl node, ProcessBlockImpl processBlock)
        {
            node.ArrivingTransitions = new ListSet();
            node.LeavingTransitions  = new ListSet();

            IEnumerator iter = nodeElement.GetChildElements("transition").GetEnumerator();

            while (iter.MoveNext())
            {
                XmlElement     transitionElement = (XmlElement)iter.Current;
                TransitionImpl transition        = new TransitionImpl();
                transition.ProcessDefinition = ProcessDefinition;
                transition.From = node;
                if (node is JoinImpl)
                {
                    this.joinTransition(transitionElement, transition, processBlock);
                }
                else
                {
                    this.transition(transitionElement, transition, processBlock);
                }

                node.LeavingTransitions.Add(transition);
            }


            this.definitionObject(nodeElement, node, processBlock);

            //把所有的Node加到集合中
            this.addReferencableObject(node.Name, processBlock, typeof(INode), node);
        }
Example #6
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);
            }
        }
Example #7
0
 protected internal virtual void AssertSequenceFlowWayPoints(TransitionImpl sequenceFlow, params int[] waypoints)
 {
     Assert.AreEqual(waypoints.Length, sequenceFlow.Waypoints.Count);
     for (int i = 0; i < waypoints.Length; i++)
     {
         Assert.AreEqual(waypoints[i], sequenceFlow.Waypoints.ToList().ElementAt(i));
     }
 }
        public virtual ProcessDefinitionBuilder EndActivity()
        {
            ScopeStack.Pop();
            ProcessElement = ScopeStack.Peek();

            transition = null;

            return(this);
        }
Example #9
0
        public virtual ProcessDefinitionBuilder endActivity()
        {
            scopeStack.Pop();
            processElement = scopeStack.Peek();

            transition_Renamed = null;

            return(this);
        }
        public virtual ProcessDefinitionBuilder CreateActivity(string id)
        {
            var activity = (ActivityImpl)ScopeStack.Peek().CreateActivity(id);

            ScopeStack.Push(activity);
            ProcessElement = activity;

            transition = null;

            return(this);
        }
Example #11
0
        public virtual ProcessDefinitionBuilder createActivity(string id)
        {
            ActivityImpl activity = scopeStack.Peek().createActivity(id);

            scopeStack.Push(activity);
            processElement = activity;

            transition_Renamed = null;

            return(this);
        }
Example #12
0
        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?
                    }
                }
            }
        }
Example #13
0
        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));
        }
        public virtual ProcessDefinitionBuilder StartTransition(string destinationActivityId, string transitionId)
        {
            if (ReferenceEquals(destinationActivityId, null))
            {
                throw new PvmException("destinationActivityId is null");
            }
            var activity = Activity;

            transition = activity.CreateOutgoingTransition(transitionId);
            UnresolvedTransitions.Add(new object[] { transition, destinationActivityId });
            ProcessElement = transition;
            return(this);
        }
Example #15
0
        public virtual ProcessDefinitionBuilder startTransition(string destinationActivityId, string transitionId)
        {
            if (string.ReferenceEquals(destinationActivityId, null))
            {
                throw new PvmException("destinationActivityId is null");
            }
            ActivityImpl activity = Activity;

            transition_Renamed = activity.createOutgoingTransition(transitionId);
            unresolvedTransitions.Add(new object[] { transition_Renamed, destinationActivityId });
            processElement = transition_Renamed;
            return(this);
        }
Example #16
0
        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);
        }
Example #17
0
 public virtual PvmProcessDefinition buildProcessDefinition()
 {
     foreach (object[] unresolvedTransition in unresolvedTransitions)
     {
         TransitionImpl transition = (TransitionImpl)unresolvedTransition[0];
         string         destinationActivityName = (string)unresolvedTransition[1];
         ActivityImpl   destination             = processDefinition.findActivity(destinationActivityName);
         if (destination == null)
         {
             throw new Exception("destination '" + destinationActivityName + "' not found.  (referenced from transition in '" + transition.Source.Id + "')");
         }
         transition.setDestination(destination);
     }
     return(processDefinition);
 }
Example #18
0
        //private const String queryFindLeavingTransitionByName = "select t " +
        //    "from t in class NetBpm.Workflow.Definition.Impl.TransitionImpl, " +
        //    "     n in class NetBpm.Workflow.Definition.Impl.NodeImpl " +
        //    "where n.id = ? " +
        //    "  and t.From.id = n.id " +
        //    "  and t.Name = ? ";

        public void ForkFlow(String transitionName, IDictionary attributeValues)
        {
            // find the transition
            TransitionImpl transition = null;

            try
            {
                transition = transitionRepository.FindLeavingTransitionByName(_node.Id, transitionName, _dbSession);
            }
            catch (NotUniqueException e)
            {
                throw new SystemException("transition with name '" + transitionName + "' was not found for creating sub-flow on fork '" + _node.Name + "' : " + e.Message);
            }
            ForkFlow(transition, attributeValues);
        }
Example #19
0
        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);
        }
Example #20
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("");
            }
        }
Example #21
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));
        }
Example #22
0
        public IList PerformActivity(long flowId, IDictionary attributeValues = null, String transitionName = null, Relations relations = null)
        {
            if (string.IsNullOrEmpty(ActorId))
            {
                throw new AuthorizationException("you can't perform an activity because you are not authenticated");
            }

            IList flows = null;

            try
            {
                using (ISession session = NHibernateHelper.OpenSession())
                {
                    DbSession         dbSession     = new DbSession(session);
                    FlowImpl          flow          = flowRepository.GetFlow(flowId, dbSession);
                    ActivityStateImpl activityState = (ActivityStateImpl)flow.Node;

                    ExecutionContext executionContext = new ExecutionContext();
                    activityState.CheckAccess(attributeValues);

                    attributeService = new AttributeService(flow, dbSession);
                    attributeService.StoreAttributeValue(attributeValues);

                    transitionService = new TransitionService(ActorId, dbSession);
                    TransitionImpl transitionTo = transitionService.GetTransition(transitionName, activityState, dbSession);
                    transitionService.ProcessTransition(transitionTo, flow, dbSession);

                    session.Flush();
                }
            }
            catch (ExecutionException e)
            {
                throw e;
            }
            catch (Exception e)
            {
                throw new SystemException("uncaught exception : " + e.Message, e);
            }
            finally
            {
                //ServiceLocator.Instance.Release(organisationComponent);
            }
            return(flows);
        }
        protected internal virtual void UpdateAsyncAfterTargetConfiguration(
            AsyncContinuationJobHandler.AsyncContinuationConfiguration currentConfiguration)
        {
            var targetActivity      = (ActivityImpl)targetScope;
            var outgoingTransitions = (IList <IPvmTransition>)targetActivity.OutgoingTransitions;

            var targetConfiguration = new AsyncContinuationJobHandler.AsyncContinuationConfiguration();

            if (outgoingTransitions.Count == 0)
            {
                targetConfiguration.AtomicOperation = PvmAtomicOperationFields.ActivityEnd.CanonicalName;
            }
            else
            {
                targetConfiguration.AtomicOperation =
                    PvmAtomicOperationFields.TransitionNotifyListenerTake.CanonicalName;

                if (outgoingTransitions.Count == 1)
                {
                    targetConfiguration.TransitionId = outgoingTransitions[0].Id;
                }
                else
                {
                    TransitionImpl matchingTargetTransition = null;
                    var            currentTransitionId      = currentConfiguration.TransitionId;
                    if (!ReferenceEquals(currentTransitionId, null))
                    {
                        matchingTargetTransition = (TransitionImpl)targetActivity.FindOutgoingTransition(currentTransitionId);
                    }

                    if (matchingTargetTransition != null)
                    {
                        targetConfiguration.TransitionId = matchingTargetTransition.Id;
                    }
                    else
                    {
                        throw new ProcessEngineException("Cannot determine matching outgoing sequence flow");
                    }
                }
            }

            //jobEntity.JobHandlerConfiguration = targetConfiguration;
        }
        public virtual void TestExecutionEntitySerialization()
        {
            var execution = new ExecutionEntity();

            var activityImpl = new ActivityImpl("test", null);

            activityImpl.ExecutionListeners.Add("start", new List <IDelegateListener <IBaseDelegateExecution> > {
                new TestExecutionListener()
            });
            execution.Activity = activityImpl;

            var processDefinitionImpl = new ProcessDefinitionImpl("test");

            processDefinitionImpl.ExecutionListeners.Add("start",
                                                         new List <IDelegateListener <IBaseDelegateExecution> > {
                new TestExecutionListener()
            });
            execution.ProcessDefinition = processDefinitionImpl;

            var transitionImpl = new TransitionImpl("test", new ProcessDefinitionImpl("test"));

            transitionImpl.AddExecutionListener(new TestExecutionListener());
            execution.Transition = (transitionImpl);

            execution.ProcessInstanceStartContext.Initial = activityImpl;
            execution.SuperExecution = (new ExecutionEntity());

            execution.IsActive           = true;
            execution.Canceled           = false;
            execution.BusinessKey        = "myBusinessKey";
            execution.DeleteReason       = "no reason";
            execution.ActivityInstanceId = "123";
            execution.IsScope            = false;

            var data = WriteObject(execution);

            execution = (ExecutionEntity)ReadObject(data);

            Assert.AreEqual("myBusinessKey", execution.BusinessKey);
            Assert.AreEqual("no reason", execution.DeleteReason);
            Assert.AreEqual("123", execution.ActivityInstanceId);
        }
Example #25
0
        protected internal virtual void updateAsyncAfterTargetConfiguration(AsyncContinuationConfiguration currentConfiguration)
        {
            ActivityImpl          targetActivity      = (ActivityImpl)targetScope;
            IList <PvmTransition> outgoingTransitions = targetActivity.OutgoingTransitions;

            AsyncContinuationConfiguration targetConfiguration = new AsyncContinuationConfiguration();

            if (outgoingTransitions.Count == 0)
            {
                targetConfiguration.AtomicOperation = org.camunda.bpm.engine.impl.pvm.runtime.operation.PvmAtomicOperation_Fields.ACTIVITY_END.CanonicalName;
            }
            else
            {
                targetConfiguration.AtomicOperation = org.camunda.bpm.engine.impl.pvm.runtime.operation.PvmAtomicOperation_Fields.TRANSITION_NOTIFY_LISTENER_TAKE.CanonicalName;

                if (outgoingTransitions.Count == 1)
                {
                    targetConfiguration.TransitionId = outgoingTransitions[0].Id;
                }
                else
                {
                    TransitionImpl matchingTargetTransition = null;
                    string         currentTransitionId      = currentConfiguration.TransitionId;
                    if (!string.ReferenceEquals(currentTransitionId, null))
                    {
                        matchingTargetTransition = targetActivity.findOutgoingTransition(currentTransitionId);
                    }

                    if (matchingTargetTransition != null)
                    {
                        targetConfiguration.TransitionId = matchingTargetTransition.Id;
                    }
                    else
                    {
                        // should not happen since it is avoided by validation
                        throw new ProcessEngineException("Cannot determine matching outgoing sequence flow");
                    }
                }
            }

            jobEntity.JobHandlerConfiguration = targetConfiguration;
        }
Example #26
0
        public virtual void execute(AsyncContinuationConfiguration configuration, ExecutionEntity execution, CommandContext commandContext, string tenantId)
        {
            LegacyBehavior.repairMultiInstanceAsyncJob(execution);

            PvmAtomicOperation atomicOperation = findMatchingAtomicOperation(configuration.AtomicOperation);

            ensureNotNull("Cannot process job with configuration " + configuration, "atomicOperation", atomicOperation);

            // reset transition id.
            string transitionId = configuration.TransitionId;

            if (!string.ReferenceEquals(transitionId, null))
            {
                PvmActivity    activity   = execution.getActivity();
                TransitionImpl transition = (TransitionImpl)activity.findOutgoingTransition(transitionId);
                execution.Transition = transition;
            }

            Context.CommandInvocationContext.performOperation(atomicOperation, execution);
        }
Example #27
0
        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);
            }
        }
Example #28
0
        private void resolveReferences()
        {
            IEnumerator iter = unresolvedReferences.GetEnumerator();

            while (iter.MoveNext())
            {
                UnresolvedReference unresolvedReference = (UnresolvedReference)iter.Current;

                Object           referencingObject        = unresolvedReference.ReferencingObject;
                String           referenceDestinationName = unresolvedReference.DestinationName;
                ProcessBlockImpl scope    = unresolvedReference.DestinationScope;
                String           property = unresolvedReference.Property;

                Object referencedObject = FindInScope(unresolvedReference, unresolvedReference.DestinationScope);
                if (referencedObject == null)
                {
                    //AddError("failed to deploy process archive : couldn't resolve " + property + "=\"" + referenceDestinationName + "\" from " + referencingObject + " in scope " + scope);
                }
                else
                {
                    if (referencingObject is TransitionImpl)
                    {
                        if (property.Equals("to"))
                        {
                            TransitionImpl transition = (TransitionImpl)referencingObject;
                            transition.To = (NodeImpl)referencedObject;
                        }
                    }
                    if (referencingObject is FieldImpl)
                    {
                        if (property.Equals("attribute"))
                        {
                            FieldImpl field = (FieldImpl)referencingObject;
                            field.Attribute = (AttributeImpl)referencedObject;
                        }
                    }
                }
            }
        }
Example #29
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void testExecutionEntitySerialization() throws Exception
        public virtual void testExecutionEntitySerialization()
        {
            ExecutionEntity execution = new ExecutionEntity();

            ActivityImpl activityImpl = new ActivityImpl("test", null);

            activityImpl.ExecutionListeners["start"] = Collections.singletonList <ExecutionListener>(new TestExecutionListener());
            execution.setActivity(activityImpl);

            ProcessDefinitionImpl processDefinitionImpl = new ProcessDefinitionImpl("test");

            processDefinitionImpl.ExecutionListeners["start"] = Collections.singletonList <ExecutionListener>(new TestExecutionListener());
            execution.setProcessDefinition(processDefinitionImpl);

            TransitionImpl transitionImpl = new TransitionImpl("test", new ProcessDefinitionImpl("test"));

            transitionImpl.addExecutionListener(new TestExecutionListener());
            execution.Transition = transitionImpl;

            execution.ProcessInstanceStartContext.Initial = activityImpl;
            execution.setSuperExecution(new ExecutionEntity());

            execution.Active             = true;
            execution.Canceled           = false;
            execution.BusinessKey        = "myBusinessKey";
            execution.DeleteReason       = "no reason";
            execution.ActivityInstanceId = "123";
            execution.Scope = false;

            sbyte[] data = writeObject(execution);
            execution = (ExecutionEntity)readObject(data);

            assertEquals("myBusinessKey", execution.BusinessKey);
            assertEquals("no reason", execution.DeleteReason);
            assertEquals("123", execution.ActivityInstanceId);
        }
Example #30
0
        /// <summary>
        /// Join的Transition To會跳回上一層的ProcessBlock的Node
        /// </summary>
        /// <param name="transitionElement"></param>
        /// <param name="transition"></param>
        /// <param name="processBlock"></param>
        private void joinTransition(XmlElement transitionElement, TransitionImpl transition, ProcessBlockImpl processBlock)
        {
            this.definitionObject(transitionElement, transition, processBlock);

            this.addUnresolvedReference(transition, transitionElement.GetProperty("to"), processBlock.ParentBlock, "to", typeof(INode));
        }