/// <summary>
/// 获取正在运行中的活动实例
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public IList <ActivityInstanceEntity> GetRunningActivityInstance(TaskQuery query)
{
var aim = new ActivityInstanceManager();
var list = aim.GetRunningActivityInstanceList(query.AppInstanceID, query.ProcessGUID).ToList();
return(list);
}
/// <summary>
/// 获取分支实例的个数
/// </summary>
/// <param name="splitActivityGUID">活动GUID</param>
/// <param name="processInstanceID">流程实例ID</param>
/// <returns>实例数目</returns>
protected int GetInstanceGatewayCount(string splitActivityGUID,
int processInstanceID)
{
ActivityInstanceManager aim = new ActivityInstanceManager();
return(aim.GetInstanceGatewayCount(splitActivityGUID, processInstanceID));
}
/// <summary>
/// 查询实例
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="id">实体主键ID</param>
/// <returns>实体</returns>
public override T GetInstance <T>(int id)
{
var aim = new ActivityInstanceManager();
var entity = aim.GetById(Session.Connection, id, Session.Transaction);
return(entity as T);
}
/// <summary>
/// 跳转执行方法
/// </summary>
/// <param name="session">会话</param>
internal override void ExecuteInstanceImp(IDbSession session)
{
WfExecutedResult result = base.WfExecutedResult;
//创建新任务节点
var nodeMediatorBackward = new NodeMediatorBackward(base.BackwardContext, session);
nodeMediatorBackward.CreateBackwardActivityTaskTransitionInstance(base.BackwardContext.ProcessInstance,
base.BackwardContext.BackwardFromActivityInstance,
BackwardTypeEnum.Sendback,
base.BackwardContext.BackwardToTargetTransitionGUID,
TransitionTypeEnum.Sendback,
TransitionFlyingTypeEnum.NotFlying,
base.ActivityResource,
session);
//更新当前办理节点的状态（从准备或运行状态更新为退回状态）
var aim = new ActivityInstanceManager();
aim.SendBack(base.BackwardContext.BackwardFromActivityInstance.ID,
base.ActivityResource.AppRunner,
session);
//构造回调函数需要的数据
result.BackwardTaskReceiver = base.BackwardContext.BackwardTaskReceiver;
result.Status = WfExecutedStatus.Success;
}
/// <summary>
/// 撤销处理具体功能实现
/// </summary>
/// <param name="session">会话</param>
internal override void ExecuteInstanceImp(IDbSession session)
{
//创建新任务节点
var backMostPreviouslyActivityInstanceID = GetBackwardMostPreviouslyActivityInstanceID();
var nodeMediatorBackward = new NodeMediatorBackward(base.BackwardContext, session);
nodeMediatorBackward.CreateBackwardActivityTaskTransitionInstance(base.BackwardContext.ProcessInstance,
base.BackwardContext.BackwardFromActivityInstance,
BackwardTypeEnum.Withdrawed,
backMostPreviouslyActivityInstanceID,
base.BackwardContext.BackwardToTargetTransitionGUID,
TransitionTypeEnum.Withdrawed,
TransitionFlyingTypeEnum.NotFlying,
base.ActivityResource,
session);
//普通节点情况下：更新撤销节点的状态（从准备状态更新为撤销状态）
var aim = new ActivityInstanceManager();
aim.Withdraw(base.BackwardContext.BackwardFromActivityInstance.ID,
base.ActivityResource.AppRunner, session);
//构造回调函数需要的数据
WfExecutedResult result = base.WfExecutedResult;
result.BackwardTaskReceiver = base.BackwardContext.BackwardTaskReceiver;
result.Status = WfExecutedStatus.Success;
}
/// <summary>
/// 获取活动实例数据
/// </summary>
/// <param name="activityInstanceID"></param>
/// <returns></returns>
public ActivityInstanceEntity GetActivityInstance(int activityInstanceID)
{
var aim = new ActivityInstanceManager();
var instance = aim.GetById(activityInstanceID);
return(instance);
}
/// <summary>
/// 获取流程当前运行节点信息
/// </summary>
/// <param name="runner"></param>
/// <returns></returns>
public ActivityInstanceEntity GetRunningNode(WfAppRunner runner)
{
var aim = new ActivityInstanceManager();
var entity = aim.GetRunningNode(runner);
return(entity);
}
/// <summary>
/// 判断是否是我的任务
/// </summary>
/// <param name="entity"></param>
/// <param name="userID"></param>
/// <returns></returns>
public bool IsMineTask(ActivityInstanceEntity entity, string userID)
{
var aim = new ActivityInstanceManager();
bool isMine = aim.IsMineTask(entity, userID);
return(isMine);
}
public bool TurnTask(string taskId, WfAppRunner runner)
{
TaskManager tim = new TaskManager(_dataAccessor, _loggerFactory);
WfTask task = tim.GetTask(taskId);
if (task == null)
{
throw new FapException("任务不存在");
}
Performer turner = runner.Turners[0];
ActivityInstanceManager aim = new ActivityInstanceManager(_dataAccessor, _loggerFactory);
WfActivityInstance activity = aim.GetByFid(task.ActivityInsUid);
activity.AssignedToUserIds = activity.AssignedToUserIds.Replace(runner.UserId, turner.UserId);
activity.AssignedToUserNames = activity.AssignedToUserNames.Replace(runner.UserName, turner.UserName);
aim.Update(activity);
task.ExecutorEmpUid = turner.UserId;
task.ExecutorEmpName = turner.UserName;
task.UpdateBy = runner.UserId;
task.UpdateName = runner.UserName;
task.UpdateDate = DateTimeUtils.CurrentDateStr;
tim.Update(task);
TaskAdviceManager tam = new TaskAdviceManager(_dataAccessor, _applicationContext, _loggerFactory);
tam.RecordWhenTurnTask(runner.ProcessUid, runner.CurrNodeId, runner.Comment, turner.UserId, turner.UserName);
return(true);
}
/// <summary>
/// 退回操作的处理逻辑
/// </summary>
/// <param name="session">会话</param>
internal override void ExecuteInstanceImp(IDbSession session)
{
var nodeMediatorBackward = new NodeMediatorBackward(base.BackwardContext, session);
var aim = new ActivityInstanceManager();
var backMostPreviouslyActivityInstanceID = GetBackwardMostPreviouslyActivityInstanceID();
//上一步节点是普通节点的退回处理
nodeMediatorBackward.CreateBackwardActivityTaskTransitionInstance(base.BackwardContext.ProcessInstance,
base.BackwardContext.BackwardFromActivityInstance,
BackwardTypeEnum.Sendback,
backMostPreviouslyActivityInstanceID,
base.BackwardContext.BackwardToTargetTransitionGUID,
TransitionTypeEnum.Sendback,
TransitionFlyingTypeEnum.NotFlying,
base.ActivityResource,
session);
//更新当前办理节点的状态（从准备或运行状态更新为退回状态）
aim.SendBack(base.BackwardContext.BackwardFromActivityInstance.ID,
base.ActivityResource.AppRunner,
session);
//构造回调函数需要的数据
WfExecutedResult result = base.WfExecutedResult;
result.BackwardTaskReceiver = base.BackwardContext.BackwardTaskReceiver;
result.ReturnDataContext = nodeMediatorBackward.ReturnDataContext;
result.Status = WfExecutedStatus.Success;
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="sendbackOperation">退回选项</param>
/// <param name="session">数据会话</param>
internal NodeSendBack(SendBackOperation sendbackOperation, IDbSession session)
{
_sendBackOperation = sendbackOperation;
_session = session;
_activityInstanceManager = new ActivityInstanceManager();
_taskManager = new TaskManager();
_transitionInstanceManager = new TransitionInstanceManager();
}
/// <summary>
/// 跳转执行方法
/// </summary>
/// <param name="session">会话</param>
internal override void ExecuteInstanceImp(IDbSession session)
{
WfExecutedResult result = base.WfExecutedResult;
//回跳类型的处理
if (base.IsBackward == true)
{
//创建新任务节点
var nodeMediatorBackward = new NodeMediatorBackward(base.BackwardContext, session);
nodeMediatorBackward.CreateBackwardActivityTaskTransitionInstance(base.BackwardContext.ProcessInstance,
base.BackwardContext.BackwardFromActivityInstance,
BackwardTypeEnum.Sendback,
base.BackwardContext.BackwardToTargetTransitionGUID,
TransitionTypeEnum.Sendback,
TransitionFlyingTypeEnum.NotFlying,
base.ActivityResource,
session);
//更新当前办理节点的状态（从准备或运行状态更新为退回状态）
var aim = new ActivityInstanceManager();
aim.SendBack(base.BackwardContext.BackwardFromActivityInstance.ID,
base.ActivityResource.AppRunner,
session);
//构造回调函数需要的数据
result.BackwardTaskReceiver = base.BackwardContext.BackwardTaskReceiver;
result.Status = WfExecutedStatus.Success;
}
else
{
var jumpActivityGUID = base.AppRunner.NextActivityPerformers.First().Key;
var jumpforwardActivity = base.ProcessModel.GetActivity(jumpActivityGUID);
var processInstance = (new ProcessInstanceManager()).GetById(base.RunningActivityInstance.ProcessInstanceID);
var jumpforwardExecutionContext = ActivityForwardContext.CreateJumpforwardContext(jumpforwardActivity,
base.ProcessModel, processInstance, base.ActivityResource);
NodeMediator mediator = NodeMediatorFactory.CreateNodeMediator(jumpforwardExecutionContext, session);
mediator.Linker.FromActivityInstance = base.RunningActivityInstance;
mediator.Linker.ToActivity = jumpforwardActivity;
if (mediator is NodeMediatorEnd)
{
//结束节点的连线转移
mediator.CreateActivityTaskTransitionInstance(jumpforwardActivity,
processInstance,
base.RunningActivityInstance,
WfDefine.WF_XPDL_JUMP_BYPASS_GUID,
TransitionTypeEnum.Forward,
TransitionFlyingTypeEnum.ForwardFlying,
base.ActivityResource,
session);
}
mediator.ExecuteWorkItem();
result.Status = WfExecutedStatus.Success;
result.Message = mediator.GetNodeMediatedMessage();
}
}
/// <summary>
/// 退回操作
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="result">结果对象</param>
/// <returns>运行时实例对象</returns>
internal static WfRuntimeManager CreateRuntimeInstanceSendBack(WfAppRunner runner,
ref WfExecutedResult result)
{
WfRuntimeManager rmins = new WfRuntimeManagerSendBack();
rmins.WfExecutedResult = result = new WfExecutedResult();
var aim = new ActivityInstanceManager();
var runningActivityInstanceList = aim.GetRunningActivityInstanceList(runner.AppInstanceID, runner.ProcessGUID).ToList();
SendbackOpertaionTypeEnum sendbackOperation = SendbackOpertaionTypeEnum.Default;
//当前没有运行状态的节点存在，流程不存在，或者已经结束或取消
if (runningActivityInstanceList == null || runningActivityInstanceList.Count() == 0)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotInRunning;
result.Message = "当前没有运行状态的节点存在，流程不存在，或者已经结束或取消";
return(rmins);
}
if (runningActivityInstanceList.Count() == 1) //如果只有1个运行节点
{
var runningNode = runningActivityInstanceList[0];
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);
}
if (aim.IsMineTask(runningNode, runner.UserID) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotMineTask;
result.Message = "不是登录用户的任务，无法退回！";
return(rmins);
}
sendbackOperation = SendbackOpertaionTypeEnum.Normal;
}
else if (runningActivityInstanceList.Count() > 1)
{
//有其它非多实例的并行节点，暂时不处理，后期实现该功能
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NullOrHasTooMany;
result.Message = "有多个可以退回的节点，而且不是多实例节点，此功能暂时不支持！";
return(rmins);
}
//根据不同分支场景，创建不同撤销运行时管理器
return(CreateRuntimeInstanceSendbackByCase(runningActivityInstanceList, sendbackOperation, runner, ref result));
}
/// <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 = string.Format("当前应用:{0}，实例ID：{1}, 没有完成的流程实例，无法让流程重新运行！",
runner.AppName, runner.AppInstanceID);
return(rmins);
}
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 lastTaskActivityInstance = tim.GetPreviousActivityInstance(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);
}
/// <summary>
/// 节点对象的完成方法
/// </summary>
/// <param name="ActivityInstanceID">活动实例ID</param>
/// <param name="runner">运行者</param>
/// <param name="session">会话</param>
protected virtual void CompleteActivityInstance(int ActivityInstanceID,
WfAppRunner runner,
IDbSession session)
{
//设置完成状态
ActivityInstanceManager.Complete(ActivityInstanceID,
runner,
session);
}
/// <summary>
/// 设置活动实例的定时作业为完成状态
/// (用于HangFire后台轮询任务)
/// </summary>
/// <param name="conn">链接</param>
/// <param name="activityInstanceID">活动实例ID</param>
/// <param name="trans">事务</param>
public void SetActivityJobTimerCompleted(IDbConnection conn, int activityInstanceID, IDbTransaction trans)
{
var aim = new ActivityInstanceManager();
var activityInstance = aim.GetById(conn, activityInstanceID, trans);
activityInstance.JobTimerStatus = (short)JobTimerStatusEnum.Completed;
activityInstance.JobTimerTreatedDateTime = System.DateTime.Now;
aim.Update(conn, activityInstance, trans);
}
/// <summary>
/// 读取节点的上一步节点信息
/// </summary>
/// <param name="runningNode">当前节点</param>
/// <param name="isLookUpBackSource">是否退回</param>
/// <param name="hasPassedGatewayNode">是否经由路由节点</param>
/// <returns>活动实例列表</returns>
internal IList <ActivityInstanceEntity> GetPreviousActivityInstanceList(ActivityInstanceEntity runningNode,
bool isLookUpBackSource,
out bool hasPassedGatewayNode)
{
hasPassedGatewayNode = false;
var tim = new TransitionInstanceManager();
var transitionList = tim.GetTransitionInstanceList(runningNode.AppInstanceID,
runningNode.ProcessGUID,
runningNode.ProcessInstanceID).ToList();
var backSrcActivityInstanceId = 0;
if (isLookUpBackSource == true)
{
//退回情况下的处理
if (runningNode.MIHostActivityInstanceID != null && runningNode.CompleteOrder.Value == 1)
{
//多实例的第一个子节点，先找到主节点，再到transition记录表中找到上一步节点
backSrcActivityInstanceId = runningNode.MIHostActivityInstanceID.Value;
}
else if (runningNode.BackSrcActivityInstanceID != null)
{
//节点时曾经发生退回的节点
backSrcActivityInstanceId = runningNode.BackSrcActivityInstanceID.Value;
}
else
{
backSrcActivityInstanceId = runningNode.ID;
}
}
else
{
backSrcActivityInstanceId = runningNode.ID;
}
var aim = new ActivityInstanceManager();
var runningTransitionList = transitionList
.Where(o => o.ToActivityInstanceID == backSrcActivityInstanceId)
.ToList();
IList <ActivityInstanceEntity> previousActivityInstanceList = new List <ActivityInstanceEntity>();
foreach (var entity in runningTransitionList)
{
//如果是逻辑节点，则继续查找
if (entity.FromActivityType == (short)ActivityTypeEnum.GatewayNode)
{
GetPreviousOfGatewayActivityInstance(transitionList, entity.FromActivityInstanceID, previousActivityInstanceList);
hasPassedGatewayNode = true;
}
else
{
previousActivityInstanceList.Add(aim.GetById(entity.FromActivityInstanceID));
}
}
return(previousActivityInstanceList);
}
/// <summary>
/// 获取上一步节点树
/// </summary>
/// <param name="runner">运行者</param>
/// <param name="hasGatewayPassed">是否经过网关</param>
/// <returns>上一步步骤列表</returns>
internal IList <NodeView> GetPreviousActivityTree(WfAppRunner runner, out Boolean hasGatewayPassed)
{
hasGatewayPassed = false;
//首先获取当前运行节点信息
var aim = new ActivityInstanceManager();
var runningNode = aim.GetRunningNode(runner);
var nodeList = GetPreviousActivityTree(runningNode, out hasGatewayPassed);
return(nodeList);
}
/// <summary>
/// 判断节点是否审批完成，可以进入下一个节点
/// </summary>
/// <param name="activityInsUid"></param>
/// <returns></returns>
public bool NodeIsComplete(string activityInsUid)
{
bool result = false;
ActivityInstanceManager activityInstanceManager = new ActivityInstanceManager(_dataAccessor, _loggerFactory);
result = activityInstanceManager.IsComplete(activityInsUid);
return(result);
}
/// <summary>
/// 判断节点是否审批完成，可以进入下一个节点
/// </summary>
/// <param name="activityInsUid"></param>
/// <returns></returns>
public bool NodeIsComplete(string activityInsUid)
{
bool result = false;
ActivityInstanceManager activityInstanceManager = new ActivityInstanceManager(_serviceProvider);
result = activityInstanceManager.IsComplete(activityInsUid);
return(result);
}
/// <summary>
/// 创建节点对象
/// </summary>
/// <param name="processInstance">流程实例</param>
/// <param name="activity">活动</param>
/// <param name="runner">执行者</param>
protected WfActivityInstance CreateActivityInstanceObject(ActivityEntity activity,
WfProcessInstance processInstance,
WfAppRunner runner)
{
WfActivityInstance entity = ActivityInstanceManager.CreateActivityInstanceObject(
processInstance,
activity,
runner);
return(entity);
}
/// <summary>
/// 创建节点对象
/// </summary>
/// <param name="activity">活动</param>
/// <param name="processInstance">流程实例</param>
/// <param name="runner">运行者</param>
protected WfActivityInstance CreateActivityInstanceObject(ActivityEntity activity,
WfProcessInstance processInstance)
{
ActivityInstanceManager aim = new ActivityInstanceManager(_serviceProvider);
this.GatewayActivityInstance = aim.CreateActivityInstanceObject(processInstance,
activity,
_runner);
return(this.GatewayActivityInstance);
}
/// <summary>
/// 创建节点对象
/// </summary>
/// <param name="activity">活动</param>
/// <param name="processInstance">流程实例</param>
/// <param name="runner">运行者</param>
protected WfActivityInstance CreateActivityInstanceObject(ActivityEntity activity,
WfProcessInstance processInstance)
{
ActivityInstanceManager aim = new ActivityInstanceManager(_dataAccessor, _loggerFactory);
this.GatewayActivityInstance = aim.CreateActivityInstanceObject(processInstance,
activity,
_runner);
return(this.GatewayActivityInstance);
}
/// <summary>
/// 加签操作
/// </summary>
/// <param name="runner"></param>
/// <param name="result"></param>
/// <returns></returns>
public static WfRuntimeManager CreateRuntimeInstanceSignForward(WfAppRunner runner,
ref WfExecutedResult result)
{
var rmins = new WfRuntimeManagerSignForward();
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.SignForward_ErrorArguments;
result.Message = "方法参数错误，无法加签流程！";
return(rmins);
}
if (runner.NextActivityPerformers.Count() == 0)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.SignForward_NoneSigners;
result.Message = "没有添加要发送加签的人员";
return(rmins);
}
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 = new ProcessModel(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="plist">执行人员列表</param>
/// <param name="mainActivityInstance">主节点</param>
/// <param name="session">数据会话</param>
private void CloneChildNodeOfMI(PerformerList plist,
ActivityInstanceEntity mainActivityInstance,
IDbSession session)
{
//查询已有的子节点列表
var childNodeListOfMI = base.ActivityInstanceManager.GetValidActivityInstanceListOfMI(mainActivityInstance.ID, session);
//创建活动实例
ActivityInstanceEntity entity = new ActivityInstanceEntity();
for (short i = 0; i < plist.Count; i++)
{
var userID = plist[i].UserID;
var userName = plist[i].UserName;
var isTaskExisted = IsTaskExisted(childNodeListOfMI, userID);
if (isTaskExisted == true)
{
//如果活动或者任务已经存在，则不用创建新活动和任务
continue;
}
//根据主节点来复制子节点数据
entity = ActivityInstanceManager.CreateActivityInstanceObject(mainActivityInstance);
entity.AssignedToUserIDs = userID;
entity.AssignedToUserNames = userName;
entity.MIHostActivityInstanceID = mainActivityInstance.ID;
//并行串行下，多实例子节点的执行顺序设置
if (mainActivityInstance.MergeType == (short)MergeTypeEnum.Sequence)
{
entity.CompleteOrder = (short)(i + 1);
}
else if (mainActivityInstance.MergeType == (short)MergeTypeEnum.Parallel)
{
entity.CompleteOrder = -1; //并行模式下CompleteOrder的优先级一样，所以置为 -1
}
//如果是串行会签，只有第一个节点处于运行状态，其它节点挂起
if ((i > 0) && (mainActivityInstance.MergeType.Value == (short)MergeTypeEnum.Sequence))
{
entity.ActivityState = (short)ActivityStateEnum.Suspended;
}
//插入活动实例数据，并返回活动实例ID
entity.ID = ActivityInstanceManager.Insert(entity, session);
//插入任务数据
base.TaskManager.Insert(entity,
plist[i],
base.ActivityForwardContext.ActivityResource.AppRunner,
session);
}
}
/// <summary>
/// 创建节点对象
/// </summary>
/// <param name="processInstance">流程实例</param>
/// <param name="activity">活动</param>
/// <param name="runner">执行者</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>
/// 撤销操作
/// 包括：
/// 1) 正常流转
/// 2) 多实例节点流转
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="result">结果对象</param>
/// <returns>运行时实例对象</returns>
internal static WfRuntimeManager CreateRuntimeInstanceWithdraw(WfAppRunner runner,
ref WfExecutedResult result)
{
WfRuntimeManager rmins = new WfRuntimeManagerWithdraw();
rmins.WfExecutedResult = result = new WfExecutedResult();
var aim = new ActivityInstanceManager();
var runningActivityInstanceList = aim.GetRunningActivityInstanceList(runner.AppInstanceID, runner.ProcessGUID).ToList();
WithdrawOpertaionTypeEnum withdrawOperation = WithdrawOpertaionTypeEnum.Default;
//当前没有运行状态的节点存在，流程不存在，或者已经结束或取消
if (runningActivityInstanceList == null || runningActivityInstanceList.Count() == 0)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Withdraw_NotInReady;
result.Message = "当前没有运行状态的节点存在，流程不存在，或者已经结束或取消";
return(rmins);
}
if (runningActivityInstanceList.Count() == 1) //如果只有1个运行节点
{
//先判断节点的状态是否是有效状态
var runningNode = runningActivityInstanceList[0];
if (runningNode.ActivityState != (short)ActivityStateEnum.Ready &&
runningNode.ActivityState != (short)ActivityStateEnum.Suspended) //只有准备或挂起状态的节点可以撤销
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Withdraw_NotInReady;
result.Message = string.Format("无法撤销到上一步，因为要撤销的节点为空，或不在【待办/挂起】状态，当前状态: {0}",
runningNode.ActivityState);//，节点状态：{0} runningNode.ActivityState 为空报错20150514
return(rmins);
}
//当前运行节点是普通节点模式
withdrawOperation = WithdrawOpertaionTypeEnum.Normal;
}
else if (runningActivityInstanceList.Count() > 1) //有多个并行运行节点存在
{
//有其它非多实例的并行节点，暂时不处理，后期实现该功能
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Withdraw_HasTooMany;
result.Message = "有多个可以撤销回去的节点，而且不是多实例节点，此功能暂时不支持！";
return(rmins);
}
//根据不同分支场景，创建不同撤销运行时管理器
return(CreateRuntimeInstanceWithdrawByCase(runningActivityInstanceList, withdrawOperation, runner, ref result));
}
/// <summary>
/// 创建节点对象
/// </summary>
/// <param name="activity">活动</param>
/// <param name="processInstance">流程实例</param>
/// <param name="runner">运行者</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="session">会话</param>
private void SetRunningNodeSendBack(IDbSession session)
{
//更新当前任务记录为退回状态
var tm = new TaskManager();
tm.SendBack(base.TaskView.TaskID, base.SendBackOperation.ActivityResource.AppRunner, session);
//更新当前办理节点的状态（从准备或运行状态更新为退回状态）
var aim = new ActivityInstanceManager();
aim.SendBack(base.SendBackOperation.BackwardFromActivityInstance.ID,
base.SendBackOperation.ActivityResource.AppRunner,
session);
}
/// <summary>
/// 创建节点对象
/// </summary>
/// <param name="processInstance">流程实例</param>
internal ActivityInstanceEntity CreateActivityInstanceObject(ProcessInstanceEntity processInstance,
WfLogonUser logonUser)
{
ActivityInstanceManager aim = new ActivityInstanceManager();
this.ActivityInstance = aim.CreateActivityInstanceObject(processInstance.AppName,
processInstance.AppInstanceID,
processInstance.ProcessInstanceGUID,
Activity,
logonUser);
AfterActivityInstanceObjectCreated();
return(this.ActivityInstance);
}
