/// <summary>
/// 创建下一步活动的节点
/// </summary>
/// <param name="transition">转移</param>
/// <param name="activity">活动</param>
/// <returns>下一步节点封装</returns>
internal static NextActivityComponent CreateNextActivityComponent(TransitionEntity transition,
ActivityEntity activity)
{
string name = string.Empty;
NextActivityComponent component = null;
if (XPDLHelper.IsSimpleComponentNode(activity.ActivityType) == true) //可流转简单类型节点
{
name = "单一节点";
component = new NextActivityItem(name, transition, activity);
}
else if (XPDLHelper.IsIntermediateEventComponentNode(activity.ActivityType) == true)
{
name = "跨事件节点";
component = new NextActivityIntermediate(name, transition, activity);
}
else if (XPDLHelper.IsGatewayComponentNode(activity.ActivityType) == true)
{
if (activity.GatewayDirectionType == GatewayDirectionEnum.AndSplit)
{
name = "必全选节点";
component = new NextActivityGateway(name, transition, activity);
}
else if (activity.GatewayDirectionType == GatewayDirectionEnum.AndSplitMI)
{
name = "并行多实例节点";
component = new NextActivityGateway(name, transition, activity);
}
else if (activity.GatewayDirectionType == GatewayDirectionEnum.OrSplit ||
activity.GatewayDirectionType == GatewayDirectionEnum.OrSplitMI ||
activity.GatewayDirectionType == GatewayDirectionEnum.XOrSplit)
{
name = "或多选节点";
component = new NextActivityGateway(name, transition, activity);
}
else
{
throw new WfXpdlException(string.Format("无法创建下一步节点列表，不明确的分支类型：{0}",
activity.GatewayDirectionType.ToString()));
}
}
else if (activity.ActivityType == ActivityTypeEnum.SubProcessNode)
{
name = "子流程节点";
component = new NextActivityItem(name, transition, activity);
}
else
{
throw new WfXpdlException(string.Format("无法创建下一步节点列表，不明确的节点类型：{0}",
activity.ActivityType.ToString()));
}
return(component);
}
/// <summary>
/// 创建下一步活动的节点
/// </summary>
/// <param name="transition">转移</param>
/// <param name="activity">活动</param>
/// <returns>下一步节点封装</returns>
internal static NextActivityComponent CreateNextActivityComponent(TransitionEntity transition,
ActivityEntity activity)
{
string name = string.Empty;
NextActivityComponent component = null;
if (XPDLHelper.IsSimpleComponentNode(activity.ActivityType) == true) //可流转简单类型节点
{
//单一节点
name = LocalizeHelper.GetEngineMessage("nextactivitycomponentfactory.singlenode");
component = new NextActivityItem(name, transition, activity);
}
else if (XPDLHelper.IsIntermediateEventComponentNode(activity.ActivityType) == true)
{
//跨事件节点
name = LocalizeHelper.GetEngineMessage("nextactivitycomponentfactory.intermediatenode");
component = new NextActivityIntermediate(name, transition, activity);
}
else if (XPDLHelper.IsGatewayComponentNode(activity.ActivityType) == true)
{
if (activity.GatewayDirectionType == GatewayDirectionEnum.AndSplit ||
activity.GatewayDirectionType == GatewayDirectionEnum.AndJoin)
{
//必全选节点
name = LocalizeHelper.GetEngineMessage("nextactivitycomponentfactory.mandatorycheckall");
}
else if (activity.GatewayDirectionType == GatewayDirectionEnum.AndSplitMI ||
activity.GatewayDirectionType == GatewayDirectionEnum.AndJoinMI)
{
//并行多实例节点
name = LocalizeHelper.GetEngineMessage("nextactivitycomponentfactory.parallelmultipleinstance");
}
else if (activity.GatewayDirectionType == GatewayDirectionEnum.OrSplit ||
activity.GatewayDirectionType == GatewayDirectionEnum.OrJoin)
{
//或多选节点
name = LocalizeHelper.GetEngineMessage("nextactivitycomponentfactory.orsplitorjoin");
}
else if (activity.GatewayDirectionType == GatewayDirectionEnum.XOrSplit ||
activity.GatewayDirectionType == GatewayDirectionEnum.XOrJoin)
{
//异或节点
name = LocalizeHelper.GetEngineMessage("nextactivitycomponentfactory.xor");
}
else if (activity.GatewayDirectionType == GatewayDirectionEnum.EOrJoin)
{
//增强合并多选节点
name = LocalizeHelper.GetEngineMessage("nextactivitycomponentfactory.eorjoin");
}
else
{
throw new WfXpdlException(LocalizeHelper.GetEngineMessage("nextactivitycomponentfactory.CreateNextActivityComponent.gateway.error",
activity.GatewayDirectionType.ToString()));
}
component = new NextActivityGateway(name, transition, activity);
}
else if (activity.ActivityType == ActivityTypeEnum.SubProcessNode)
{
//子流程节点
name = LocalizeHelper.GetEngineMessage("nextactivitycomponentfactory.subprocess");
component = new NextActivityItem(name, transition, activity);
}
else
{
throw new WfXpdlException(LocalizeHelper.GetEngineMessage("nextactivitycomponentfactory.CreateNextActivityComponent.error",
activity.ActivityType.ToString()));
}
return(component);
}
/// <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()))
);
}
}
}
/// <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()))
);
}
}
}