/// <summary>
/// 创建下一步活动的节点
/// </summary>
/// <param name="activity"></param>
/// <returns></returns>
internal static NextActivityComponent CreateNextActivityComponent(TransitionEntity transition,
ActivityEntity activity)
{
NextActivityComponent component = null;
if (activity.ActivityType == ActivityTypeEnum.TaskNode
|| activity.ActivityType == ActivityTypeEnum.EndNode)
{
string name = "单一节点";
component = new NextActivityItem(name, transition, activity);
}
else
{
string name = string.Empty;
if (activity.GatewayDirectionType == Slickflow.Engine.Common.GatewayDirectionEnum.AndSplit)
{
name = "必全选节点";
}
else
{
name = "或多选节点";
}
component = new NextActivityGateway(name, transition, activity);
}
return component;
}
/// <summary>
/// 创建活动实例的对象
/// </summary>
/// <param name="activity"></param>
/// <param name="processInstance"></param>
/// <returns></returns>
internal ActivityInstanceEntity CreateActivityInstanceObject(string appName,
string appInstanceID,
int processInstanceID,
ActivityEntity activity,
WfAppRunner runner)
{
ActivityInstanceEntity instance = new ActivityInstanceEntity();
instance.ActivityGUID = activity.ActivityGUID;
instance.ActivityName = activity.ActivityName;
instance.ActivityType = (short)activity.ActivityType;
instance.GatewayDirectionTypeID = (short)activity.GatewayDirectionType;
instance.ProcessGUID = activity.ProcessGUID;
instance.AppName = appName;
instance.AppInstanceID = appInstanceID;
instance.ProcessInstanceID = processInstanceID;
instance.TokensRequired = 1;
instance.TokensHad = 1;
instance.CreatedByUserID = runner.UserID;
instance.CreatedByUserName = runner.UserName;
instance.CreatedDateTime = System.DateTime.Now;
instance.ActivityState = (short)ActivityStateEnum.Ready;
instance.CanRenewInstance = 0;
return instance;
}
public NextActivityGateway(string name,
TransitionEntity transition,
ActivityEntity activity)
{
base.Name = name;
base.Transition = transition;
base.Activity = activity;
}
/// <summary>
/// 开始节点的构造执行上下文对象
/// </summary>
/// <param name="processModel"></param>
/// <param name="processInstance"></param>
/// <param name="activity"></param>
/// <param name="activityResource"></param>
private ActivityForwardContext(ProcessModel processModel,
ProcessInstanceEntity processInstance,
ActivityEntity activity,
ActivityResource activityResource)
{
ProcessModel = processModel;
ProcessInstance = processInstance;
Activity = activity;
ActivityResource = activityResource;
}
/// <summary>
/// 把子节点添加到网关路由节点，根据网关节点和子节点是否为空处理
/// </summary>
/// <param name="gatewayComponent"></param>
/// <param name="child"></param>
/// <param name="currentGatewayActivity"></param>
/// <returns></returns>
protected NextActivityComponent AddChildToGatewayComponent(TransitionEntity fromTransition,
ActivityEntity currentGatewayActivity,
NextActivityComponent gatewayComponent,
NextActivityComponent child)
{
if ((gatewayComponent == null) && (child != null))
gatewayComponent = NextActivityComponentFactory.CreateNextActivityComponent(fromTransition, currentGatewayActivity);
if ((gatewayComponent != null) && (child != null))
gatewayComponent.Add(child);
return gatewayComponent;
}
/// <summary>
/// 创建跳转节点(强制拉取跳转方式，后续节点状态可以强制拉取前置节点到当前节点[后续节点])
/// </summary>
/// <param name="fromActivity">要拉取的节点</param>
/// <param name="toActivity">拉取到节点</param>
/// <returns></returns>
internal static NextActivityComponent CreateNextActivityComponent(ActivityEntity fromActivity,
ActivityEntity toActivity)
{
NextActivityComponent component = null;
if (fromActivity.ActivityType == ActivityTypeEnum.TaskNode
|| fromActivity.ActivityType == ActivityTypeEnum.EndNode)
{
string name = "单一节点";
var transition = ProcessModel.CreateJumpforwardEmptyTransition(fromActivity, toActivity);
component = new NextActivityItem(name, transition, fromActivity); //强制拉取跳转类型的transition 为空类型
}
else
{
throw new ApplicationException(string.Format("不能跳转到其它非任务类型的节点！当前节点:{0}",
fromActivity.ActivityType));
}
return component;
}
internal static NodeMediatorGateway CreateGatewayNodeMediator(ActivityEntity gActivity,
ProcessModel processModel,
IDbSession session)
{
NodeMediatorGateway nodeMediator = null;
if (gActivity.ActivityType == ActivityTypeEnum.GatewayNode)
{
if (gActivity.GatewayDirectionType == GatewayDirectionEnum.AndSplit)
{
nodeMediator = new NodeMediatorAndSplit(gActivity, processModel, session);
}
else if (gActivity.GatewayDirectionType == GatewayDirectionEnum.OrSplit)
{
nodeMediator = new NodeMediatorOrSplit(gActivity, processModel, session);
}
else if (gActivity.GatewayDirectionType == GatewayDirectionEnum.XOrSplit)
{
nodeMediator = new NodeMediatorXOrSplit(gActivity, processModel, session);
}
else if (gActivity.GatewayDirectionType == GatewayDirectionEnum.AndJoin)
{
nodeMediator = new NodeMediatorAndJoin(gActivity, processModel, session);
}
else if (gActivity.GatewayDirectionType == GatewayDirectionEnum.OrJoin)
{
nodeMediator = new NodeMediatorOrJoin(gActivity, processModel, session);
}
else if (gActivity.GatewayDirectionType == GatewayDirectionEnum.XOrJoin)
{
nodeMediator = new NodeMediatorXOrJoin(gActivity, processModel, session);
}
else
{
throw new XmlDefinitionException(string.Format("不明确的节点分支Gateway类型！{0}", gActivity.GatewayDirectionType.ToString()));
}
}
else
{
throw new XmlDefinitionException(string.Format("不明确的节点类型！{0}", gActivity.ActivityType.ToString()));
}
return nodeMediator;
}
internal static NextActivityRouteResult CreateNextActivityRouteResult(ActivityEntity activity)
{
NextActivityRouteResult result;
if (activity.ActivityType == ActivityTypeEnum.GatewayNode)
{
if (activity.GatewayDirectionType == GatewayDirectionEnum.AndSplit)
{
result = new NextActivityRouteResult(NextActivityRouteChoiceEnum.MustAll);
}
else
{
result = new NextActivityRouteResult(NextActivityRouteChoiceEnum.OrMultiple);
}
result.GatewayActivity = activity;
}
else
{
result = new NextActivityRouteResult(NextActivityRouteChoiceEnum.Single);
result.NormalActivity = activity;
}
return result;
}
/// <summary>
/// 获取下一步节点列表
/// </summary>
/// <param name="processInstanceID"></param>
/// <param name="fromTransition"></param>
/// <param name="currentGatewayActivity"></param>
/// <param name="conditionKeyValuePair"></param>
/// <returns></returns>
internal override NextActivityComponent GetNextActivityListFromGateway(TransitionEntity fromTransition,
ActivityEntity currentGatewayActivity,
IDictionary<string, string> conditionKeyValuePair,
out NextActivityMatchedType resultType)
{
NextActivityComponent child = null;
NextActivityComponent gatewayComponent = null;
resultType = NextActivityMatchedType.Unknown;
//直接取出下步列表，运行时再根据条件执行
List<TransitionEntity> transitionList = base.ProcessModel.GetForwardTransitionList(currentGatewayActivity.ActivityGUID).ToList();
foreach (TransitionEntity transition in transitionList)
{
child = GetNextActivityListFromGatewayCore(transition,
conditionKeyValuePair,
out resultType);
gatewayComponent = AddChildToGatewayComponent(fromTransition, currentGatewayActivity, gatewayComponent, child);
}
return gatewayComponent;
}
/// <summary>
/// 根据网关类型获取下一步节点列表的抽象方法
/// </summary>
/// <param name="transition">转移</param>
/// <param name="activity">活动</param>
/// <param name="conditionKeyValuePair">条件kv对</param>
/// <param name="scheduleStatus">匹配类型</param>
/// <returns></returns>
internal abstract NextActivityComponent GetNextActivityListFromGateway(TransitionEntity transition,
ActivityEntity activity,
IDictionary <string, string> conditionKeyValuePair,
out NextActivityMatchedType scheduleStatus);
/// <summary>
/// 创建流程跳转上下文对象
/// </summary>
/// <param name="jumpforwardActivity"></param>
/// <param name="processModel"></param>
/// <param name="processInstance"></param>
/// <param name="activityResource"></param>
/// <returns></returns>
internal static ActivityForwardContext CreateJumpforwardContext(ActivityEntity jumpforwardActivity,
ProcessModel processModel,
ProcessInstanceEntity processInstance,
ActivityResource activityResource)
{
return new ActivityForwardContext(processModel, processInstance, jumpforwardActivity, activityResource);
}
/// <summary>
/// 启动流程的上下文对象
/// </summary>
/// <param name="processModel"></param>
/// <param name="processInstance"></param>
/// <param name="activity"></param>
/// <param name="activityResource"></param>
/// <returns></returns>
internal static ActivityForwardContext CreateStartupContext(ProcessModel processModel,
ProcessInstanceEntity processInstance,
ActivityEntity activity,
ActivityResource activityResource)
{
return new ActivityForwardContext(processModel, processInstance, activity, activityResource);
}
/// <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);
}
}
}
/// <summary>
/// 退回是会签情况下的处理：
/// 要退回的节点是会签节点
/// 1) 全部实例化会签节点下的多实例节点
/// 2) 只取得办理完成的节点，而且保证CompleteOrder的唯一性
/// </summary>
/// <param name="processInstance"></param>
/// <param name="originalBackwardToActivityInstance"></param>
/// <param name="backwardType"></param>
/// <param name="backSrcActivityInstanceID"></param>
/// <param name="activityResource"></param>
/// <param name="session"></param>
internal void CreateBackwardActivityTaskRepeatedSignTogetherMultipleInstance(ProcessInstanceEntity processInstance,
ActivityEntity backwardToTaskActvity,
ActivityInstanceEntity fromActivityInstance,
BackwardTypeEnum backwardType,
ActivityInstanceEntity previousMainInstance,
string transitionGUID,
TransitionTypeEnum transitionType,
TransitionFlyingTypeEnum flyingType,
ActivityResource activityResource,
IDbSession session)
{
//上一步节点是会签节点的退回处理
//需要重新实例化会签节点上的所有办理人的任务
//重新封装任务办理人为AssignedToUsers, AssignedToUsernames
var performerList = AntiGenerateActivityPerformerList(previousMainInstance);
activityResource.NextActivityPerformers.Clear();
activityResource.NextActivityPerformers = new Dictionary<string, PerformerList>();
activityResource.NextActivityPerformers.Add(backwardToTaskActvity.ActivityGUID, performerList);
//重新生成会签节点的多实例数据
CreateMultipleInstance(backwardToTaskActvity, processInstance, fromActivityInstance,
transitionGUID, transitionType, flyingType, activityResource, session);
}
internal NodeMediatorOrSplit(ActivityEntity activity, ProcessModel processModel, IDbSession session)
: base(activity, processModel, session)
{
}
internal NodeMediatorGateway(ActivityEntity gActivity, ProcessModel processModel, IDbSession session)
{
_gatewayActivity = gActivity;
_processModel = processModel;
_session = session;
}
internal override void CreateActivityTaskTransitionInstance(ActivityEntity toActivity,
ProcessInstanceEntity processInstance,
ActivityInstanceEntity fromActivityInstance,
string transitionGUID,
TransitionTypeEnum transitionType,
TransitionFlyingTypeEnum flyingType,
ActivityResource activityResource,
IDbSession session)
{
if (toActivity.ActivityTypeDetail.ComplexType == ComplexTypeEnum.SignTogether)
{
CreateMultipleInstance(toActivity, processInstance, fromActivityInstance,
transitionGUID, transitionType, flyingType, activityResource, session);
}
else
{
//实例化Activity
var toActivityInstance = CreateActivityInstanceObject(toActivity, processInstance, activityResource.AppRunner);
//进入运行状态
toActivityInstance.ActivityState = (short)ActivityStateEnum.Ready;
toActivityInstance.AssignedToUserIDs = GenerateActivityAssignedUserIDs(
activityResource.NextActivityPerformers[toActivity.ActivityGUID]);
toActivityInstance.AssignedToUserNames = GenerateActivityAssignedUserNames(
activityResource.NextActivityPerformers[toActivity.ActivityGUID]);
//插入活动实例数据
base.ActivityInstanceManager.Insert(toActivityInstance, session);
//插入任务数据
base.CreateNewTask(toActivityInstance, activityResource, session);
//插入转移数据
InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
transitionType,
flyingType,
activityResource.AppRunner,
session);
//启动子流程
WfExecutedResult startedResult = null;
var subProcessNode = (SubProcessNode)toActivity.Node;
subProcessNode.ActivityInstance = toActivityInstance;
WfAppRunner subRunner = CopyActivityForwardRunner(activityResource.AppRunner,
new Performer(activityResource.AppRunner.UserID,
activityResource.AppRunner.UserName),
subProcessNode);
var runtimeInstance = WfRuntimeManagerFactory.CreateRuntimeInstanceStartup(subRunner,
processInstance,
subProcessNode,
ref startedResult);
runtimeInstance.Execute(Session);
}
}
/// <summary>
/// 会签类型的主节点, 多实例节点处理
/// </summary>
/// <param name="processInstance"></param>
/// <param name="fromToTransition"></param>
/// <param name="fromActivityInstance"></param>
/// <param name="activityResource"></param>
/// <param name="session"></param>
internal void CreateMultipleInstance(ActivityEntity toActivity,
ProcessInstanceEntity processInstance,
ActivityInstanceEntity fromActivityInstance,
String transitionGUID,
TransitionTypeEnum transitionType,
TransitionFlyingTypeEnum flyingType,
ActivityResource activityResource,
IDbSession session)
{
//实例化主节点Activity
var toActivityInstance = CreateActivityInstanceObject(toActivity,
processInstance, activityResource.AppRunner);
//主节点实例数据
toActivityInstance.ActivityState = (short)ActivityStateEnum.Suspended;
toActivityInstance.ComplexType = (short)ComplexTypeEnum.SignTogether;
if (toActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Parallel)
{
toActivityInstance.CompleteOrder = toActivity.ActivityTypeDetail.CompleteOrder;
}
toActivityInstance.AssignedToUserIDs = GenerateActivityAssignedUserIDs(
activityResource.NextActivityPerformers[toActivity.ActivityGUID]);
//插入主节点实例数据
base.ActivityInstanceManager.Insert(toActivityInstance, session);
//插入主节点转移数据
InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
transitionType,
flyingType,
activityResource.AppRunner,
session);
//插入会签子节点实例数据
var plist = activityResource.NextActivityPerformers[toActivity.ActivityGUID];
ActivityInstanceEntity entity = new ActivityInstanceEntity();
for (short i = 0; i < plist.Count; i++)
{
entity = base.ActivityInstanceManager.CreateActivityInstanceObject(toActivityInstance);
entity.AssignedToUserIDs = plist[i].UserID;
entity.AssignedToUserNames = plist[i].UserName;
entity.MIHostActivityInstanceID = toActivityInstance.ID;
entity.CompleteOrder = (short)(i + 1);
//只有第一个节点处于运行状态，其它节点挂起
if ((i > 0) && (toActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Sequence))
{
entity.ActivityState = (short)ActivityStateEnum.Suspended;
}
//插入活动实例数据，并返回活动实例ID
entity.ID = base.ActivityInstanceManager.Insert(entity, session);
//插入任务数据
base.TaskManager.Insert(entity, plist[i], activityResource.AppRunner, session);
//启动子流程
IDbSession subSession = SessionFactory.CreateSession();
WfExecutedResult startedResult = null;
var subProcessNode = (SubProcessNode)toActivity.Node;
subProcessNode.ActivityInstance = entity; //在流程实例表中记录激活子流程的活动节点ID
WfAppRunner subRunner = CopyActivityForwardRunner(activityResource.AppRunner,
plist[i],
subProcessNode);
var runtimeInstance = WfRuntimeManagerFactory.CreateRuntimeInstanceStartup(subRunner,
processInstance,
subProcessNode,
ref startedResult);
if (runtimeInstance.WfExecutedResult.Status == WfExecutedStatus.Exception)
{
throw new WfRuntimeException(runtimeInstance.WfExecutedResult.Message);
}
runtimeInstance.Execute(subSession);
//如果是串行会签，只有第一个子流程可以运行，其它子流程处于挂起状态
if ((i > 0) && (toActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Sequence))
{
var startResult = (WfExecutedResult)runtimeInstance.WfExecutedResult;
base.ProcessInstanceManager.Suspend(startedResult.ProcessInstanceIDStarted, subRunner, subSession);
}
}
}
/// <summary>
/// 获取下一步节点列表
/// </summary>
/// <param name="processInstanceID"></param>
/// <param name="fromTransition"></param>
/// <param name="currentGatewayActivity"></param>
/// <param name="conditionKeyValuePair"></param>
/// <returns></returns>
internal override NextActivityComponent GetNextActivityListFromGateway(TransitionEntity fromTransition,
ActivityEntity currentGatewayActivity,
IDictionary<string, string> conditionKeyValuePair,
out NextActivityMatchedType resultType)
{
NextActivityComponent child = null;
NextActivityComponent gatewayComponent = null;
resultType = NextActivityMatchedType.Unknown;
var transitionList = this.ProcessModel.GetForwardTransitionList(currentGatewayActivity.ActivityGUID).ToList();
if (currentGatewayActivity.GatewayDirectionType == GatewayDirectionEnum.AndSplit)
{
//判读连线上的条件是否都满足，如果都满足才可以取出后续节点列表
bool isCheckedOk = base.ProcessModel.CheckAndSplitOccurrenceCondition(transitionList, conditionKeyValuePair);
if (isCheckedOk)
{
//获取AndSplit的每一条后续连线上的To节点
foreach (TransitionEntity transition in transitionList)
{
child = GetNextActivityListFromGatewayCore(transition,
conditionKeyValuePair,
out resultType);
gatewayComponent = AddChildToGatewayComponent(fromTransition, currentGatewayActivity, gatewayComponent, child);
}
}
if (gatewayComponent == null)
{
resultType = NextActivityMatchedType.WaitingForSplitting;
}
}
else if (currentGatewayActivity.GatewayDirectionType == GatewayDirectionEnum.OrSplit)
{
//获取OrSplit的，满足条件的后续连线上的To节点
foreach (TransitionEntity transition in transitionList)
{
bool isValidTransition = base.ProcessModel.IsValidTransition(transition, conditionKeyValuePair);
if (isValidTransition)
{
child = GetNextActivityListFromGatewayCore(transition,
conditionKeyValuePair,
out resultType);
gatewayComponent = AddChildToGatewayComponent(fromTransition, currentGatewayActivity, gatewayComponent, child);
}
if (gatewayComponent == null)
{
resultType = NextActivityMatchedType.NoneTransitionMatchedToSplit;
}
}
}
else if (currentGatewayActivity.GatewayDirectionType == GatewayDirectionEnum.XOrSplit)
{
//按连线定义的优先级排序
transitionList.Sort(new TransitionPriorityCompare());
//获取XOrSplit的，第一条满足条件的后续连线上的To节点
foreach (TransitionEntity transition in transitionList)
{
bool isValidTransitionXOr = base.ProcessModel.IsValidTransition(transition, conditionKeyValuePair);
if (isValidTransitionXOr)
{
child = GetNextActivityListFromGatewayCore(transition,
conditionKeyValuePair,
out resultType);
gatewayComponent = AddChildToGatewayComponent(fromTransition, currentGatewayActivity, gatewayComponent, child);
//退出循环
break;
}
}
if (gatewayComponent == null)
{
resultType = NextActivityMatchedType.NoneTransitionMatchedToSplit;
}
}
else if (currentGatewayActivity.GatewayDirectionType == GatewayDirectionEnum.ComplexSplit)
{
resultType = NextActivityMatchedType.Failed;
throw new Exception("ComplexSplit 没有具体实现！");
}
else
{
resultType = NextActivityMatchedType.Failed;
throw new Exception("Split 分支节点的类型不明确！");
}
return gatewayComponent;
}
/// <summary>
/// 根据网关类型获取下一步节点列表的抽象方法
/// </summary>
/// <param name="processInstanceID"></param>
/// <param name="transition"></param>
/// <param name="activity"></param>
/// <param name="conditionKeyValuePair"></param>
/// <returns></returns>
internal abstract NextActivityComponent GetNextActivityListFromGateway(TransitionEntity transition,
ActivityEntity activity,
IDictionary<string, string> conditionKeyValuePair,
out NextActivityMatchedType scheduleStatus);
/// <summary>
/// Convert XmlNode to Activity Entity
/// </summary>
/// <param name="node">Xml Node</param>
/// <param name="processGUID">ProcessGUID</param>
/// <returns>Activity Entity</returns>
public static ActivityEntity ConvertXmlActivityNodeToActivityEntity(XmlNode node, string processGUID)
{
ActivityEntity entity = new ActivityEntity();
entity.ActivityGUID = XMLHelper.GetXmlAttribute(node, "id");
entity.ActivityName = XMLHelper.GetXmlAttribute(node, "name");
entity.ActivityCode = XMLHelper.GetXmlAttribute(node, "code");
entity.ActivityUrl = XMLHelper.GetXmlAttribute(node, "url");
entity.ProcessGUID = processGUID;
//描述信息
XmlNode descNode = node.SelectSingleNode("Description");
entity.Description = (descNode != null) ? descNode.InnerText : string.Empty;
//节点类型信息
XmlNode typeNode = node.SelectSingleNode("ActivityType");
entity.ActivityType = (ActivityTypeEnum)Enum.Parse(typeof(ActivityTypeEnum), XMLHelper.GetXmlAttribute(typeNode, "type"));
entity.ActivityTypeDetail = ConvertXmlNodeToActivityTypeDetail(typeNode);
entity.WorkItemType = XPDLHelper.GetWorkItemType(entity.ActivityType);
if (entity.ActivityType == ActivityTypeEnum.SubProcessNode) //sub process node
{
//子流程节点
var subProcessNode = new SubProcessNode(entity);
var strSubType = XMLHelper.GetXmlAttribute(typeNode, "subType");
if (!string.IsNullOrEmpty(strSubType))
{
subProcessNode.SubProcessType = (SubProcessTypeEnum)Enum.Parse(typeof(SubProcessTypeEnum), strSubType);
subProcessNode.SubVarName = XMLHelper.GetXmlAttribute(typeNode, "subVar");
}
else
{
subProcessNode.SubProcessType = SubProcessTypeEnum.Fixed;
}
subProcessNode.SubProcessGUID = XMLHelper.GetXmlAttribute(typeNode, "subId");
entity.Node = subProcessNode;
}
else if (entity.ActivityType == ActivityTypeEnum.MultipleInstanceNode) //multiple instance node
{
var multipleInstanceNode = new MultipleInstanceNode(entity);
entity.Node = multipleInstanceNode;
}
//获取节点的操作列表
XmlNode actionsNode = node.SelectSingleNode("Actions");
if (actionsNode != null)
{
XmlNodeList xmlActionList = actionsNode.ChildNodes;
List <ActionEntity> actionList = new List <ActionEntity>();
foreach (XmlNode element in xmlActionList)
{
actionList.Add(ConvertXmlActionNodeToActionEntity(element));
}
entity.ActionList = actionList;
}
//获取节点的服务列表
XmlNode servicesNode = node.SelectSingleNode("Services");
if (servicesNode != null)
{
XmlNodeList xmlServiceList = servicesNode.ChildNodes;
List <ServiceEntity> serviceList = new List <ServiceEntity>();
foreach (XmlNode element in xmlServiceList)
{
serviceList.Add(ConvertXmlServiceNodeToServiceEntity(element));
}
entity.ServiceList = serviceList;
}
//获取节点边界列表
XmlNode boundariesNode = node.SelectSingleNode("Boundaries");
if (boundariesNode != null)
{
XmlNodeList xmlBoundaryList = boundariesNode.ChildNodes;
List <BoundaryEntity> boundaryList = new List <BoundaryEntity>();
foreach (XmlNode element in xmlBoundaryList)
{
boundaryList.Add(ConvertXmlBoundaryNodeToBoundaryEntity(element));
}
entity.BoundaryList = boundaryList;
}
//获取节点自定义章节信息
XmlNode sectionsNode = node.SelectSingleNode("Sections");
if (sectionsNode != null)
{
XmlNodeList xmlSectionList = sectionsNode.ChildNodes;
List <SectionEntity> sectionList = new List <SectionEntity>();
foreach (XmlNode element in xmlSectionList)
{
sectionList.Add(ConvertXmlSectionNodeToSectionEntity(element));
}
entity.SectionList = sectionList;
}
//节点的Split Join 类型
string gatewaySplitJoinType = XMLHelper.GetXmlAttribute(typeNode, "gatewaySplitJoinType");
if (!string.IsNullOrEmpty(gatewaySplitJoinType))
{
entity.GatewaySplitJoinType = (GatewaySplitJoinTypeEnum)Enum.Parse(typeof(GatewaySplitJoinTypeEnum), gatewaySplitJoinType);
}
string gatewayDirection = XMLHelper.GetXmlAttribute(typeNode, "gatewayDirection");
//节点的路由信息
if (!string.IsNullOrEmpty(gatewayDirection))
{
entity.GatewayDirectionType = (GatewayDirectionEnum)Enum.Parse(typeof(GatewayDirectionEnum), gatewayDirection);
}
string gatewayJoinPass = XMLHelper.GetXmlAttribute(typeNode, "gatewayJoinPass");
if (!string.IsNullOrEmpty(gatewayJoinPass))
{
entity.GatewayJoinPassType = EnumHelper.TryParseEnum <GatewayJoinPassEnum>(gatewayJoinPass);
}
return(entity);
}
/// <summary>
/// 会签类型的主节点, 多实例节点处理
/// </summary>
/// <param name="processInstance"></param>
/// <param name="fromToTransition"></param>
/// <param name="fromActivityInstance"></param>
/// <param name="activityResource"></param>
/// <param name="session"></param>
internal void CreateMultipleInstance(ActivityEntity toActivity,
ProcessInstanceEntity processInstance,
ActivityInstanceEntity fromActivityInstance,
String transitionGUID,
TransitionTypeEnum transitionType,
TransitionFlyingTypeEnum flyingType,
ActivityResource activityResource,
IDbSession session)
{
//实例化主节点Activity
var toActivityInstance = base.CreateActivityInstanceObject(toActivity,
processInstance, activityResource.AppRunner);
//主节点实例数据
toActivityInstance.ActivityState = (short)ActivityStateEnum.Suspended;
toActivityInstance.ComplexType = (short)ComplexTypeEnum.MultipleInstance;
if (toActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Parallel)
{
toActivityInstance.CompleteOrder = toActivity.ActivityTypeDetail.CompleteOrder;
}
toActivityInstance.AssignedToUsers = GenerateActivityAssignedUsers(
activityResource.NextActivityPerformers[toActivity.ActivityGUID]);
//插入主节点实例数据
base.ActivityInstanceManager.Insert(toActivityInstance, session);
//插入主节点转移数据
InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
transitionType,
flyingType,
activityResource.AppRunner,
session);
//插入会签子节点实例数据
var plist = activityResource.NextActivityPerformers[toActivity.ActivityGUID];
ActivityInstanceEntity entity = new ActivityInstanceEntity();
for (short i = 0; i < plist.Count; i++)
{
entity = base.ActivityInstanceManager.CreateActivityInstanceObject(toActivityInstance);
entity.AssignedToUsers = plist[i].UserID.ToString();
entity.MIHostActivityInstanceID = toActivityInstance.ID;
entity.CompleteOrder = (short)(i + 1);
//如果是串行会签，只有第一个节点处于运行状态，其它节点挂起
if ((i > 0) && (toActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Sequence))
{
entity.ActivityState = (short)ActivityStateEnum.Suspended;
}
//插入活动实例数据，并返回活动实例ID
entity.ID = base.ActivityInstanceManager.Insert(entity, session);
//插入任务数据
base.TaskManager.Insert(entity, plist[i], activityResource.AppRunner, session);
}
}
/// <summary>
/// 创建节点对象
/// </summary>
/// <param name="processInstance">流程实例</param>
protected ActivityInstanceEntity CreateActivityInstanceObject(ActivityEntity activity,
ProcessInstanceEntity processInstance,
WfAppRunner runner)
{
ActivityInstanceEntity entity = ActivityInstanceManager.CreateActivityInstanceObject(processInstance.AppName,
processInstance.AppInstanceID,
processInstance.ID,
activity,
runner);
return entity;
}
/// <summary>
/// 创建活动任务转移实例数据
/// </summary>
/// <param name="toActivity"></param>
/// <param name="processInstance"></param>
/// <param name="fromActivityInstance"></param>
/// <param name="transitionGUID"></param>
/// <param name="transitionType"></param>
/// <param name="flyingType"></param>
/// <param name="activityResource"></param>
/// <param name="session"></param>
internal override void CreateActivityTaskTransitionInstance(ActivityEntity toActivity,
ProcessInstanceEntity processInstance,
ActivityInstanceEntity fromActivityInstance,
string transitionGUID,
TransitionTypeEnum transitionType,
TransitionFlyingTypeEnum flyingType,
ActivityResource activityResource,
IDbSession session)
{
//判断是否是会签节点，如果是创建会签节点
if (toActivity.ActivityTypeDetail != null
&& toActivity.ActivityTypeDetail.ComplexType == ComplexTypeEnum.SignTogether)
{
//创建会签节点的主节点，以及会签主节点下的实例子节点记录
CreateMultipleInstance(toActivity, processInstance, fromActivityInstance,
transitionGUID, transitionType, flyingType, activityResource, session);
}
else
{
//实例化Activity
var toActivityInstance = base.CreateActivityInstanceObject(toActivity, processInstance, activityResource.AppRunner);
//进入运行状态
toActivityInstance.ActivityState = (short)ActivityStateEnum.Ready;
toActivityInstance.AssignedToUserIDs = GenerateActivityAssignedUserIDs(
activityResource.NextActivityPerformers[toActivity.ActivityGUID]);
toActivityInstance.AssignedToUserNames = GenerateActivityAssignedUserNames(
activityResource.NextActivityPerformers[toActivity.ActivityGUID]);
//插入活动实例数据
base.ActivityInstanceManager.Insert(toActivityInstance, session);
//插入任务数据
base.CreateNewTask(toActivityInstance, activityResource, session);
//插入转移数据
InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
transitionType,
flyingType,
activityResource.AppRunner,
session);
}
}
public static TransitionEntity CreateJumpforwardEmptyTransition(ActivityEntity fromActivity, ActivityEntity toActivity)
{
TransitionEntity transition = new TransitionEntity();
transition.TransitionGUID = string.Empty;
transition.FromActivity = fromActivity;
transition.FromActivityGUID = fromActivity.ActivityGUID;
transition.ToActivity = toActivity;
transition.ToActivityGUID = toActivity.ActivityGUID;
transition.DirectionType = TransitionDirectionTypeEnum.Forward;
return transition;
}
public static TransitionEntity CreateJumpforwardEmptyTransition(ActivityEntity fromActivity, ActivityEntity toActivity)
{
TransitionEntity transition = new TransitionEntity();
transition.TransitionGUID = string.Empty;
transition.FromActivity = fromActivity;
transition.FromActivityGUID = fromActivity.ActivityGUID;
transition.ToActivity = toActivity;
transition.ToActivityGUID = toActivity.ActivityGUID;
transition.DirectionType = TransitionDirectionTypeEnum.Forward;
return(transition);
}
/// <summary>
/// 把XML节点转换为ActivityEntity实体对象
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
internal ActivityEntity ConvertXmlActivityNodeToActivityEntity(XmlNode node)
{
ActivityEntity entity = new ActivityEntity();
entity.ActivityName = XMLHelper.GetXmlAttribute(node, "name");
entity.ActivityCode = XMLHelper.GetXmlAttribute(node, "code");
entity.ActivityGUID = XMLHelper.GetXmlAttribute(node, "id");
entity.ProcessGUID = ProcessEntity.ProcessGUID;
//节点类型信息
XmlNode typeNode = node.SelectSingleNode("ActivityType");
entity.ActivityType = (ActivityTypeEnum)Enum.Parse(typeof(ActivityTypeEnum), XMLHelper.GetXmlAttribute(typeNode, "type"));
entity.ActivityTypeDetail = ConvertXmlNodeToActivityTypeDetail(typeNode);
if (entity.ActivityType == ActivityTypeEnum.SubProcessNode)
{
//子流程节点
var subProcessNode = new SubProcessNode(entity);
subProcessNode.SubProcessGUID = XMLHelper.GetXmlAttribute(typeNode, "subid");
entity.Node = subProcessNode;
}
//任务完成类型信息
XmlNode implementNode = node.SelectSingleNode("Implement");
if (implementNode != null)
{
entity.TaskImplementDetail = new TaskImplementDetail();
entity.TaskImplementDetail.ImplementationType = (ImplementationTypeEnum)Enum.Parse(typeof(ImplementationTypeEnum), XMLHelper.GetXmlAttribute(implementNode, "type"));
//完成类型的详细信息
XmlNode contentNode = implementNode.SelectSingleNode("Content");
if (contentNode != null)
{
entity.TaskImplementDetail.Assembly = XMLHelper.GetXmlAttribute(contentNode, "assembly");
entity.TaskImplementDetail.Interface = XMLHelper.GetXmlAttribute(contentNode, "interface");
entity.TaskImplementDetail.Method = XMLHelper.GetXmlAttribute(contentNode, "method");
entity.TaskImplementDetail.Content = contentNode.InnerText;
}
}
//节点的Split Join 类型
string gatewaySplitJoinType = XMLHelper.GetXmlAttribute(typeNode, "gatewaySplitJoinType");
if (!string.IsNullOrEmpty(gatewaySplitJoinType))
{
entity.GatewaySplitJoinType = (GatewaySplitJoinTypeEnum)Enum.Parse(typeof(GatewaySplitJoinTypeEnum), gatewaySplitJoinType);
}
string gatewayDirection = XMLHelper.GetXmlAttribute(typeNode, "gatewayDirection");
//节点的路由信息
if (!string.IsNullOrEmpty(gatewayDirection))
{
entity.GatewayDirectionType = (GatewayDirectionEnum)Enum.Parse(typeof(GatewayDirectionEnum), gatewayDirection);
}
return entity;
}
/// <summary>
/// 创建节点对象
/// </summary>
/// <param name="processInstance">流程实例</param>
protected ActivityInstanceEntity CreateActivityInstanceObject(ActivityEntity activity,
ProcessInstanceEntity processInstance,
WfAppRunner runner)
{
ActivityInstanceManager aim = new ActivityInstanceManager();
this.GatewayActivityInstance = aim.CreateActivityInstanceObject(processInstance.AppName,
processInstance.AppInstanceID,
processInstance.ID,
activity,
runner);
return this.GatewayActivityInstance;
}
/// <summary>
/// 退回是加签情况下的处理：
/// 要退回的节点是加签节点
/// 只实例化当初的加签主节点
/// </summary>
/// <param name="processInstance"></param>
/// <param name="backwardToTaskActvity"></param>
/// <param name="fromActivityInstance"></param>
/// <param name="backwardType"></param>
/// <param name="previousMainInstance"></param>
/// <param name="transitionGUID"></param>
/// <param name="transitionType"></param>
/// <param name="flyingType"></param>
/// <param name="activityResource"></param>
/// <param name="session"></param>
internal void CreateBackwardActivityTaskRepateSignForwardMainNodeOnly(ProcessInstanceEntity processInstance,
ActivityEntity backwardToTaskActvity,
ActivityInstanceEntity fromActivityInstance,
BackwardTypeEnum backwardType,
ActivityInstanceEntity previousMainInstance,
string transitionGUID,
TransitionTypeEnum transitionType,
TransitionFlyingTypeEnum flyingType,
ActivityResource activityResource,
IDbSession session)
{
// 退回是加签情况下的处理：
// 要退回的节点是加签节点
// 只实例化当初的加签主节点
//重新封装任务办理人为AssignedToUsers, AssignedToUsernames
var performerList = AntiGenerateActivityPerformerList(previousMainInstance);
activityResource.NextActivityPerformers.Clear();
activityResource.NextActivityPerformers = new Dictionary<string, PerformerList>();
activityResource.NextActivityPerformers.Add(backwardToTaskActvity.ActivityGUID, performerList);
//实例化Activity
var toActivityInstance = base.CreateBackwardToActivityInstanceObject(processInstance,
backwardType,
previousMainInstance.ID,
activityResource.AppRunner);
//进入准备运行状态
toActivityInstance.ActivityState = (short)ActivityStateEnum.Ready;
toActivityInstance.AssignedToUserIDs = previousMainInstance.AssignedToUserIDs;
toActivityInstance.AssignedToUserNames = previousMainInstance.AssignedToUserNames;
toActivityInstance.ComplexType = previousMainInstance.ComplexType;
toActivityInstance.CompleteOrder = previousMainInstance.CompleteOrder;
toActivityInstance.SignForwardType = previousMainInstance.SignForwardType;
//插入活动实例数据
base.ActivityInstanceManager.Insert(toActivityInstance,
session);
//插入任务数据
base.CreateNewTask(toActivityInstance, activityResource, session);
//插入转移数据
base.InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
transitionType,
flyingType,
activityResource.AppRunner,
session);
}
/// <summary>
/// 获取下一步节点列表
/// </summary>
/// <param name="processInstanceID"></param>
/// <param name="fromTransition"></param>
/// <param name="currentGatewayActivity"></param>
/// <param name="conditionKeyValuePair"></param>
/// <returns></returns>
internal override NextActivityComponent GetNextActivityListFromGateway(TransitionEntity fromTransition,
ActivityEntity currentGatewayActivity,
IDictionary <string, string> conditionKeyValuePair,
out NextActivityMatchedType resultType)
{
NextActivityComponent child = null;
NextActivityComponent gatewayComponent = null;
resultType = NextActivityMatchedType.Unknown;
var transitionList = this.ProcessModel.GetForwardTransitionList(currentGatewayActivity.ActivityGUID).ToList();
if (currentGatewayActivity.GatewayDirectionType == GatewayDirectionEnum.AndSplit)
{
//判读连线上的条件是否都满足，如果都满足才可以取出后续节点列表
bool isCheckedOk = base.ProcessModel.CheckAndSplitOccurrenceCondition(transitionList, conditionKeyValuePair);
if (isCheckedOk)
{
//获取AndSplit的每一条后续连线上的To节点
foreach (TransitionEntity transition in transitionList)
{
child = GetNextActivityListFromGatewayCore(transition,
conditionKeyValuePair,
out resultType);
gatewayComponent = AddChildToGatewayComponent(fromTransition, currentGatewayActivity, gatewayComponent, child);
}
}
if (gatewayComponent == null)
{
resultType = NextActivityMatchedType.WaitingForSplitting;
}
}
else if (currentGatewayActivity.GatewayDirectionType == GatewayDirectionEnum.OrSplit)
{
//获取OrSplit的，满足条件的后续连线上的To节点
foreach (TransitionEntity transition in transitionList)
{
bool isValidTransition = base.ProcessModel.IsValidTransition(transition, conditionKeyValuePair);
if (isValidTransition)
{
child = GetNextActivityListFromGatewayCore(transition,
conditionKeyValuePair,
out resultType);
gatewayComponent = AddChildToGatewayComponent(fromTransition, currentGatewayActivity, gatewayComponent, child);
}
if (gatewayComponent == null)
{
resultType = NextActivityMatchedType.NoneTransitionMatchedToSplit;
}
}
}
else if (currentGatewayActivity.GatewayDirectionType == GatewayDirectionEnum.XOrSplit)
{
//按连线定义的优先级排序
transitionList.Sort(new TransitionPriorityCompare());
//获取XOrSplit的，第一条满足条件的后续连线上的To节点
foreach (TransitionEntity transition in transitionList)
{
bool isValidTransitionXOr = base.ProcessModel.IsValidTransition(transition, conditionKeyValuePair);
if (isValidTransitionXOr)
{
child = GetNextActivityListFromGatewayCore(transition,
conditionKeyValuePair,
out resultType);
gatewayComponent = AddChildToGatewayComponent(fromTransition, currentGatewayActivity, gatewayComponent, child);
//退出循环
break;
}
}
if (gatewayComponent == null)
{
resultType = NextActivityMatchedType.NoneTransitionMatchedToSplit;
}
}
else if (currentGatewayActivity.GatewayDirectionType == GatewayDirectionEnum.ComplexSplit)
{
resultType = NextActivityMatchedType.Failed;
throw new Exception("ComplexSplit 没有具体实现！");
}
else
{
resultType = NextActivityMatchedType.Failed;
throw new Exception("Split 分支节点的类型不明确！");
}
return(gatewayComponent);
}
/// <summary>
/// 创建工作项及转移数据
/// </summary>
/// <param name="toActivity"></param>
/// <param name="processInstance"></param>
/// <param name="fromActivityInstance"></param>
/// <param name="transitionGUID"></param>
/// <param name="transitionType"></param>
/// <param name="flyingType"></param>
/// <param name="activityResource"></param>
/// <param name="session"></param>
internal virtual void CreateActivityTaskTransitionInstance(ActivityEntity toActivity,
ProcessInstanceEntity processInstance,
ActivityInstanceEntity fromActivityInstance,
String transitionGUID,
TransitionTypeEnum transitionType,
TransitionFlyingTypeEnum flyingType,
ActivityResource activityResource,
IDbSession session)
{
}
