/// <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);
}
}
}
/// <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()))
);
}
}
}
/// <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>
/// 递归执行节点
/// </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);
}
}
}