Esempio n. 1
0
        /// <summary>
        /// 递归执行节点
        /// 1)创建普通节点的任务
        /// 2)创建会签节点的任务
        /// </summary>
        /// <param name="fromActivity">起始活动</param>
        /// <param name="fromActivityInstance">起始活动实例</param>
        /// <param name="isJumpforward">是否跳跃</param>
        /// <param name="root">根节点</param>
        /// <param name="conditionKeyValuePair">条件key-value</param>
        protected void ContinueForwardCurrentNodeRecurisivly(ActivityEntity fromActivity,
                                                             ActivityInstanceEntity fromActivityInstance,
                                                             NextActivityComponent root,
                                                             IDictionary <string, string> conditionKeyValuePair,
                                                             Boolean isJumpforward)
        {
            foreach (NextActivityComponent comp in root)
            {
                if (comp.HasChildren)
                {
                    //此节点类型为分支或合并节点类型:首先需要实例化当前节点(自动完成)
                    NodeMediatorGateway gatewayNodeMediator = NodeMediatorGatewayFactory.CreateGatewayNodeMediator(comp.Activity,
                                                                                                                   this.ActivityForwardContext.ProcessModel,
                                                                                                                   Session);

                    ICompleteAutomaticlly autoGateway   = (ICompleteAutomaticlly)gatewayNodeMediator;
                    GatewayExecutedResult gatewayResult = autoGateway.CompleteAutomaticlly(
                        ActivityForwardContext.ProcessInstance,
                        comp.Transition.TransitionGUID,
                        fromActivityInstance,
                        ActivityForwardContext.ActivityResource,
                        Session);

                    if (gatewayResult.Status == GatewayExecutedStatus.Successed)
                    {
                        //遍历后续子节点
                        ContinueForwardCurrentNodeRecurisivly(fromActivity,
                                                              gatewayNodeMediator.GatewayActivityInstance,
                                                              comp,
                                                              conditionKeyValuePair,
                                                              isJumpforward);
                    }
                    else
                    {
                        WfRuntimeException e = new WfRuntimeException("第一个满足条件的节点已经被成功执行,此后的节点被阻止在XOrJoin节点!");
                        LogManager.RecordLog("递归执行节点方法异常", LogEventType.Exception, LogPriority.Normal, null, e);
                    }
                }
                else if (comp.Activity.ActivityType == ActivityTypeEnum.TaskNode)                   //普通任务节点
                {
                    //此节点类型为任务节点:根据fromActivityInstance的类型判断是否可以创建任务
                    if (fromActivityInstance.ActivityState == (short)ActivityStateEnum.Completed)
                    {
                        //创建新任务节点
                        NodeMediator taskNodeMediator = new NodeMediatorTask(Session);
                        taskNodeMediator.CreateActivityTaskTransitionInstance(comp.Activity,
                                                                              ActivityForwardContext.ProcessInstance,
                                                                              fromActivityInstance,
                                                                              comp.Transition.TransitionGUID,
                                                                              comp.Transition.DirectionType == TransitionDirectionTypeEnum.Loop ?
                                                                              TransitionTypeEnum.Loop : TransitionTypeEnum.Forward, //根据Direction方向确定是否是自身循环
                                                                              isJumpforward == true ?
                                                                              TransitionFlyingTypeEnum.ForwardFlying : TransitionFlyingTypeEnum.NotFlying,
                                                                              ActivityForwardContext.ActivityResource,
                                                                              Session);
                    }
                    else
                    {
                        //下一步的任务节点没有创建,需给出提示信息
                        if ((fromActivity.GatewayDirectionType | GatewayDirectionEnum.AllJoinType)
                            == GatewayDirectionEnum.AllJoinType)
                        {
                            WfRuntimeException e = new WfRuntimeException("等待其它需要合并的分支!");
                            LogManager.RecordLog("递归执行节点方法异常", LogEventType.Exception, LogPriority.Normal, null, e);
                        }
                    }
                }
                else if (comp.Activity.ActivityType == ActivityTypeEnum.SubProcessNode)         //子流程节点
                {
                    //节点类型为subprocessnode
                    if (fromActivityInstance.ActivityState == (short)ActivityStateEnum.Completed)
                    {
                        //实例化subprocess节点数据
                        NodeMediator subNodeMediator = new NodeMediatorSubProcess(Session);
                        subNodeMediator.CreateActivityTaskTransitionInstance(comp.Activity,
                                                                             ActivityForwardContext.ProcessInstance,
                                                                             fromActivityInstance,
                                                                             comp.Transition.TransitionGUID,
                                                                             comp.Transition.DirectionType == TransitionDirectionTypeEnum.Loop ?
                                                                             TransitionTypeEnum.Loop : TransitionTypeEnum.Forward,
                                                                             TransitionFlyingTypeEnum.NotFlying,
                                                                             ActivityForwardContext.ActivityResource,
                                                                             Session);
                    }
                }
                else if (comp.Activity.ActivityType == ActivityTypeEnum.EndNode)        //结束节点
                {
                    //此节点为完成结束节点,结束流程
                    NodeMediator endMediator = new NodeMediatorEnd(ActivityForwardContext, Session);
                    endMediator.Linker.ToActivity = comp.Activity;

                    //创建结束节点实例及转移数据
                    endMediator.CreateActivityTaskTransitionInstance(comp.Activity, ActivityForwardContext.ProcessInstance,
                                                                     fromActivityInstance, comp.Transition.TransitionGUID, TransitionTypeEnum.Forward,
                                                                     TransitionFlyingTypeEnum.NotFlying,
                                                                     ActivityForwardContext.ActivityResource,
                                                                     Session);

                    //执行结束节点中的业务逻辑
                    endMediator.ExecuteWorkItem();
                }
                else
                {
                    WfRuntimeException e = new WfRuntimeException(string.Format("XML文件定义了未知的节点类型,执行失败,节点类型信息:{0}",
                                                                                comp.Activity.ActivityType.ToString()));
                    LogManager.RecordLog("递归执行节点方法异常", LogEventType.Exception, LogPriority.Normal, null, e);
                }
            }
        }
