public static WfRuntimeManager CreateRuntimeInstanceStartup(WfAppRunner runner,
ProcessInstanceEntity parentProcessInstance,
SubProcessNode subProcessNode,
ref WfExecutedResult result)
{
//检查流程是否可以被启动
var rmins = new WfRuntimeManagerStartup();
rmins.WfExecutedResult = result = new WfExecutedResult();
var pim = new ProcessInstanceManager();
ProcessInstanceEntity processInstance = null;
if (subProcessNode == null)
{
//正常流程启动
processInstance = pim.GetProcessInstanceLatest(runner.AppInstanceID,
runner.ProcessGUID);
}
else
{
//子流程启动
processInstance = pim.GetProcessInstanceLatest(runner.AppInstanceID,
subProcessNode.SubProcessGUID);
}
//不能同时启动多个主流程
if (processInstance != null &&
processInstance.ParentProcessInstanceID == null &&
processInstance.ProcessState == (short)ProcessStateEnum.Running)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Started_IsRunningAlready;
result.Message = "流程已经处于运行状态，如果要重新启动，请先终止当前流程实例！";
return(rmins);
}
//processInstance 为空，此时继续执行启动操作
rmins.AppRunner = runner;
rmins.ParentProcessInstance = parentProcessInstance;
rmins.InvokedSubProcessNode = subProcessNode;
//获取流程第一个可办理节点
rmins.ProcessModel = ProcessModelFactory.Create(runner.ProcessGUID);
var firstActivity = rmins.ProcessModel.GetFirstActivity();
rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(firstActivity.ActivityGUID,
runner.UserID,
runner.UserName);
rmins.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers);
return(rmins);
}
/// <summary>
/// 获取下一步活动列表树
/// </summary>
/// <param name="taskID">任务ID</param>
/// <param name="condition">条件</param>
/// <returns></returns>
public IList <NodeView> GetNextActivityTree(int taskID,
IDictionary <string, string> condition = null)
{
var taskView = (new TaskManager()).GetTaskView(taskID);
var processModel = ProcessModelFactory.Create(taskView.ProcessGUID, taskView.Version);
var nextSteps = processModel.GetNextActivityTree(taskView.ProcessInstanceID,
taskView.ActivityGUID,
condition);
return(nextSteps);
}
/// <summary>
/// 根据应用获取流程下一步节点列表
/// </summary>
/// <param name="runner">应用执行人</param>
/// <param name="condition">条件</param>
/// <returns>节点列表</returns>
public IList <NodeView> GetNextActivityTree(WfAppRunner runner,
IDictionary <string, string> condition = null)
{
var tm = new TaskManager();
var taskView = tm.GetTaskOfMine(runner.AppInstanceID, runner.ProcessGUID, runner.UserID);
var processModel = ProcessModelFactory.Create(taskView.ProcessGUID, taskView.Version);
var nextSteps = processModel.GetNextActivityTree(taskView.ProcessInstanceID,
taskView.ActivityGUID,
condition);
return(nextSteps);
}
/// <summary>
/// 流程启动时获取开始节点下一步的节点角色人员列表
/// </summary>
/// <param name="runner">应用执行人</param>
/// <param name="condition">条件</param>
/// <returns>节点列表</returns>
public IList <NodeView> GetFirstActivityRoleUserTree(WfAppRunner runner, IDictionary <string, string> condition = null)
{
var processModel = ProcessModelFactory.Create(runner.ProcessGUID, runner.Version);
var firstActivity = processModel.GetFirstActivity();
var nextSteps = processModel.GetNextActivityTree(firstActivity.ActivityGUID,
condition);
foreach (var ns in nextSteps)
{
var roleIDs = ns.Roles.Select(x => x.ID).ToArray();
ns.Users = ResourceService.GetUserListByRoleReceiverType(roleIDs, runner.UserID, (int)ns.ReceiverType); //增加转移前置过滤条件
}
return(nextSteps);
}
/// <summary>
/// 创建运行时实例对象
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="result">结果对象</param>
/// <returns>运行时实例对象</returns>
public static WfRuntimeManager CreateRuntimeInstanceAppRunning(
WfAppRunner runner,
ref WfExecutedResult result)
{
//检查传人参数是否有效
var rmins = new WfRuntimeManagerAppRunning();
rmins.WfExecutedResult = result = new WfExecutedResult();
if (string.IsNullOrEmpty(runner.AppName) ||
String.IsNullOrEmpty(runner.AppInstanceID) ||
runner.ProcessGUID == null)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.RunApp_ErrorArguments;
result.Message = "方法参数错误，无法运行流程！";
return(rmins);
}
//传递runner变量
rmins.AppRunner = runner;
var aim = new ActivityInstanceManager();
TaskViewEntity taskView = null;
var runningNode = aim.GetRunningNode(runner, out taskView);
//判断是否是当前登录用户的任务
if (runningNode.AssignedToUserIDs.Contains(runner.UserID.ToString()) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.RunApp_HasNoTask;
result.Message = "当前没有登录用户要办理的任务，无法运行流程！";
return(rmins);
}
var processModel = ProcessModelFactory.Create(taskView.ProcessGUID, taskView.Version);
var activityResource = new ActivityResource(runner,
runner.NextActivityPerformers,
runner.Conditions,
runner.DynamicVariables);
var tm = new TaskManager();
rmins.TaskView = taskView;
rmins.RunningActivityInstance = runningNode;
rmins.ProcessModel = processModel;
rmins.ActivityResource = activityResource;
return(rmins);
}
/// <summary>
/// 获取预选步骤人员列表
/// </summary>
/// <param name="runner">当前运行用户</param>
/// <returns>步骤预选人员列表</returns>
private IDictionary <string, PerformerList> GetNextActivityPerformersPriliminary(WfAppRunner runner)
{
IDictionary <string, PerformerList> nextSteps = null;
var tm = new TaskManager();
TaskViewEntity taskView = tm.GetTaskOfMine(runner);
//读取活动实例中记录的步骤预选数据
var aim = new ActivityInstanceManager();
if (taskView.MIHostActivityInstanceID != null)
{
var mainActivityInstanceID = taskView.MIHostActivityInstanceID.Value;
var mainActivityInstance = aim.GetById(mainActivityInstanceID);
if (mainActivityInstance != null)
{
nextSteps = NextStepUtility.DeserializeNextStepPerformers(mainActivityInstance.NextStepPerformers);
}
}
IProcessModel processModel = ProcessModelFactory.Create(runner.ProcessGUID, runner.Version);
var nextActivity = processModel.GetNextActivity(taskView.ActivityGUID);
if (nextActivity != null)
{
if (nextActivity.ActivityType == ActivityTypeEnum.GatewayNode)
{
//获取网关节点信息
var gatewayActivityInstance = aim.GetActivityInstanceLatest(taskView.ProcessInstanceID, nextActivity.ActivityGUID);
if (gatewayActivityInstance != null &&
!string.IsNullOrEmpty(gatewayActivityInstance.NextStepPerformers))
{
nextSteps = NextStepUtility.DeserializeNextStepPerformers(gatewayActivityInstance.NextStepPerformers);
}
}
else if (XPDLHelper.IsInterTimerEventComponentNode(nextActivity) == true)
{
//中间Timer事件节点
var timerActivityInstance = aim.GetActivityInstanceLatest(taskView.ProcessInstanceID, nextActivity.ActivityGUID);
if (timerActivityInstance != null &&
!string.IsNullOrEmpty(timerActivityInstance.NextStepPerformers))
{
nextSteps = NextStepUtility.DeserializeNextStepPerformers(timerActivityInstance.NextStepPerformers);
}
}
}
return(nextSteps);
}
/// <summary>
/// 创建运行时实例对象
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="session">数据库会话</param>
/// <param name="result">结果对象</param>
/// <returns>运行时实例对象</returns>
public static WfRuntimeManager CreateRuntimeInstanceAppRunning(WfAppRunner runner,
IDbSession session,
ref WfExecutedResult result)
{
//检查传人参数是否有效
var rmins = new WfRuntimeManagerAppRunning();
rmins.WfExecutedResult = result = new WfExecutedResult();
if (string.IsNullOrEmpty(runner.AppName) ||
String.IsNullOrEmpty(runner.AppInstanceID) ||
runner.ProcessGUID == null)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.RunApp_ErrorArguments;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceAppRunning.missing.error");
return(rmins);
}
//传递runner变量
rmins.AppRunner = runner;
var aim = new ActivityInstanceManager();
TaskViewEntity taskView = null;
var runningNode = aim.GetRunningNode(runner, session, out taskView);
//判断是否是当前登录用户的任务
if (runningNode.AssignedToUserIDs.Contains(runner.UserID.ToString()) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.RunApp_HasNoTask;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceAppRunning.nonetask.error");
return(rmins);
}
//用于流程注册事件时的流程实例ID提供
rmins.ProcessInstanceID = runningNode.ProcessInstanceID;
var processModel = ProcessModelFactory.Create(taskView.ProcessGUID, taskView.Version);
var activityResource = new ActivityResource(runner,
runner.NextActivityPerformers,
runner.Conditions);
rmins.TaskView = taskView;
rmins.RunningActivityInstance = runningNode;
rmins.ProcessModel = processModel;
rmins.ActivityResource = activityResource;
return(rmins);
}
/// <summary>
/// 子流程启动
/// </summary>
/// <param name="runner">运行者</param>
/// <param name="parentProcessInstance">父流程</param>
/// <param name="subProcessNode">子流程节点</param>
/// <param name="performerList">执行者列表</param>
/// <param name="session">数据库会话</param>
/// <param name="result">运行结果</param>
/// <returns>运行时管理器</returns>
public static WfRuntimeManager CreateRuntimeInstanceStartupSub(WfAppRunner runner,
ProcessInstanceEntity parentProcessInstance,
SubProcessNode subProcessNode,
PerformerList performerList,
IDbSession session,
ref WfExecutedResult result)
{
//检查流程是否可以被启动
var rmins = new WfRuntimeManagerStartupSub();
rmins.WfExecutedResult = result = new WfExecutedResult();
var pim = new ProcessInstanceManager();
ProcessInstanceEntity processInstance = pim.GetProcessInstanceCurrent(session.Connection,
runner.AppInstanceID,
subProcessNode.SubProcessGUID,
session.Transaction);
//不能同时启动多个主流程
if (processInstance != null &&
processInstance.ParentProcessInstanceID == null &&
processInstance.ProcessState == (short)ProcessStateEnum.Running)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Started_IsRunningAlready;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceStartup.error");
return(rmins);
}
//processInstance 为空，此时继续执行启动操作
rmins.AppRunner = runner;
rmins.ParentProcessInstance = parentProcessInstance;
rmins.InvokedSubProcessNode = subProcessNode;
//获取流程第一个可办理节点
rmins.ProcessModel = ProcessModelFactory.Create(runner.ProcessGUID, runner.Version);
var startActivity = rmins.ProcessModel.GetStartActivity();
var firstActivity = rmins.ProcessModel.GetFirstActivity();
//子流程自动获取第一个办理节点上的人员列表
rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(firstActivity.ActivityGUID,
performerList);
rmins.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers);
return(rmins);
}
/// <summary>
/// 启动流程
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="result">结果对象</param>
/// <returns>运行时实例对象</returns>
public static WfRuntimeManager CreateRuntimeInstanceStartup(WfAppRunner runner,
ref WfExecutedResult result)
{
//检查流程是否可以被启动
var rmins = new WfRuntimeManagerStartup();
rmins.WfExecutedResult = result = new WfExecutedResult();
//正常流程启动
var pim = new ProcessInstanceManager();
ProcessInstanceEntity processInstance = pim.GetProcessInstanceCurrent(runner.AppInstanceID,
runner.ProcessGUID);
//不能同时启动多个主流程
if (processInstance != null &&
processInstance.ParentProcessInstanceID == null &&
processInstance.ProcessState == (short)ProcessStateEnum.Running)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Started_IsRunningAlready;
result.Message = "流程已经处于运行状态，如果要重新启动，请先终止当前流程实例！";
return(rmins);
}
rmins.AppRunner = runner;
//获取流程第一个可办理节点
rmins.ProcessModel = ProcessModelFactory.Create(runner.ProcessGUID, runner.Version);
var startActivity = rmins.ProcessModel.GetStartActivity();
var firstActivity = rmins.ProcessModel.GetFirstActivity();
if (startActivity.ActivityTypeDetail.TriggerType == TriggerTypeEnum.None)
{
rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(firstActivity.ActivityGUID,
runner.UserID,
runner.UserName);
}
else if (startActivity.ActivityTypeDetail.TriggerType == TriggerTypeEnum.Timer)
{
var roleList = rmins.ProcessModel.GetActivityRoles(firstActivity.ActivityGUID);
rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(firstActivity.ActivityGUID, roleList);
}
rmins.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers);
return(rmins);
}
/// <summary>
/// 创建活动任务转移数据
/// </summary>
/// <param name="toActivity">目的活动</param>
/// <param name="processInstance">流程实例</param>
/// <param name="fromActivityInstance">来源活动实例</param>
/// <param name="transitionGUID">转移GUID</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)
{
Boolean isParallel = false;
if (fromActivityInstance.ActivityType == (short)ActivityTypeEnum.GatewayNode)
{
var processModel = ProcessModelFactory.Create(processInstance.ProcessGUID, processInstance.Version);
var activityNode = processModel.GetActivity(fromActivityInstance.ActivityGUID);
isParallel = processModel.IsAndSplitMI(activityNode);
}
if (isParallel)
{
var entity = new ActivityInstanceEntity();
var plist = activityResource.NextActivityPerformers[toActivity.ActivityGUID];
//创建并行多实例分支
for (var i = 0; i < plist.Count; i++)
{
var performer = plist[i];
CreateSubProcessNode(toActivity, processInstance, fromActivityInstance, transitionGUID, transitionType,
flyingType, activityResource, performer, session);
}
}
else
{
if (toActivity.ActivityTypeDetail.ComplexType == ComplexTypeEnum.SignTogether)
{
CreateMultipleInstance(toActivity, processInstance, fromActivityInstance,
transitionGUID, transitionType, flyingType, activityResource, session);
}
else
{
CreateSubProcessNode(toActivity, processInstance, fromActivityInstance, transitionGUID, transitionType,
flyingType, activityResource, null, session);
}
}
}
/// <summary>
/// 使用流程定义资源添加角色用户
/// </summary>
/// <param name="mainActivityInstanceID">主流程节点实例ID</param>
/// <param name="mainActivityGUID">主流程节点GUID</param>
/// <param name="session">数据库会话</param>
/// <returns>执行用户</returns>
private WfAppRunner FillNextActivityPerformersByRoleList(int mainActivityInstanceID,
string mainActivityGUID,
IDbSession session)
{
var pm = new ProcessInstanceManager();
var mainProcessInstance = pm.GetByActivity(session.Connection, mainActivityInstanceID, session.Transaction);
var processModel = ProcessModelFactory.Create(mainProcessInstance.ProcessGUID, mainProcessInstance.Version);
var nextSteps = processModel.GetNextActivityTree(mainActivityGUID);
//获取主流程的任务
var task = (new TaskManager()).GetTaskByActivity(session.Connection, mainProcessInstance.ID, mainActivityInstanceID, session.Transaction);
var runner = new WfAppRunner
{
AppName = mainProcessInstance.AppName,
AppInstanceID = mainProcessInstance.AppInstanceID,
AppInstanceCode = mainProcessInstance.AppInstanceCode,
ProcessGUID = mainProcessInstance.ProcessGUID,
Version = mainProcessInstance.Version,
UserID = task.AssignedToUserID,
UserName = task.AssignedToUserName
};
foreach (var node in nextSteps)
{
Dictionary <string, PerformerList> dict = new Dictionary <string, PerformerList>();
var performerList = PerformerBuilder.CreatePerformerList(node.Roles); //根据节点角色定义，读取执行者列表
if (node.ActivityType != ActivityTypeEnum.EndNode &&
performerList.Count == 0)
{
throw new WfRuntimeException(LocalizeHelper.GetEngineMessage("nodemediatorend.FillNextActivityPerformersByRoleList.warn", node.ActivityName));
}
else
{
dict.Add(node.ActivityGUID, performerList);
}
runner.NextActivityPerformers = dict;
}
return(runner);
}
/// <summary>
/// 设置流程的启动类型
/// </summary>
/// <param name="entity">流程实体</param>
/// <param name="xmlConent">XML内容</param>
private void SetProcessStartEndType(ProcessEntity entity, string xmlConent)
{
var processModel = ProcessModelFactory.Create(entity.ProcessGUID, entity.Version);
//StartNode
var startNode = processModel.GetActivityByType(xmlConent, entity.ProcessGUID, ActivityTypeEnum.StartNode);
if (startNode != null)
{
if (startNode.ActivityTypeDetail.TriggerType == TriggerTypeEnum.Timer)
{
entity.StartType = (byte)ProcessStartTypeEnum.Timer;
entity.StartExpression = startNode.ActivityTypeDetail.Expression;
}
else if (startNode.ActivityTypeDetail.TriggerType == TriggerTypeEnum.Message)
{
entity.StartType = (byte)ProcessStartTypeEnum.Message;
entity.StartExpression = startNode.ActivityTypeDetail.Expression;
}
}
//EndNode
var endNode = processModel.GetActivityByType(xmlConent, entity.ProcessGUID, ActivityTypeEnum.EndNode);
if (endNode != null)
{
if (endNode.ActivityTypeDetail.TriggerType == TriggerTypeEnum.Timer)
{
entity.EndType = (byte)ProcessEndTypeEnum.Timer;
entity.EndExpression = endNode.ActivityTypeDetail.Expression;
}
else if (endNode.ActivityTypeDetail.TriggerType == TriggerTypeEnum.Message)
{
entity.EndType = (byte)ProcessEndTypeEnum.Message;
entity.EndExpression = endNode.ActivityTypeDetail.Expression;
}
}
}
/// <summary>
/// 获取预选步骤人员列表
/// </summary>
/// <param name="nextActivityTree">下一步活动节点树</param>
/// <param name="runner">当前运行用户</param>
/// <returns>步骤预选人员列表</returns>
private IDictionary <string, PerformerList> GetNextActivityPerformers(IList <NodeView> nextActivityTree,
WfAppRunner runner)
{
IDictionary <string, PerformerList> nextSteps = null;
var tm = new TaskManager();
TaskViewEntity taskView = tm.GetTaskOfMine(runner);
//读取活动实例中记录的步骤预选数据
var aim = new ActivityInstanceManager();
if (taskView.MIHostActivityInstanceID != null)
{
var mainActivityInstanceID = taskView.MIHostActivityInstanceID.Value;
var mainActivityInstance = aim.GetById(mainActivityInstanceID);
if (mainActivityInstance != null)
{
nextSteps = NextStepUtility.DeserializeNextStepPerformers(mainActivityInstance.NextStepPerformers);
}
}
//获取网关节点信息
IProcessModel processModel = ProcessModelFactory.Create(runner.ProcessGUID, runner.Version);
var nextActivity = processModel.GetNextActivity(taskView.ActivityGUID);
if (nextActivity.ActivityType == ActivityTypeEnum.GatewayNode)
{
var gatewayActivityInstance = aim.GetActivityInstanceLatest(taskView.ProcessInstanceID, nextActivity.ActivityGUID);
if (gatewayActivityInstance != null &&
!string.IsNullOrEmpty(gatewayActivityInstance.NextStepPerformers))
{
nextSteps = NextStepUtility.DeserializeNextStepPerformers(gatewayActivityInstance.NextStepPerformers);
}
}
return(nextSteps);
}
/// <summary>
/// 根据不同撤销场景创建运行时管理器
/// </summary>
/// <param name="runningActivityInstanceList">运行节点列表</param>
/// <param name="withdrawOperation">撤销类型</param>
/// <param name="runner">执行者</param>
/// <param name="result">结果对象</param>
/// <returns>运行时管理器</returns>
private static WfRuntimeManager CreateRuntimeInstanceWithdrawByCase(
List <ActivityInstanceEntity> runningActivityInstanceList,
WithdrawOperationTypeEnum withdrawOperation,
WfAppRunner runner,
ref WfExecutedResult result)
{
WfRuntimeManager rmins = new WfRuntimeManagerWithdraw();
rmins.WfExecutedResult = result = new WfExecutedResult();
//根据当前运行节点获取
ActivityInstanceEntity runningNode = runningActivityInstanceList[0];
ProcessInstanceEntity processInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID);
IProcessModel processModel = ProcessModelFactory.Create(processInstance.ProcessGUID, processInstance.Version);
//不同撤销的分支场景处理
var aim = new ActivityInstanceManager();
//以下处理，需要知道上一步是独立节点的信息
//获取上一步流转节点信息，可能经过And, Or等路由节点
var tim = new TransitionInstanceManager();
bool hasGatewayNode = false;
var currentNode = runningNode;
if (runningNode.MIHostActivityInstanceID != null)
{
//如果当前运行节点是多实例子节点，则需要找到它的主节点的Transiton记录
currentNode = aim.GetById(runningNode.MIHostActivityInstanceID.Value);
}
var lastActivityInstanceList = tim.GetPreviousActivityInstance(currentNode, false, out hasGatewayNode).ToList();
if (lastActivityInstanceList == null || lastActivityInstanceList.Count > 1)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Withdraw_HasTooMany;
result.Message = "当前没有可以撤销回去的节点，或者有多个可以撤销回去的节点，无法选择！";
return(rmins);
}
TransitionInstanceEntity lastTaskTransitionInstance = null;
if (hasGatewayNode == false)
{
lastTaskTransitionInstance = tim.GetLastTaskTransition(runner.AppName,
runner.AppInstanceID, runner.ProcessGUID);
if (lastTaskTransitionInstance.TransitionType == (short)TransitionTypeEnum.Loop)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Withdraw_IsLoopNode;
result.Message = "当前流转是自循环，无需撤销！";
return(rmins);
}
}
var previousActivityInstance = lastActivityInstanceList[0];
if (previousActivityInstance.EndedByUserID != runner.UserID)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Withdraw_NotCreatedByMine;
result.Message = string.Format("上一步节点的任务办理人跟当前登录用户不一致，无法撤销回上一步！节点办理人：{0}",
previousActivityInstance.EndedByUserName);
return(rmins);
}
if (previousActivityInstance.ActivityType == (short)ActivityTypeEnum.EndNode)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Withdraw_PreviousIsEndNode;
result.Message = "上一步是结束节点，无法撤销！";
return(rmins);
}
//当前运行节点是普通节点
if (withdrawOperation == WithdrawOperationTypeEnum.Normal)
{
//简单串行模式下的退回
rmins = new WfRuntimeManagerWithdraw();
rmins.WfExecutedResult = result = new WfExecutedResult();
rmins.ProcessModel = processModel;
rmins.AppRunner.ProcessGUID = runner.ProcessGUID;
rmins.BackwardContext.ProcessInstance = processInstance;
rmins.BackwardContext.BackwardToTargetTransitionGUID =
hasGatewayNode == false ? lastTaskTransitionInstance.TransitionGUID : String.Empty;
rmins.BackwardContext.BackwardToTaskActivity = processModel.GetActivity(previousActivityInstance.ActivityGUID);
rmins.BackwardContext.BackwardToTaskActivityInstance = previousActivityInstance;
rmins.BackwardContext.BackwardFromActivity = processModel.GetActivity(runningNode.ActivityGUID);
rmins.BackwardContext.BackwardFromActivityInstance = runningNode; //准备状态的接收节点
rmins.BackwardContext.BackwardTaskReceiver = WfBackwardTaskReceiver.Instance(
previousActivityInstance.ActivityName,
previousActivityInstance.EndedByUserID,
previousActivityInstance.EndedByUserName);
//封装AppUser对象
rmins.AppRunner.AppName = runner.AppName;
rmins.AppRunner.AppInstanceID = runner.AppInstanceID;
rmins.AppRunner.UserID = runner.UserID;
rmins.AppRunner.UserName = runner.UserName;
rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(
previousActivityInstance.ActivityGUID,
runner.UserID,
runner.UserName);
rmins.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers);
return(rmins);
}
//如果有其它模式，没有处理到，则直接抛出异常
throw new WorkflowException("未知的撤销场景，请报告给技术支持人员！");
}
/// <summary>
/// 创建跳转实例信息
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="result">结果对象</param>
/// <returns>运行时实例对象</returns>
public static WfRuntimeManager CreateRuntimeInstanceJump(WfAppRunner runner,
ref WfExecutedResult result)
{
var rmins = new WfRuntimeManagerJump();
rmins.WfExecutedResult = result = new WfExecutedResult();
if (string.IsNullOrEmpty(runner.AppName) ||
String.IsNullOrEmpty(runner.AppInstanceID) ||
runner.ProcessGUID == null ||
runner.NextActivityPerformers == null)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Jump_ErrorArguments;
result.Message = "方法参数错误，无法运行流程！";
return(rmins);
}
//流程跳转时，只能跳转到一个节点
if (runner.NextActivityPerformers.Count() > 1)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Jump_OverOneStep;
result.Message = string.Format("不能跳转到多个节点！节点数:{0}",
runner.NextActivityPerformers.Count());
return(rmins);
}
//获取当前运行节点信息
var aim = new ActivityInstanceManager();
TaskViewEntity taskView = null;
var runningNode = aim.GetRunningNode(runner, out taskView);
//传递runner变量
rmins.TaskView = taskView;
rmins.AppRunner = runner;
rmins.AppRunner.AppName = runner.AppName;
rmins.AppRunner.AppInstanceID = runner.AppInstanceID;
rmins.AppRunner.ProcessGUID = runner.ProcessGUID;
rmins.AppRunner.UserID = runner.UserID;
rmins.AppRunner.UserName = runner.UserName;
var processModel = ProcessModelFactory.Create(taskView.ProcessGUID, taskView.Version);
rmins.ProcessModel = processModel;
#region 考虑回跳方式
////获取跳转节点信息
//var jumpActivityGUID = runner.NextActivityPerformers.First().Key;
//var jumpActivityInstanceList = aim.GetActivityInstance(runner.AppInstanceID, runner.ProcessGUID, jumpActivityGUID);
//if (jumpActivityInstanceList != null
// && jumpActivityInstanceList.Count > 0)
//{
// //跳转到曾经执行过的节点上,可以作为跳回方式处理
// rmins.IsBackward = true;
// rmins.BackwardContext.ProcessInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID);
// rmins.BackwardContext.BackwardToTaskActivity = processModel.GetActivity(jumpActivityGUID);
// //获取当前运行节点的上一步节点
// bool hasGatewayNode = false;
// var tim = new TransitionInstanceManager();
// var lastTaskTransitionInstance = tim.GetLastTaskTransition(runner.AppName,
// runner.AppInstanceID, runner.ProcessGUID);
// var previousActivityInstance = tim.GetPreviousActivityInstance(runningNode, true,
// out hasGatewayNode).ToList()[0];
// //仅仅是回跳到上一步节点，即按SendBack方式处理
// if (previousActivityInstance.ActivityGUID == jumpActivityGUID)
// {
// rmins.BackwardContext.BackwardToTaskActivityInstance = previousActivityInstance;
// rmins.BackwardContext.BackwardToTargetTransitionGUID =
// hasGatewayNode == false ? lastTaskTransitionInstance.TransitionGUID : System.Guid.Empty; //如果中间有Gateway节点，则没有直接相连的TransitonGUID
// rmins.BackwardContext.BackwardFromActivity = processModel.GetActivity(runningNode.ActivityGUID);
// rmins.BackwardContext.BackwardFromActivityInstance = runningNode;
// rmins.BackwardContext.BackwardTaskReciever = WfBackwardTaskReciever.Instance(
// previousActivityInstance.ActivityName,
// previousActivityInstance.EndedByUserID.Value,
// previousActivityInstance.EndedByUserName);
// rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(
// previousActivityInstance.ActivityGUID,
// previousActivityInstance.EndedByUserID.Value,
// previousActivityInstance.EndedByUserName);
// }
// else
// {
// //回跳到早前节点
// var jumptoActivityInstance = jumpActivityInstanceList[0];
// if (jumptoActivityInstance.ActivityState != (short)ActivityStateEnum.Completed)
// {
// result.Status = WfExecutedStatus.Exception;
// result.Exception = WfJumpException.NotActivityBackCompleted;
// result.Message = string.Format("回跳到的节点不在完成状态，无法重新回跳！");
// return rmins;
// }
// rmins.BackwardContext.BackwardToTaskActivityInstance = jumptoActivityInstance;
// //判断两个节点是否有Transition的定义存在
// var transition = processModel.GetForwardTransition(runningNode.ActivityGUID, runner.JumpbackActivityGUID.Value);
// rmins.BackwardContext.BackwardToTargetTransitionGUID = transition != null ? transition.TransitionGUID : System.Guid.Empty;
// rmins.BackwardContext.BackwardFromActivity = processModel.GetActivity(runningNode.ActivityGUID);
// rmins.BackwardContext.BackwardFromActivityInstance = runningNode;
// rmins.BackwardContext.BackwardTaskReciever = WfBackwardTaskReciever.Instance(
// jumptoActivityInstance.ActivityName,
// jumptoActivityInstance.EndedByUserID.Value,
// jumptoActivityInstance.EndedByUserName);
// rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(
// jumptoActivityInstance.ActivityGUID,
// jumptoActivityInstance.EndedByUserID.Value,
// jumptoActivityInstance.EndedByUserName);
// }
// //获取资源数据
// var activityResourceBack = new ActivityResource(rmins.AppRunner,
// rmins.AppRunner.NextActivityPerformers,
// runner.Conditions);
// rmins.ActivityResource = activityResourceBack;
//}
//else
//{
// //跳转到从未执行过的节点上
// var activityResource = new ActivityResource(runner, runner.NextActivityPerformers, runner.Conditions);
// rmins.ActivityResource = activityResource;
// rmins.RunningActivityInstance = runningNode;
//}
#endregion
//跳转到从未执行过的节点上
var activityResource = new ActivityResource(runner, runner.NextActivityPerformers, runner.Conditions);
rmins.ActivityResource = activityResource;
rmins.RunningActivityInstance = runningNode;
return(rmins);
}
/// <summary>
/// 退回操作
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="result">结果对象</param>
/// <returns>运行时实例对象</returns>
internal static WfRuntimeManager CreateRuntimeInstanceSendBack(WfAppRunner runner,
ref WfExecutedResult result)
{
var rmins = new WfRuntimeManagerSendBack();
rmins.WfExecutedResult = result = new WfExecutedResult();
var sendbackOperation = SendbackOperationTypeEnum.Default;
//先查找当前用户正在办理的运行节点
var aim = new ActivityInstanceManager();
var runningNode = runner.TaskID != null?aim.GetByTask(runner.TaskID.Value)
: aim.GetRunningNode(runner);
if (runningNode == null)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotInRunning;
result.Message = "当前没有运行状态的节点存在，流程不存在，或者已经结束或取消";
return(rmins);
}
if (aim.IsMineTask(runningNode, runner.UserID) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotMineTask;
result.Message = "不是当前登录用户的任务，无法退回！";
return(rmins);
}
var activityType = EnumHelper.ParseEnum <ActivityTypeEnum>(runningNode.ActivityType.ToString());
if (XPDLHelper.IsSimpleComponentNode(activityType) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotTaskNode;
result.Message = "当前节点不是任务类型的节点，无法退回上一步节点！";
return(rmins);
}
//获取当前运行主节点信息
var currentNode = runningNode;
if (runningNode.MIHostActivityInstanceID != null)
{
currentNode = aim.GetById(runningNode.MIHostActivityInstanceID.Value);
}
//获取上一步流转节点信息，可能经过And, Or等路由节点
//判断前置步骤是否经过Gateway节点
var hasGatewayPassed = false;
var processInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID);
var processModel = ProcessModelFactory.Create(processInstance.ProcessGUID, processInstance.Version);
var previousActivityList = aim.GetPreviousActivityList(runningNode, processModel, out hasGatewayPassed);
if (previousActivityList == null ||
previousActivityList.Count == 0)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsNull;
result.Message = "当前没有可以退回的节点，请检查流程数据！";
return(null);
}
//多个退回节点存在的有效退回判断
IList <ActivityEntity> sendbackPreviousActivityList = new List <ActivityEntity>();
if (previousActivityList.Count > 1)
{
if (runner.NextActivityPerformers == null ||
runner.NextActivityPerformers.Count == 0)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsTooManyPrevious;
result.Message = "当前有多个可以退回的节点，无法选择，请明确指定！";
return(rmins);
}
//明确指定的退回节点，需要判断处理
var isInvalidSendBack = IsInvalidStepsInPrevousActivityList(previousActivityList,
runner.NextActivityPerformers,
sendbackPreviousActivityList);
if (isInvalidSendBack == true)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotContainedInPreviousOrStartNode;
result.Message = "指定的退回节点不在上一步节点运行列表中，或者上一步是开始节点，无法退回！";
return(rmins);
}
}
else
{
//只有一个要退回去的节点
sendbackPreviousActivityList.Add(previousActivityList[0]);
}
//判断当前节点是否是多实例节点
if (runningNode.MIHostActivityInstanceID != null)
{
if (runningNode.CompleteOrder == 1)
{
//只有串行模式下有CompleteOrder的值为 1
//串行模式多实例的第一个执行节点，此时可退回到上一步
sendbackOperation = SendbackOperationTypeEnum.MISFirstOneIsRunning;
}
else if (runningNode.CompleteOrder > 1)
{
//已经是中间节点，只能退回到上一步多实例子节点
sendbackOperation = SendbackOperationTypeEnum.MISOneIsRunning;
}
else if (runningNode.CompleteOrder == -1)
{
sendbackOperation = SendbackOperationTypeEnum.MIPOneIsRunning;
}
}
if (hasGatewayPassed == true)
{
sendbackOperation = SendbackOperationTypeEnum.GatewayFollowedByParalleledNodes;
}
else
{
sendbackOperation = SendbackOperationTypeEnum.Normal;
}
//根据不同分支场景，创建不同撤销运行时管理器
return(CreateRuntimeInstanceSendbackByCase(runningNode, processModel, processInstance,
sendbackPreviousActivityList, hasGatewayPassed, sendbackOperation, runner, ref result));
}
/// <summary>
/// 创建活动任务转移实例数据
/// </summary>
/// <param name="toActivity">活动</param>
/// <param name="processInstance">流程实例</param>
/// <param name="fromActivityInstance">开始活动实例</param>
/// <param name="transitionGUID">转移GUID</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)
{
int newActivityInstanceID = 0;
Boolean isParallel = false;
if (fromActivityInstance.ActivityType == (short)ActivityTypeEnum.GatewayNode)
{
//并发多实例分支判断(AndSplit Multiple)
var processModel = ProcessModelFactory.Create(processInstance.ProcessGUID, processInstance.Version);
var activityNode = processModel.GetActivity(fromActivityInstance.ActivityGUID);
isParallel = processModel.IsAndSplitMI(activityNode);
}
if (isParallel)
{
//并行多实例容器
var entity = new ActivityInstanceEntity();
var plist = activityResource.NextActivityPerformers[toActivity.ActivityGUID];
//创建并行多实例分支
for (var i = 0; i < plist.Count; i++)
{
entity = base.CreateActivityInstanceObject(toActivity, processInstance, activityResource.AppRunner);
entity.AssignedToUserIDs = plist[i].UserID;
entity.AssignedToUserNames = plist[i].UserName;
entity.ActivityState = (short)ActivityStateEnum.Ready;
//插入活动实例数据
entity.ID = base.ActivityInstanceManager.Insert(entity, session);
//插入任务
base.TaskManager.Insert(entity, plist[i], activityResource.AppRunner, session);
//插入转移数据
InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
entity,
transitionType,
flyingType,
activityResource.AppRunner,
session);
}
}
else
{
//普通任务节点
var toActivityInstance = base.CreateActivityInstanceObject(toActivity, processInstance, activityResource.AppRunner);
//进入运行状态
toActivityInstance.ActivityState = (short)ActivityStateEnum.Ready;
toActivityInstance = GenerateActivityAssignedUserInfo(toActivityInstance, activityResource);
//插入活动实例数据
newActivityInstanceID = base.ActivityInstanceManager.Insert(toActivityInstance, session);
//插入任务数据
base.CreateNewTask(toActivityInstance, activityResource, session);
//插入转移数据
InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
transitionType,
flyingType,
activityResource.AppRunner,
session);
//调用外部事件的注册方法
var delegateContext = new DelegateContext
{
AppInstanceID = processInstance.AppInstanceID,
ProcessGUID = processInstance.ProcessGUID,
ProcessInstanceID = processInstance.ID,
ActivityGUID = toActivity.ActivityGUID,
ActivityCode = toActivity.ActivityCode,
ActivityResource = activityResource
};
DelegateExecutor.InvokeExternalDelegate(session,
EventFireTypeEnum.OnActivityCreated,
activityResource.AppRunner.DelegateEventList,
delegateContext);
}
}
/// <summary>
/// 获取活动节点下的角色数据
/// </summary>
/// <param name="processGUID">流程GUID</param>
/// <param name="version">版本</param>
/// <param name="activityGUID">活动GUID</param>
/// <returns>角色列表</returns>
public IList <Role> GetActivityRoles(string processGUID, string version, string activityGUID)
{
var processModel = ProcessModelFactory.Create(processGUID, version);
return(processModel.GetActivityRoles(activityGUID));
}
/// <summary>
/// 获取上一步节点树
/// </summary>
/// <param name="runningNode">运行活动</param>
/// <param name="hasGatewayPassed">是否经过网关</param>
/// <returns>上一步步骤列表</returns>
private IList <NodeView> GetPreviousActivityTree(ActivityInstanceEntity runningNode, out Boolean hasGatewayPassed)
{
var aim = new ActivityInstanceManager();
//获取前置节点列表
var processInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID);
var processModel = ProcessModelFactory.Create(processInstance.ProcessGUID, processInstance.Version);
var previousActivityList = GetPreviousActivityList(runningNode, processModel, out hasGatewayPassed);
//封装返回结果集合
var nodeList = new List <NodeView>();
foreach (var activity in previousActivityList)
{
//判断是否是会签节点
if (processModel.IsMINode(activity) == true)
{
//获取上一步节点的运行记录
if (processModel.IsMIParallel(activity) == true)
{
//并行会签节点读取所有完成的子节点
var activityInstanceList = aim.GetPreviousParallelMultipleInstanceListCompleted(runningNode, activity.ActivityGUID);
foreach (var ai in activityInstanceList)
{
AppendNodeViewList(nodeList, activity, ai.EndedByUserID, ai.EndedByUserName);
}
}
else if (processModel.IsMISequence(activity) == true)
{
if (processModel.IsTaskNode(runningNode) == true)
{
//当前节点是任务节点
//退回到会签节点的最后一步
var activityInstance = aim.GetPreviousActivityInstanceSimple(runningNode, activity.ActivityGUID);
if (activityInstance != null)
{
AppendNodeViewList(nodeList, activity, activityInstance.EndedByUserID, activityInstance.EndedByUserName);
}
}
else if (processModel.IsMISequence(activity) == true)
{
//串行会签节点按照CompleteOrder顺序递减读取上一步
var previousAdjacentBrotherNode = GetPreviousOfMultipleInstanceNode(
runningNode.MIHostActivityInstanceID.Value,
runningNode.ID,
runningNode.CompleteOrder.Value);
if (previousAdjacentBrotherNode != null)
{
AppendNodeViewList(nodeList, activity, previousAdjacentBrotherNode.EndedByUserID, previousAdjacentBrotherNode.EndedByUserName);
}
}
}
}
else
{
if (hasGatewayPassed == true)
{
//跨越网关类型
var activityInstanceList = aim.GetActivityInstanceListCompletedSimple(runningNode.ProcessInstanceID, activity.ActivityGUID);
foreach (var a in activityInstanceList)
{
AppendNodeViewList(nodeList, activity, a.EndedByUserID, a.EndedByUserName);
}
}
else
{
//普通任务节点
var activityInstance = aim.GetPreviousActivityInstanceSimple(runningNode, activity.ActivityGUID);
if (activityInstance != null)
{
AppendNodeViewList(nodeList, activity, activityInstance.EndedByUserID, activityInstance.EndedByUserName);
}
}
}
}
return(nodeList);
}
/// <summary>
/// 创建跳转实例信息
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="result">结果对象</param>
/// <returns>运行时实例对象</returns>
public static WfRuntimeManager CreateRuntimeInstanceJump(WfAppRunner runner,
ref WfExecutedResult result)
{
var rmins = new WfRuntimeManagerJump();
rmins.WfExecutedResult = result = new WfExecutedResult();
if (string.IsNullOrEmpty(runner.AppName) ||
String.IsNullOrEmpty(runner.AppInstanceID) ||
runner.ProcessGUID == null ||
runner.NextActivityPerformers == null)
{
//缺失方法参数
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Jump_ErrorArguments;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceJump.missing.error");
return(rmins);
}
//流程跳转时，只能跳转到一个节点
if (runner.NextActivityPerformers.Count() > 1)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Jump_OverOneStep;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceJump.jump.error",
runner.NextActivityPerformers.Count().ToString());
return(rmins);
}
//获取当前运行节点信息
var aim = new ActivityInstanceManager();
TaskViewEntity taskView = null;
var runningNode = aim.GetRunningNode(runner, out taskView);
//传递runner变量
rmins.TaskView = taskView;
rmins.AppRunner = runner;
rmins.AppRunner.AppName = runner.AppName;
rmins.AppRunner.AppInstanceID = runner.AppInstanceID;
rmins.AppRunner.ProcessGUID = runner.ProcessGUID;
rmins.AppRunner.UserID = runner.UserID;
rmins.AppRunner.UserName = runner.UserName;
//用于流程注册时间调用时候的流程实例ID提供
rmins.ProcessInstanceID = runningNode.ProcessInstanceID;
var processModel = ProcessModelFactory.Create(taskView.ProcessGUID, taskView.Version);
rmins.ProcessModel = processModel;
#region 考虑回跳方式
//获取跳转节点信息
var jumpBackActivityGUID = runner.NextActivityPerformers.First().Key;
var jumpBackActivityInstance = aim.GetActivityInstanceLatest(runningNode.ProcessInstanceID, jumpBackActivityGUID);
if (jumpBackActivityInstance != null)
{
//跳转到曾经执行过的节点上,可以作为跳回方式处理
rmins.IsBackward = true;
rmins.BackwardContext.ProcessInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID);
rmins.BackwardContext.BackwardToTaskActivity = processModel.GetActivity(jumpBackActivityGUID);
//获取当前运行节点的上一步节点
bool hasGatewayNode = false;
var tim = new TransitionInstanceManager();
var lastTaskTransitionInstance = tim.GetLastTaskTransition(runner.AppName,
runner.AppInstanceID, runner.ProcessGUID);
var npc = new PreviousStepChecker();
var previousActivityInstance = npc.GetPreviousActivityInstanceList(runningNode, true,
out hasGatewayNode).ToList()[0];
//仅仅是回跳到上一步节点，即按SendBack方式处理
if (previousActivityInstance.ActivityGUID == jumpBackActivityGUID)
{
rmins.BackwardContext.BackwardToTaskActivityInstance = previousActivityInstance;
rmins.BackwardContext.BackwardToTargetTransitionGUID =
hasGatewayNode == false ? lastTaskTransitionInstance.TransitionGUID : WfDefine.WF_XPDL_GATEWAY_BYPASS_GUID; //如果中间有Gateway节点，则没有直接相连的TransitonGUID
rmins.BackwardContext.BackwardFromActivity = processModel.GetActivity(runningNode.ActivityGUID);
rmins.BackwardContext.BackwardFromActivityInstance = runningNode;
rmins.BackwardContext.BackwardTaskReceiver = WfBackwardTaskReceiver.Instance(
previousActivityInstance.ActivityName,
previousActivityInstance.EndedByUserID,
previousActivityInstance.EndedByUserName);
rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(
previousActivityInstance.ActivityGUID,
previousActivityInstance.EndedByUserID,
previousActivityInstance.EndedByUserName);
}
else
{
//回跳到早前节点
if (jumpBackActivityInstance.ActivityState != (short)ActivityStateEnum.Completed)
{
//回跳节点不在完成状态
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Jump_NotActivityBackCompleted;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceJump.back.error");
return(rmins);
}
rmins.BackwardContext.BackwardToTaskActivityInstance = jumpBackActivityInstance;
//判断两个节点是否有Transition的定义存在
var transition = processModel.GetForwardTransition(runningNode.ActivityGUID, jumpBackActivityGUID);
rmins.BackwardContext.BackwardToTargetTransitionGUID = transition != null ? transition.TransitionGUID : WfDefine.WF_XPDL_GATEWAY_BYPASS_GUID;
rmins.BackwardContext.BackwardFromActivity = processModel.GetActivity(runningNode.ActivityGUID);
rmins.BackwardContext.BackwardFromActivityInstance = runningNode;
rmins.BackwardContext.BackwardTaskReceiver = WfBackwardTaskReceiver.Instance(
jumpBackActivityInstance.ActivityName,
jumpBackActivityInstance.EndedByUserID,
jumpBackActivityInstance.EndedByUserName);
rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(
jumpBackActivityInstance.ActivityGUID,
jumpBackActivityInstance.EndedByUserID,
jumpBackActivityInstance.EndedByUserName);
}
//获取资源数据
var activityResourceBack = new ActivityResource(rmins.AppRunner,
rmins.AppRunner.NextActivityPerformers,
runner.Conditions);
rmins.ActivityResource = activityResourceBack;
}
else
{
//跳转到从未执行过的节点上
var activityResource = new ActivityResource(runner, runner.NextActivityPerformers, runner.Conditions);
rmins.ActivityResource = activityResource;
rmins.RunningActivityInstance = runningNode;
}
#endregion
return(rmins);
}
/// <summary>
/// 退回操作
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="result">结果对象</param>
/// <returns>运行时实例对象</returns>
internal static WfRuntimeManager CreateRuntimeInstanceSendBack(WfAppRunner runner,
ref WfExecutedResult result)
{
var rmins = new WfRuntimeManagerSendBack();
rmins.WfExecutedResult = result = new WfExecutedResult();
//没有指定退回节点信息
if (runner.NextPerformerType != NextPerformerIntTypeEnum.Traced &&
(runner.NextActivityPerformers == null || runner.NextActivityPerformers.Count == 0))
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsNull;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.null.error");
return(rmins);
}
//先查找当前用户正在办理的运行节点
var aim = new ActivityInstanceManager();
TaskViewEntity taskView = null;
var runningNode = aim.GetRunningNode(runner, out taskView);
if (runningNode == null)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotInRunning;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.nonerun.error");
return(rmins);
}
if (aim.IsMineTask(runningNode, runner.UserID) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotMineTask;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.nonetask.error");
return(rmins);
}
var activityType = EnumHelper.ParseEnum <ActivityTypeEnum>(runningNode.ActivityType.ToString());
if (XPDLHelper.IsSimpleComponentNode(activityType) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotTaskNode;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.nottask.error");
return(rmins);
}
//获取上一步节点信息
var hasGatewayPassed = false;
var processInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID);
var processModel = ProcessModelFactory.Create(processInstance.ProcessGUID, processInstance.Version);
var previousStepChecker = new PreviousStepChecker();
var previousActivityList = previousStepChecker.GetPreviousActivityList(runningNode, processModel, out hasGatewayPassed);
//判断退回是否有效
if (previousActivityList == null || previousActivityList.Count == 0)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsNull;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.empty.error");
return(rmins);
}
//前端用户指定退回步骤的模式
if (runner.NextPerformerType != NextPerformerIntTypeEnum.Traced)
{
if (runner.NextActivityPerformers == null || runner.NextActivityPerformers.Count == 0)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsNull;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.noneperformer.error");
return(rmins);
}
//检查节点是否一致
if (previousActivityList.Count == 1)
{
var onlyActivityGUID = previousActivityList[0].ActivityGUID;
var isOnly = true;
foreach (var step in runner.NextActivityPerformers)
{
if (step.Key != onlyActivityGUID)
{
isOnly = false;
break;
}
}
//存在不一致的退回节点
if (isOnly == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsTooManyPrevious;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.notunique.error");
return(rmins);
}
}
}
else
{
//Traced 用于直接返回上一步使用，测试模式
var prevActivity = previousActivityList[0];
var performerList = PerformerBuilder.CreatePerformerList(runningNode.CreatedByUserID, runningNode.CreatedByUserName);
runner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(prevActivity.ActivityGUID, performerList);
}
//创建运行时
rmins.TaskView = taskView;
rmins.RunningActivityInstance = runningNode;
rmins.ProcessInstanceID = runningNode.ProcessInstanceID;
rmins.ProcessInstance = processInstance;
rmins.ProcessModel = processModel;
rmins.AppRunner.AppName = runner.AppName;
rmins.AppRunner.AppInstanceID = runner.AppInstanceID;
rmins.AppRunner.UserID = runner.UserID;
rmins.AppRunner.UserName = runner.UserName;
rmins.AppRunner.NextActivityPerformers = runner.NextActivityPerformers;
//设置退回选项类
var sendbackOperation = new SendBackOperation();
sendbackOperation.BackwardType = BackwardTypeEnum.Sendback;
sendbackOperation.ProcessInstance = processInstance;
sendbackOperation.BackwardFromActivityInstance = runningNode;
sendbackOperation.HasGatewayPassed = hasGatewayPassed;
sendbackOperation.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers);
sendbackOperation.ProcessModel = processModel;
sendbackOperation.IsCancellingBrothersNode = (runner.ControlParameterSheet != null &&
runner.ControlParameterSheet.IsCancellingBrothersNode == 1) ? true : false;
rmins.SendBackOperation = sendbackOperation;
return(rmins);
}
/// <summary>
/// 创建撤销处理运行时
/// </summary>
/// <param name="runner">撤销人</param>
/// <param name="result">创建结果</param>
/// <returns>运行时管理器</returns>
internal static WfRuntimeManager CreateRuntimeInstanceWithdraw(WfAppRunner runner,
ref WfExecutedResult result)
{
var rmins = new WfRuntimeManagerSendBack();
rmins.WfExecutedResult = result = new WfExecutedResult();
if (runner.TaskID == null)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Withdraw_ErrorArguments;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceWithdraw.missingtaskid.error");
return(rmins);
}
//获取已经完成任务的信息
var tm = new TaskManager();
var taskDone = tm.GetTaskView(runner.TaskID.Value);
if (tm.IsMine(taskDone, runner.UserID) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotMineTask;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceWithdraw.nonetask.error");
return(rmins);
}
//赋值下一步办理列表
runner.NextActivityPerformers = NextStepUtility.CreateNextStepPerformerList(taskDone.ActivityGUID,
taskDone.AssignedToUserID, taskDone.AssignedToUserName);
//没有指定退回节点信息
if (runner.NextActivityPerformers == null || runner.NextActivityPerformers.Count == 0)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsNull;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceWithdraw.noneperformer.error");
return(rmins);
}
//获取待办任务
var tim = new TransitionInstanceManager();
var nextStepList = tim.GetTargetActivityInstanceList(taskDone.ActivityInstanceID).ToList();
ActivityInstanceEntity runningNode = nextStepList.Count > 0 ? nextStepList[0] : null;
if (runningNode == null)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotInRunning;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceWithdraw.nonerun.error");
return(rmins);
}
var activityType = EnumHelper.ParseEnum <ActivityTypeEnum>(runningNode.ActivityType.ToString());
if (XPDLHelper.IsSimpleComponentNode(activityType) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotTaskNode;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceWithdraw.nottask.error");
return(rmins);
}
//获取待办任务(模拟待办任务用户做退回处理)
var taskToDo = tm.GetTaskViewByActivity(runningNode.ProcessInstanceID, runningNode.ID);
runner.UserID = taskToDo.AssignedToUserID;
runner.UserName = taskToDo.AssignedToUserName;
//获取上一步节点信息
var hasGatewayPassed = false;
var processInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID);
var previousStepChecker = new PreviousStepChecker();
var processModel = ProcessModelFactory.Create(taskToDo.ProcessGUID, taskToDo.Version);
var previousActivityList = previousStepChecker.GetPreviousActivityList(runningNode, processModel, out hasGatewayPassed);
//判断退回是否有效
if (previousActivityList == null || previousActivityList.Count == 0)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsNull;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceWithdraw.empty.error");
return(rmins);
}
//检查节点是否一致
if (previousActivityList.Count == 1)
{
var onlyActivityGUID = previousActivityList[0].ActivityGUID;
var isOnly = true;
foreach (var step in runner.NextActivityPerformers)
{
if (step.Key != onlyActivityGUID)
{
isOnly = false;
break;
}
}
//存在不一致的退回节点
if (isOnly == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsTooManyPrevious;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceWithdraw.notunique.error");
return(rmins);
}
}
//创建运行时
rmins.TaskView = taskToDo;
rmins.RunningActivityInstance = runningNode;
rmins.ProcessInstanceID = runningNode.ProcessInstanceID;
rmins.ProcessInstance = processInstance;
rmins.ProcessModel = processModel;
rmins.AppRunner.AppName = runner.AppName;
rmins.AppRunner.AppInstanceID = runner.AppInstanceID;
rmins.AppRunner.UserID = runner.UserID;
rmins.AppRunner.UserName = runner.UserName;
rmins.AppRunner.NextActivityPerformers = runner.NextActivityPerformers;
//设置退回选项类
var sendbackOperation = new SendBackOperation();
sendbackOperation.BackwardType = BackwardTypeEnum.Withdrawed;
sendbackOperation.ProcessInstance = processInstance;
sendbackOperation.BackwardFromActivityInstance = runningNode;
sendbackOperation.HasGatewayPassed = hasGatewayPassed;
sendbackOperation.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers);
sendbackOperation.ProcessModel = processModel;
sendbackOperation.IsCancellingBrothersNode = true; //撤销时默认撤销各个并行分支
rmins.SendBackOperation = sendbackOperation;
return(rmins);
}
/// <summary>
/// 根据应用获取流程下一步节点列表，包含角色用户
/// </summary>
/// <param name="resourceService">资源服务</param>
/// <param name="runner">应用执行人</param>
/// <param name="condition">条件</param>
/// <returns>节点列表</returns>
internal IList <NodeView> GetNextActivityRoleUserTree(IResourceService resourceService,
WfAppRunner runner,
IDictionary <string, string> condition = null)
{
//判断应用数据是否缺失
if (string.IsNullOrEmpty(runner.AppInstanceID) ||
string.IsNullOrEmpty(runner.ProcessGUID))
{
throw new WorkflowException(LocalizeHelper.GetEngineMessage("nextstepparser.getnextactivityroleusertree.error"));
}
//条件参数一致
if (condition == null && runner.Conditions != null)
{
condition = runner.Conditions;
}
IList <NodeView> nextSteps = new List <NodeView>();
IProcessModel processModel = ProcessModelFactory.Create(runner.ProcessGUID, runner.Version);
using (var session = SessionFactory.CreateSession())
{
var pim = new ProcessInstanceManager();
var processInstanceList = pim.GetProcessInstance(session.Connection,
runner.AppInstanceID,
runner.ProcessGUID,
session.Transaction).ToList();
var processInstanceEntity = EnumHelper.GetFirst <ProcessInstanceEntity>(processInstanceList);
//判断流程是否创建还是已经运行
if (processInstanceEntity != null &&
processInstanceEntity.ProcessState == (short)ProcessStateEnum.Running)
{
//运行状态的流程实例
var tm = new TaskManager();
TaskViewEntity taskView = tm.GetTaskOfMine(session.Connection, runner, session.Transaction);
//获取下一步列表
nextSteps = processModel.GetNextActivityTree(taskView.ActivityGUID, condition);
foreach (var ns in nextSteps)
{
if (ns.ReceiverType == ReceiverTypeEnum.ProcessInitiator) //下一步执行人为流程发起人
{
ns.Users = AppendUserList(ns.Users, pim.GetProcessInitiator(session.Connection,
taskView.ProcessInstanceID,
session.Transaction)); //获取流程发起人
}
else
{
var roleIDs = ns.Roles.Select(x => x.ID).ToArray();
if (roleIDs.Count() > 0)
{
ns.Users = resourceService.GetUserListByRoleReceiverType(roleIDs, runner.UserID, (int)ns.ReceiverType); //增加转移前置过滤条件
}
}
}
}
else
{
//流程准备启动，获取第一个办理节点的用户列表
var firstActivity = processModel.GetFirstActivity();
nextSteps = processModel.GetNextActivityTree(firstActivity.ActivityGUID,
condition);
foreach (var ns in nextSteps)
{
var roleIDs = ns.Roles.Select(x => x.ID).ToArray();
ns.Users = resourceService.GetUserListByRoleReceiverType(roleIDs, runner.UserID, (int)ns.ReceiverType); //增加转移前置过滤条件
}
}
}
return(nextSteps);
}
/// <summary>
/// 保存泳道流程
/// </summary>
/// <param name="file">泳道流程实体</param>
internal void SaveProcessFilePool(ProcessFilePool file)
{
var packageProcessClient = file.ProcessEntityList.Single(a => a.PackageType.Value == (short)PackageTypeEnum.MainProcess);
var poolProcessListClient = file.ProcessEntityList.Where(a => a.PackageType.Value == (short)PackageTypeEnum.PoolProcess).ToList();
var session = SessionFactory.CreateSession();
try
{
session.BeginTrans();
var packageProcessDB = GetByVersion(session.Connection, packageProcessClient.ProcessGUID, packageProcessClient.Version,
false, session.Transaction);
if (packageProcessDB == null)
{
//插入主流程，然后插入泳道流
var packageGUID = Guid.NewGuid().ToString();
packageProcessClient.XmlContent = file.XmlContent;
packageProcessClient.CreatedDateTime = System.DateTime.Now;
var processModelClient = ProcessModelFactory.Create(session.Connection, packageProcessClient.ProcessGUID, packageProcessClient.Version, session.Transaction);
SetProcessStartEndType(processModelClient, packageProcessClient, file.XmlContent);
var newPackageProcessID = Insert(session.Connection, packageProcessClient, session.Transaction);
foreach (var pool in poolProcessListClient)
{
pool.PackageProcessID = newPackageProcessID;
pool.XmlContent = file.XmlContent;
var processModelPool = ProcessModelFactory.Create(session.Connection, pool.ProcessGUID, pool.Version, session.Transaction);
SetProcessStartEndType(processModelPool, pool, file.XmlContent);
Insert(session.Connection, pool, session.Transaction);
}
}
else
{
var poolProcessListDataBase = GetPoolProcessList(session.Connection, packageProcessDB.ID, session.Transaction);
List <int> poolProcessIDs = new List <int>();
foreach (var pool in poolProcessListDataBase)
{
//多泳道流程变为单一流程
if (poolProcessListClient.Count() == 0)
{
//删除数据库中所有泳道流程
poolProcessIDs.Add(pool.ID);
}
else
{
var item = poolProcessListClient.Find(a => a.ProcessGUID == pool.ProcessGUID && a.Version == pool.Version);
if (item == null)
{
//删除ID列表
poolProcessIDs.Add(pool.ID);
}
}
}
//删除图形中不含有的泳道流程
if (poolProcessIDs.Count() > 0)
{
DeletePoolProcess(session.Connection, packageProcessDB.ID, poolProcessIDs, session.Transaction);
}
//如果是泳道流程变为单一流程，更新PackageType和PackageProcessID
if (poolProcessListClient.Count() == 0)
{
packageProcessDB.PackageType = null;
packageProcessDB.PackageProcessID = null;
}
//更新主流程，更新或插入泳道流
packageProcessDB.PackageType = (byte)PackageTypeEnum.MainProcess;
packageProcessDB.XmlContent = file.XmlContent;
packageProcessDB.LastUpdatedDateTime = System.DateTime.Now;
var processModelPackageDB = ProcessModelFactory.Create(session.Connection, packageProcessDB.ProcessGUID, packageProcessDB.Version, session.Transaction);
SetProcessStartEndType(processModelPackageDB, packageProcessDB, file.XmlContent);
Update(session.Connection, packageProcessDB, session.Transaction);
foreach (var pool in poolProcessListClient)
{
var child = GetByVersion(session.Connection, pool.ProcessGUID, pool.Version, false, session.Transaction);
if (child == null)
{
//新增泳道流程
pool.PackageType = (byte)PackageTypeEnum.PoolProcess;
pool.PackageProcessID = packageProcessDB.ID;
pool.XmlContent = file.XmlContent;
pool.CreatedDateTime = System.DateTime.Now;
var processModelPoolA = ProcessModelFactory.Create(session.Connection, pool.ProcessGUID, pool.Version, session.Transaction);
SetProcessStartEndType(processModelPoolA, pool, file.XmlContent);
Insert(session.Connection, pool, session.Transaction);
}
else
{
//更新泳道流程
child.ProcessName = pool.ProcessName;
child.ProcessCode = pool.ProcessCode;
child.Description = pool.Description;
child.PackageType = (byte)PackageTypeEnum.PoolProcess;
child.XmlContent = file.XmlContent;
child.LastUpdatedDateTime = System.DateTime.Now;
var processModelPoolChild = ProcessModelFactory.Create(session.Connection, child.ProcessGUID, child.Version, session.Transaction);
SetProcessStartEndType(processModelPoolChild, child, file.XmlContent);
Update(session.Connection, child, session.Transaction);
}
}
}
session.Commit();
}
catch (System.Exception ex)
{
session.Rollback();
throw;
}
finally
{
session.Dispose();
}
}
/// <summary>
/// 获取当前活动实体
/// </summary>
/// <param name="processGUID">流程定义GUID</param>
/// <param name="version">版本</param>
/// <param name="activityGUID">活动GUID</param>
/// <returns>活动</returns>
public ActivityEntity GetActivityEntity(string processGUID, string version, string activityGUID)
{
var processModel = ProcessModelFactory.Create(processGUID, version);
return(processModel.GetActivity(activityGUID));
}
/// <summary>
/// 根据不同退回场景创建运行时管理器
/// </summary>
/// <param name="runningActivityInstanceList">运行节点列表</param>
/// <param name="sendbackOperation">退回类型</param>
/// <param name="runner">执行者</param>
/// <param name="result">结果对象</param>
/// <returns>运行时管理器</returns>
private static WfRuntimeManager CreateRuntimeInstanceSendbackByCase(
List <ActivityInstanceEntity> runningActivityInstanceList,
SendbackOperationTypeEnum sendbackOperation,
WfAppRunner runner,
ref WfExecutedResult result)
{
WfRuntimeManager rmins = new WfRuntimeManagerSendBack();
rmins.WfExecutedResult = result = new WfExecutedResult();
ActivityInstanceEntity runningNode = runningActivityInstanceList.Where(x => x.ActivityState == (int)ActivityStateEnum.Running).OrderBy(x => x.ID).FirstOrDefault();
if (runningNode == null)
{
runningNode = runningActivityInstanceList[0];
}
ProcessInstanceEntity processInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID);
IProcessModel processModel = ProcessModelFactory.Create(processInstance.ProcessGUID, processInstance.Version);
var aim = new ActivityInstanceManager();
//以下处理，需要知道上一步是独立节点的信息
//获取上一步流转节点信息，可能经过And, Or等路由节点
var tim = new TransitionInstanceManager();
bool hasGatewayNode = false;
var currentNode = runningNode;
var lastActivityInstanceList = tim.GetPreviousActivityInstance(currentNode, true, out hasGatewayNode).ToList();
if (lastActivityInstanceList == null || lastActivityInstanceList.Count == 0 || lastActivityInstanceList.Count > 1)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NullOrHasTooMany;
result.Message = "当前没有可以退回的节点，或者有多个可以退回的节点，无法选择！";
return(rmins);
}
TransitionInstanceEntity lastTaskTransitionInstance = tim.GetLastTaskTransition(runner.AppName,
runner.AppInstanceID, runner.ProcessGUID);
if (lastTaskTransitionInstance.TransitionType == (short)TransitionTypeEnum.Loop)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsLoopNode;
result.Message = "当前流转是自循环，无需退回！";
return(rmins);
}
//设置退回节点的相关信息
var previousActivityInstance = lastActivityInstanceList[0];
if (previousActivityInstance.ActivityType == (short)ActivityTypeEnum.StartNode)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_PreviousIsStartNode;
result.Message = "上一步是开始节点，无需退回！";
return(rmins);
}
if (sendbackOperation == SendbackOperationTypeEnum.Normal)
{
//简单串行模式下的退回
rmins = new WfRuntimeManagerSendBack();
rmins.WfExecutedResult = result = new WfExecutedResult();
rmins.ProcessModel = processModel;
rmins.BackwardContext.ProcessInstance = processInstance;
rmins.BackwardContext.BackwardToTaskActivity = processModel.GetActivity(previousActivityInstance.ActivityGUID);
rmins.BackwardContext.BackwardToTaskActivityInstance = previousActivityInstance;
rmins.BackwardContext.BackwardToTargetTransitionGUID =
hasGatewayNode == false ? lastTaskTransitionInstance.TransitionGUID : String.Empty; //如果中间有Gateway节点，则没有直接相连的TransitonGUID
rmins.BackwardContext.BackwardFromActivity = processModel.GetActivity(runningNode.ActivityGUID);
rmins.BackwardContext.BackwardFromActivityInstance = runningNode;
rmins.BackwardContext.BackwardTaskReceiver = WfBackwardTaskReceiver.Instance(previousActivityInstance.ActivityName,
previousActivityInstance.EndedByUserID, previousActivityInstance.EndedByUserName);
//封装AppUser对象
rmins.AppRunner.AppName = runner.AppName;
rmins.AppRunner.AppInstanceID = runner.AppInstanceID;
rmins.AppRunner.ProcessGUID = runner.ProcessGUID;
rmins.AppRunner.UserID = runner.UserID;
rmins.AppRunner.UserName = runner.UserName;
rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(previousActivityInstance.ActivityGUID,
previousActivityInstance.EndedByUserID,
previousActivityInstance.EndedByUserName);
rmins.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers);
return(rmins);
}
//如果有其它模式，没有处理到，则直接抛出异常
throw new WorkflowException("未知的退回场景，请报告给技术支持人员！");
}
/// <summary>
/// 流程返签，先检查约束条件，然后调用wfruntimeinstance执行
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="result">结果对象</param>
/// <returns>运行时实例对象</returns>
public static WfRuntimeManager CreateRuntimeInstanceReverse(WfAppRunner runner,
ref WfExecutedResult result)
{
var rmins = new WfRuntimeManagerReverse();
rmins.WfExecutedResult = result = new WfExecutedResult();
var pim = new ProcessInstanceManager();
var processInstance = pim.GetProcessInstanceLatest(runner.AppInstanceID, runner.ProcessGUID);
if (processInstance == null || processInstance.ProcessState != (short)ProcessStateEnum.Completed)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Reverse_NotInCompleted;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceReverse.error");
return(rmins);
}
//用于注册事件时候的流程ID
rmins.ProcessInstanceID = processInstance.ID;
var tim = new TransitionInstanceManager();
var endTransitionInstance = tim.GetEndTransition(runner.AppName, runner.AppInstanceID, runner.ProcessGUID);
var processModel = ProcessModelFactory.Create(processInstance.ProcessGUID, processInstance.Version);
var endActivity = processModel.GetActivity(endTransitionInstance.ToActivityGUID);
var aim = new ActivityInstanceManager();
var endActivityInstance = aim.GetById(endTransitionInstance.ToActivityInstanceID);
bool hasGatewayNode = false;
var npc = new PreviousStepChecker();
var lastTaskActivityInstance = npc.GetPreviousActivityInstanceList(endActivityInstance, false,
out hasGatewayNode).ToList()[0];
var lastTaskActivity = processModel.GetActivity(lastTaskActivityInstance.ActivityGUID);
//封装返签结束点之前办理节点的任务接收人
rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(lastTaskActivityInstance.ActivityGUID,
lastTaskActivityInstance.EndedByUserID,
lastTaskActivityInstance.EndedByUserName);
rmins.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers);
rmins.AppRunner.AppName = runner.AppName;
rmins.AppRunner.AppInstanceID = runner.AppInstanceID;
rmins.AppRunner.ProcessGUID = runner.ProcessGUID;
rmins.AppRunner.UserID = runner.UserID;
rmins.AppRunner.UserName = runner.UserName;
rmins.BackwardContext.ProcessInstance = processInstance;
rmins.BackwardContext.BackwardToTaskActivity = lastTaskActivity;
rmins.BackwardContext.BackwardToTaskActivityInstance = lastTaskActivityInstance;
rmins.BackwardContext.BackwardToTargetTransitionGUID =
hasGatewayNode == false ? endTransitionInstance.TransitionGUID : String.Empty;
rmins.BackwardContext.BackwardFromActivity = endActivity;
rmins.BackwardContext.BackwardFromActivityInstance = endActivityInstance;
rmins.BackwardContext.BackwardTaskReceiver = WfBackwardTaskReceiver.Instance(lastTaskActivityInstance.ActivityName,
lastTaskActivityInstance.EndedByUserID,
lastTaskActivityInstance.EndedByUserName);
return(rmins);
}