Esempio n. 2
0
        /// <summary>
        /// 递归执行节点
        /// 1)创建普通节点的任务
        /// 2)创建会签节点的任务
        /// </summary>
        /// <param name="fromActivity">起始活动</param>
        /// <param name="fromActivityInstance">起始活动实例</param>
        /// <param name="isNotParsedForward">是否跳跃</param>
        /// <param name="root">根节点</param>
        /// <param name="conditionKeyValuePair">条件key-value</param>
        /// <param name="mediatorResult">执行结果的返回列表</param>
        protected void ContinueForwardCurrentNodeRecurisivly(ActivityEntity fromActivity,
                                                             ActivityInstanceEntity fromActivityInstance,
                                                             NextActivityComponent root,
                                                             IDictionary <string, string> conditionKeyValuePair,
                                                             Boolean isNotParsedForward,
                                                             ref List <WfNodeMediatedResult> mediatorResult)
        {
            foreach (NextActivityComponent comp in root)
            {
                if (comp.HasChildren)
                {
                    NodeAutoExecutedResult nodeExecutedResult = null;
                    if (XPDLHelper.IsGatewayComponentNode(comp.Activity.ActivityType) == true)
                    {
                        //此节点类型为任务节点:根据fromActivityInstance的类型判断是否可以创建任务
                        if (fromActivityInstance.ActivityState == (short)ActivityStateEnum.Completed)
                        {
                            //此节点类型为分支或合并节点类型:首先需要实例化当前节点(自动完成)
                            NodeMediatorGateway gatewayNodeMediator = NodeMediatorFactory.CreateNodeMediatorGateway(comp.Activity,
                                                                                                                    this.ActivityForwardContext.ProcessModel,
                                                                                                                    Session);

                            ICompleteAutomaticlly autoGateway = (ICompleteAutomaticlly)gatewayNodeMediator;
                            nodeExecutedResult = autoGateway.CompleteAutomaticlly(ActivityForwardContext.ProcessInstance,
                                                                                  comp.Transition.TransitionGUID,
                                                                                  fromActivity,
                                                                                  fromActivityInstance,
                                                                                  ActivityForwardContext.ActivityResource.AppRunner,
                                                                                  Session);

                            if (nodeExecutedResult.Status == NodeAutoExecutedStatus.Successed)
                            {
                                //遍历后续子节点
                                ContinueForwardCurrentNodeRecurisivly(gatewayNodeMediator.GatewayActivity,
                                                                      gatewayNodeMediator.GatewayActivityInstance,
                                                                      comp,
                                                                      conditionKeyValuePair,
                                                                      isNotParsedForward,
                                                                      ref mediatorResult);
                            }
                            else
                            {
                                mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                                       WfNodeMediatedFeedback.OrJoinOneBranchHasBeenFinishedWaittingOthers));
                                LogManager.RecordLog("递归执行节点方法异常",
                                                     LogEventType.Exception,
                                                     LogPriority.Normal,
                                                     null,
                                                     new WfRuntimeException(
                                                         string.Format("第一个满足条件的节点已经被成功执行,此后的节点被阻止在OrJoin类型的节点! 详细状态类型:{0}", nodeExecutedResult.Status.ToString())
                                                         ));
                            }
                        }
                        else
                        {
                            //下一步的任务节点没有创建,需给出提示信息
                            if (IsWaitingOneOfJoin(fromActivity.GatewayDirectionType) == true)
                            {
                                mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                                       WfNodeMediatedFeedback.NeedOtherGatewayBranchesToJoin));
                                LogManager.RecordLog("递归执行节点方法异常",
                                                     LogEventType.Exception,
                                                     LogPriority.Normal,
                                                     null,
                                                     new WfRuntimeException("等待其它需要合并的分支!"));
                            }
                            else
                            {
                                mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                                       WfNodeMediatedFeedback.OtherUnknownReasonToDebug));
                                LogManager.RecordLog("递归执行节点方法异常",
                                                     LogEventType.Exception,
                                                     LogPriority.Normal,
                                                     null,
                                                     new WfRuntimeException("等待其它需要合并的分支或发生其它类型的异常!"));
                            }
                        }
                    }
                    else if (XPDLHelper.IsIntermediateEventComponentNode(comp.Activity.ActivityType) == true)
                    {
                        //中间事件类型节点,调用外部业务逻辑,然后流程继续向下流转
                        NodeMediatorEvent eventNodeMediator = NodeMediatorFactory.CreateNodeMediatorEvent(ActivityForwardContext,
                                                                                                          comp.Activity,
                                                                                                          this.ActivityForwardContext.ProcessModel,
                                                                                                          Session);
                        eventNodeMediator.ExecuteWorkItem();

                        ICompleteAutomaticlly autoEvent = (ICompleteAutomaticlly)eventNodeMediator;
                        nodeExecutedResult = autoEvent.CompleteAutomaticlly(ActivityForwardContext.ProcessInstance,
                                                                            comp.Transition.TransitionGUID,
                                                                            fromActivity,
                                                                            fromActivityInstance,
                                                                            ActivityForwardContext.ActivityResource.AppRunner,
                                                                            Session);

                        if (nodeExecutedResult.Status == NodeAutoExecutedStatus.Successed)
                        {
                            //遍历后续子节点
                            ContinueForwardCurrentNodeRecurisivly(eventNodeMediator.EventActivity,
                                                                  eventNodeMediator.EventActivityInstance,
                                                                  comp,
                                                                  conditionKeyValuePair,
                                                                  isNotParsedForward,
                                                                  ref mediatorResult);
                        }
                        else
                        {
                            mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                                   WfNodeMediatedFeedback.IntermediateEventFailed));
                            LogManager.RecordLog("中间事件节点执行方法异常",
                                                 LogEventType.Exception,
                                                 LogPriority.Normal,
                                                 null,
                                                 new WfRuntimeException(nodeExecutedResult.Status.ToString()));
                        }
                    }
                    else
                    {
                        mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                               WfNodeMediatedFeedback.UnknownNodeTypeToWatch));
                        LogManager.RecordLog("递归执行节点方法异常",
                                             LogEventType.Exception,
                                             LogPriority.Normal,
                                             null,
                                             new WfRuntimeException(string.Format("XML文件定义了未知的节点类型,执行失败,节点类型信息:{0}",
                                                                                  comp.Activity.ActivityType.ToString()))
                                             );
                    }
                }
                else if (comp.Activity.ActivityType == ActivityTypeEnum.TaskNode)                   //普通任务节点
                {
                    //此节点类型为任务节点:根据fromActivityInstance的类型判断是否可以创建任务
                    if (fromActivityInstance.ActivityState == (short)ActivityStateEnum.Completed)
                    {
                        //创建新任务节点
                        NodeMediator taskNodeMediator = new NodeMediatorTask(Session);
                        taskNodeMediator.CreateActivityTaskTransitionInstance(comp.Activity,
                                                                              ActivityForwardContext.ProcessInstance,
                                                                              fromActivityInstance,
                                                                              comp.Transition.TransitionGUID,
                                                                              comp.Transition.DirectionType == TransitionDirectionTypeEnum.Loop ?
                                                                              TransitionTypeEnum.Loop : TransitionTypeEnum.Forward, //根据Direction方向确定是否是自身循环
                                                                              isNotParsedForward == true ?
                                                                              TransitionFlyingTypeEnum.ForwardFlying : TransitionFlyingTypeEnum.NotFlying,
                                                                              ActivityForwardContext.ActivityResource,
                                                                              Session);
                    }
                    else
                    {
                        //下一步的任务节点没有创建,需给出提示信息
                        if (IsWaitingOneOfJoin(fromActivity.GatewayDirectionType) == true)
                        {
                            mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                                   WfNodeMediatedFeedback.NeedOtherGatewayBranchesToJoin));
                            LogManager.RecordLog("递归执行节点方法异常",
                                                 LogEventType.Exception,
                                                 LogPriority.Normal,
                                                 null,
                                                 new WfRuntimeException("等待其它需要合并的分支!"));
                        }
                        else
                        {
                            mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                                   WfNodeMediatedFeedback.OtherUnknownReasonToDebug));
                            LogManager.RecordLog("递归执行节点方法异常",
                                                 LogEventType.Exception,
                                                 LogPriority.Normal,
                                                 null,
                                                 new WfRuntimeException("等待其它需要合并的分支或发生其它类型的异常!"));
                        }
                    }
                }
                else if (comp.Activity.ActivityType == ActivityTypeEnum.MultipleInstanceNode)       //多实例会签节点
                {
                    //此节点类型为任务节点:根据fromActivityInstance的类型判断是否可以创建任务
                    if (fromActivityInstance.ActivityState == (short)ActivityStateEnum.Completed)
                    {
                        //创建新多实例节点
                        NodeMediator mediatorMICreator = new NodeMediatorMICreator(Session);
                        mediatorMICreator.CreateActivityTaskTransitionInstance(comp.Activity,
                                                                               ActivityForwardContext.ProcessInstance,
                                                                               fromActivityInstance,
                                                                               comp.Transition.TransitionGUID,
                                                                               comp.Transition.DirectionType == TransitionDirectionTypeEnum.Loop ?
                                                                               TransitionTypeEnum.Loop : TransitionTypeEnum.Forward, //根据Direction方向确定是否是自身循环
                                                                               isNotParsedForward == true ?
                                                                               TransitionFlyingTypeEnum.ForwardFlying : TransitionFlyingTypeEnum.NotFlying,
                                                                               ActivityForwardContext.ActivityResource,
                                                                               Session);
                    }
                    else
                    {
                        //下一步的任务节点没有创建,需给出提示信息
                        if (IsWaitingOneOfJoin(fromActivity.GatewayDirectionType) == true)
                        {
                            mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                                   WfNodeMediatedFeedback.NeedOtherGatewayBranchesToJoin));
                            LogManager.RecordLog("递归执行节点方法异常",
                                                 LogEventType.Exception,
                                                 LogPriority.Normal,
                                                 null,
                                                 new WfRuntimeException("等待其它需要合并的分支!"));
                        }
                        else
                        {
                            mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                                   WfNodeMediatedFeedback.OtherUnknownReasonToDebug));
                            LogManager.RecordLog("递归执行节点方法异常",
                                                 LogEventType.Exception,
                                                 LogPriority.Normal,
                                                 null,
                                                 new WfRuntimeException("等待其它需要合并的分支或发生其它类型的异常!"));
                        }
                    }
                }
                else if (comp.Activity.ActivityType == ActivityTypeEnum.SubProcessNode)         //子流程节点
                {
                    //节点类型为subprocessnode
                    if (fromActivityInstance.ActivityState == (short)ActivityStateEnum.Completed)
                    {
                        //实例化subprocess节点数据
                        NodeMediator subNodeMediator = new NodeMediatorSubProcess(Session);
                        subNodeMediator.CreateActivityTaskTransitionInstance(comp.Activity,
                                                                             ActivityForwardContext.ProcessInstance,
                                                                             fromActivityInstance,
                                                                             comp.Transition.TransitionGUID,
                                                                             comp.Transition.DirectionType == TransitionDirectionTypeEnum.Loop ?
                                                                             TransitionTypeEnum.Loop : TransitionTypeEnum.Forward,
                                                                             TransitionFlyingTypeEnum.NotFlying,
                                                                             ActivityForwardContext.ActivityResource,
                                                                             Session);
                    }
                }
                else if (comp.Activity.ActivityType == ActivityTypeEnum.EndNode)        //结束节点
                {
                    if (fromActivityInstance.ActivityState == (short)ActivityStateEnum.Completed)
                    {
                        //此节点为完成结束节点,结束流程
                        NodeMediator endMediator = new NodeMediatorEnd(ActivityForwardContext, Session);
                        endMediator.Linker.ToActivity = comp.Activity;

                        //创建结束节点实例及转移数据
                        endMediator.CreateActivityTaskTransitionInstance(comp.Activity, ActivityForwardContext.ProcessInstance,
                                                                         fromActivityInstance, comp.Transition.TransitionGUID, TransitionTypeEnum.Forward,
                                                                         TransitionFlyingTypeEnum.NotFlying,
                                                                         ActivityForwardContext.ActivityResource,
                                                                         Session);

                        //执行结束节点中的业务逻辑
                        endMediator.ExecuteWorkItem();
                    }
                    else
                    {
                        //结束节点没有创建,需给出提示信息
                        if (IsWaitingOneOfJoin(fromActivity.GatewayDirectionType) == true)
                        {
                            mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                                   WfNodeMediatedFeedback.NeedOtherGatewayBranchesToJoin));
                            LogManager.RecordLog("递归执行节点方法异常",
                                                 LogEventType.Exception,
                                                 LogPriority.Normal,
                                                 null,
                                                 new WfRuntimeException("等待其它需要合并的分支!"));
                        }
                        else
                        {
                            mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                                   WfNodeMediatedFeedback.OtherUnknownReasonToDebug));
                            LogManager.RecordLog("递归执行节点方法异常",
                                                 LogEventType.Exception,
                                                 LogPriority.Normal,
                                                 null,
                                                 new WfRuntimeException("等待其它需要合并的分支或发生其它类型的异常!"));
                        }
                    }
                }
                else
                {
                    mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                           WfNodeMediatedFeedback.UnknownNodeTypeToWatch));
                    LogManager.RecordLog("递归执行节点方法异常",
                                         LogEventType.Exception,
                                         LogPriority.Normal,
                                         null,
                                         new WfRuntimeException(string.Format("XML文件定义了未知的节点类型,执行失败,节点类型信息:{0}",
                                                                              comp.Activity.ActivityType.ToString()))
                                         );
                }
            }
        }
Esempio n. 3
0
        /// <summary>
        /// 递归执行节点
        /// 1)创建普通节点的任务
        /// 2)创建会签节点的任务
        /// </summary>
        /// <param name="fromActivity">起始活动</param>
        /// <param name="fromActivityInstance">起始活动实例</param>
        /// <param name="isNotParsedForward">是否跳跃</param>
        /// <param name="root">根节点</param>
        /// <param name="conditionKeyValuePair">条件key-value</param>
        /// <param name="mediatorResult">执行结果的返回列表</param>
        protected void ContinueForwardCurrentNodeRecurisivly(ActivityEntity fromActivity,
                                                             ActivityInstanceEntity fromActivityInstance,
                                                             NextActivityComponent root,
                                                             IDictionary <string, string> conditionKeyValuePair,
                                                             Boolean isNotParsedForward,
                                                             ref List <WfNodeMediatedResult> mediatorResult)
        {
            foreach (NextActivityComponent comp in root)
            {
                if (comp.HasChildren)
                {
                    NodeAutoExecutedResult nodeExecutedResult = null;
                    if (XPDLHelper.IsGatewayComponentNode(comp.Activity.ActivityType) == true)
                    {
                        //此节点类型为任务节点:根据fromActivityInstance的类型判断是否可以创建任务
                        if (fromActivityInstance.ActivityState == (short)ActivityStateEnum.Completed)
                        {
                            //此节点类型为分支或合并节点类型:首先需要实例化当前节点(自动完成)
                            NodeMediatorGateway gatewayNodeMediator = NodeMediatorFactory.CreateNodeMediatorGateway(comp.Activity,
                                                                                                                    this.ActivityForwardContext.ProcessModel,
                                                                                                                    Session);

                            ICompleteGatewayAutomaticlly autoGateway = (ICompleteGatewayAutomaticlly)gatewayNodeMediator;
                            nodeExecutedResult = autoGateway.CompleteAutomaticlly(ActivityForwardContext.ProcessInstance,
                                                                                  comp.Transition.TransitionGUID,
                                                                                  fromActivity,
                                                                                  fromActivityInstance,
                                                                                  ActivityForwardContext.ActivityResource.AppRunner,
                                                                                  Session);

                            if (nodeExecutedResult.Status == NodeAutoExecutedStatus.Successed)
                            {
                                //遍历后续子节点
                                ContinueForwardCurrentNodeRecurisivly(gatewayNodeMediator.GatewayActivity,
                                                                      gatewayNodeMediator.GatewayActivityInstance,
                                                                      comp,
                                                                      conditionKeyValuePair,
                                                                      isNotParsedForward,
                                                                      ref mediatorResult);
                            }
                            else
                            {
                                mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                                       WfNodeMediatedFeedback.OrJoinOneBranchHasBeenFinishedWaittingOthers));
                                LogManager.RecordLog("ContinueForwardCurrentNodeRecurisivlyExeception",
                                                     LogEventType.Exception,
                                                     LogPriority.Normal,
                                                     null,
                                                     new WfRuntimeException(
                                                         LocalizeHelper.GetEngineMessage("nodemediator.ContinueForwardCurrentNodeRecurisivly.warn"))
                                                     );
                            }
                        }
                        else
                        {
                            //下一步的任务节点没有创建,需给出提示信息
                            if (IsWaitingOneOfJoin(fromActivity.GatewayDirectionType) == true)
                            {
                                mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                                       WfNodeMediatedFeedback.NeedOtherGatewayBranchesToJoin));
                                LogManager.RecordLog("NodeMediator.ContinueForwardCurrentNodeRecurisivly.IsWaintingOneOfJoin.Exception",
                                                     LogEventType.Exception,
                                                     LogPriority.Normal,
                                                     null,
                                                     new WfRuntimeException(LocalizeHelper.GetEngineMessage("nodemediator.ContinueForwardCurrentNodeRecurisivly.waitingothers.warn"))
                                                     );
                            }
                            else
                            {
                                mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                                       WfNodeMediatedFeedback.OtherUnknownReasonToDebug));
                                LogManager.RecordLog("NodeMediator.ContinueForwardCurrentNodeRecurisivly.IsWaintingOneOfJoin.OtherUnknownReason.Exception",
                                                     LogEventType.Exception,
                                                     LogPriority.Normal,
                                                     null,
                                                     new WfRuntimeException(LocalizeHelper.GetEngineMessage("nodemediator.ContinueForwardCurrentNodeRecurisivly.otherreason.warn"))
                                                     );
                            }
                        }
                    }
                    else
                    {
                        mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                               WfNodeMediatedFeedback.UnknownNodeTypeToWatch));
                        LogManager.RecordLog("NodeMediator.UnknownType.Exception",
                                             LogEventType.Exception,
                                             LogPriority.Normal,
                                             null,
                                             new WfRuntimeException(LocalizeHelper.GetEngineMessage("nodemediator.ContinueForwardCurrentNodeRecurisivly.unknowntype.warn",
                                                                                                    comp.Activity.ActivityType.ToString()))
                                             );
                    }
                }
                else if (comp.Activity.ActivityType == ActivityTypeEnum.TaskNode)                   //普通任务节点
                {
                    //此节点类型为任务节点:根据fromActivityInstance的类型判断是否可以创建任务
                    if (fromActivityInstance.ActivityState == (short)ActivityStateEnum.Completed)
                    {
                        //创建新任务节点
                        NodeMediator taskNodeMediator = new NodeMediatorTask(Session);
                        taskNodeMediator.CreateActivityTaskTransitionInstance(comp.Activity,
                                                                              ActivityForwardContext.ProcessInstance,
                                                                              fromActivityInstance,
                                                                              comp.Transition.TransitionGUID,
                                                                              comp.Transition.DirectionType == TransitionDirectionTypeEnum.Loop ?
                                                                              TransitionTypeEnum.Loop : TransitionTypeEnum.Forward, //根据Direction方向确定是否是自身循环
                                                                              isNotParsedForward == true ?
                                                                              TransitionFlyingTypeEnum.ForwardFlying : TransitionFlyingTypeEnum.NotFlying,
                                                                              ActivityForwardContext.ActivityResource,
                                                                              Session);
                    }
                    else
                    {
                        //下一步的任务节点没有创建,需给出提示信息
                        if (IsWaitingOneOfJoin(fromActivity.GatewayDirectionType) == true)
                        {
                            mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                                   WfNodeMediatedFeedback.NeedOtherGatewayBranchesToJoin));
                            LogManager.RecordLog("NodeMediator.TaskNode.NeedOtherGatewayBranchesToJoin.Exception",
                                                 LogEventType.Exception,
                                                 LogPriority.Normal,
                                                 null,
                                                 new WfRuntimeException(LocalizeHelper.GetEngineMessage("nodemediator.ContinueForwardCurrentNodeRecurisivly.waitingothers.warn"))
                                                 );
                        }
                        else
                        {
                            mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                                   WfNodeMediatedFeedback.OtherUnknownReasonToDebug));
                            LogManager.RecordLog("NodeMediator.TaskNode.NeedOtherGatewayBranchesToJoin.OtherUnkownReaseon.Exception",
                                                 LogEventType.Exception,
                                                 LogPriority.Normal,
                                                 null,
                                                 new WfRuntimeException(LocalizeHelper.GetEngineMessage("nodemediator.ContinueForwardCurrentNodeRecurisivly.otherreason.warn"))
                                                 );
                        }
                    }
                }
                else if (comp.Activity.ActivityType == ActivityTypeEnum.SubProcessNode)         //子流程节点
                {
                    //节点类型为subprocessnode
                    if (fromActivityInstance.ActivityState == (short)ActivityStateEnum.Completed)
                    {
                        //实例化subprocess节点数据
                        NodeMediator subNodeMediator = new NodeMediatorSubProcess(Session);
                        subNodeMediator.CreateActivityTaskTransitionInstance(comp.Activity,
                                                                             ActivityForwardContext.ProcessInstance,
                                                                             fromActivityInstance,
                                                                             comp.Transition.TransitionGUID,
                                                                             comp.Transition.DirectionType == TransitionDirectionTypeEnum.Loop ?
                                                                             TransitionTypeEnum.Loop : TransitionTypeEnum.Forward,
                                                                             TransitionFlyingTypeEnum.NotFlying,
                                                                             ActivityForwardContext.ActivityResource,
                                                                             Session);
                    }
                }
                else if (comp.Activity.ActivityType == ActivityTypeEnum.EndNode)        //结束节点
                {
                    if (fromActivityInstance.ActivityState == (short)ActivityStateEnum.Completed)
                    {
                        //此节点为完成结束节点,结束流程
                        var endMediator = NodeMediatorFactory.CreateNodeMediatorEnd(ActivityForwardContext, comp.Activity, Session);
                        endMediator.Linker.ToActivity = comp.Activity;

                        //创建结束节点实例及转移数据
                        endMediator.CreateActivityTaskTransitionInstance(comp.Activity, ActivityForwardContext.ProcessInstance,
                                                                         fromActivityInstance, comp.Transition.TransitionGUID, TransitionTypeEnum.Forward,
                                                                         TransitionFlyingTypeEnum.NotFlying,
                                                                         ActivityForwardContext.ActivityResource,
                                                                         Session);

                        //执行结束节点中的业务逻辑
                        endMediator.ExecuteWorkItem();
                    }
                    else
                    {
                        //结束节点没有创建,需给出提示信息
                        if (IsWaitingOneOfJoin(fromActivity.GatewayDirectionType) == true)
                        {
                            mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                                   WfNodeMediatedFeedback.NeedOtherGatewayBranchesToJoin));
                            LogManager.RecordLog("NodeMediator.EndNode.NeedOtherGatewayBranchesToJoin.Exception",
                                                 LogEventType.Exception,
                                                 LogPriority.Normal,
                                                 null,
                                                 new WfRuntimeException(LocalizeHelper.GetEngineMessage("nodemediator.ContinueForwardCurrentNodeRecurisivly.waitingothers.warn"))
                                                 );
                        }
                        else
                        {
                            mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                                   WfNodeMediatedFeedback.OtherUnknownReasonToDebug));
                            LogManager.RecordLog("NodeMediator.EndNode.NeedOtherGatewayBranchesToJoin.OtherUnkownReaseon.Exception",
                                                 LogEventType.Exception,
                                                 LogPriority.Normal,
                                                 null,
                                                 new WfRuntimeException(LocalizeHelper.GetEngineMessage("nodemediator.ContinueForwardCurrentNodeRecurisivly.otherreason.warn"))
                                                 );
                        }
                    }
                }
                else
                {
                    mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
                                           WfNodeMediatedFeedback.UnknownNodeTypeToWatch));
                    LogManager.RecordLog("NodeMediator.UnkonwNodeType.Exception",
                                         LogEventType.Exception,
                                         LogPriority.Normal,
                                         null,
                                         new WfRuntimeException(LocalizeHelper.GetEngineMessage("nodemediator.ContinueForwardCurrentNodeRecurisivly.unknowntype.warn",
                                                                                                comp.Activity.ActivityType.ToString()))
                                         );
                }
            }
        }
Esempio n. 4
0
        /// <summary>
        /// 递归执行节点
        /// </summary>
        /// <param name="root"></param>
        /// <param name="fromNode"></param>
        /// <param name="conditionKeyValuePair"></param>
        protected void ContinueForwardCurrentNodeRecurisivly(ActivityEntity fromActivity,
            ActivityInstanceEntity fromActivityInstance,
            NextActivityComponent root,
            IDictionary<string, string> conditionKeyValuePair,
            Boolean isJumpforward)
        {
            foreach (NextActivityComponent comp in root)
            {
                if (comp.HasChildren)
                {
                    //此节点类型为分支或合并节点类型:首先需要实例化当前节点(自动完成)
                    NodeMediatorGateway gatewayNodeMediator = NodeMediatorGatewayFactory.CreateGatewayNodeMediator(comp.Activity,
                        ProcessModel, Session);

                    ICompleteAutomaticlly autoGateway = (ICompleteAutomaticlly)gatewayNodeMediator;
                    GatewayExecutedResult gatewayResult = autoGateway.CompleteAutomaticlly(
                        ActivityForwardContext.ProcessInstance,
                        comp.Transition.TransitionGUID,
                        fromActivityInstance,
                        ActivityForwardContext.ActivityResource,
                        Session);

                    if (gatewayResult.Status == GatewayExecutedStatus.Successed)
                    {
                        //遍历后续子节点
                        ContinueForwardCurrentNodeRecurisivly(fromActivity,
                            gatewayNodeMediator.GatewayActivityInstance,
                            comp,
                            conditionKeyValuePair,
                            isJumpforward);
                    }
                    else
                    {
                        WfRuntimeException e = new WfRuntimeException("第一个满足条件的节点已经被成功执行,此后的节点被阻止在XOrJoin节点!");
                        LogManager.RecordLog("递归执行节点方法异常", LogEventType.Exception, LogPriority.Normal, null, e);
                    }
                }
                else if (comp.Activity.IsSimpleWorkItem)
                {
                    //此节点类型为任务节点:根据fromActivityInstance的类型判断是否可以创建任务
                    if (fromActivityInstance.ActivityState == (short)ActivityStateEnum.Completed)
                    {
                        //创建新任务节点
                        NodeMediator taskNodeMediator = new NodeMediatorTask(Session);
                        taskNodeMediator.CreateActivityTaskTransitionInstance(comp.Activity,
                            ActivityForwardContext.ProcessInstance,
                            fromActivityInstance,
                            comp.Transition.TransitionGUID,
                            comp.Transition.DirectionType == TransitionDirectionTypeEnum.Loop ?
                                TransitionTypeEnum.Loop : TransitionTypeEnum.Forward, //根据Direction方向确定是否是自身循环
                            isJumpforward == true ?
                                TransitionFlyingTypeEnum.ForwardFlying : TransitionFlyingTypeEnum.NotFlying,
                            ActivityForwardContext.ActivityResource,
                            Session);
                    }
                    else
                    {
                        //下一步的任务节点没有创建,需给出提示信息
                        if ((fromActivity.GatewayDirectionType | GatewayDirectionEnum.AllJoinType)
                            == GatewayDirectionEnum.AllJoinType)
                        {
                            WfRuntimeException e = new WfRuntimeException("等待其它需要合并的分支!");
                            LogManager.RecordLog("递归执行节点方法异常", LogEventType.Exception, LogPriority.Normal, null, e);
                        }
                    }
                }
                else if (comp.Activity.ActivityType == ActivityTypeEnum.SubProcessNode)
                {
                    //节点类型为subprocessnode
                    if (fromActivityInstance.ActivityState == (short)ActivityStateEnum.Completed)
                    {
                        //实例化subprocess节点数据
                        NodeMediator subNodeMediator = new NodeMediatorSubProcess(Session);
                        subNodeMediator.CreateActivityTaskTransitionInstance(comp.Activity,
                            ActivityForwardContext.ProcessInstance,
                            fromActivityInstance,
                            comp.Transition.TransitionGUID,
                            comp.Transition.DirectionType == TransitionDirectionTypeEnum.Loop ?
                                TransitionTypeEnum.Loop : TransitionTypeEnum.Forward,
                            TransitionFlyingTypeEnum.NotFlying,
                            ActivityForwardContext.ActivityResource,
                            Session);
                    }
                }
                else if (comp.Activity.ActivityType == ActivityTypeEnum.EndNode)
                {
                    //此节点为完成结束节点,结束流程
                    var endMediator = new NodeMediatorEnd(ActivityForwardContext, Session);
                    endMediator.Linker.ToActivity = comp.Activity;
                    endMediator.CompleteAutomaticlly(ActivityForwardContext.ProcessInstance,
                        comp.Transition.TransitionGUID,
                        fromActivityInstance,
                        ActivityForwardContext.ActivityResource,
                        Session);
                }
                else
                {
                    WfRuntimeException e = new WfRuntimeException(string.Format("XML文件定义了未知的节点类型,执行失败,节点类型信息:{0}",
                        comp.Activity.ActivityType.ToString()));
                    LogManager.RecordLog("递归执行节点方法异常", LogEventType.Exception, LogPriority.Normal, null, e);
                }
            }
        }