/// <summary>
/// 自动完成结束节点
/// </summary>
/// <param name="processInstance"></param>
/// <param name="fromActivityInstance"></param>
/// <param name="activityResource"></param>
/// <param name="wfLinqDataContext"></param>
public GatewayExecutedResult CompleteAutomaticlly(ProcessInstanceEntity processInstance,
string transitionGUID,
ActivityInstanceEntity fromActivityInstance,
ActivityResource activityResource,
IDbSession session)
{
GatewayExecutedResult result = null;
var toActivityInstance = base.CreateActivityInstanceObject(base.Linker.ToActivity,
processInstance, activityResource.AppRunner);
base.ActivityInstanceManager.Insert(toActivityInstance, session);
base.ActivityInstanceManager.Complete(toActivityInstance.ID,
activityResource.AppRunner,
session);
//写节点转移实例数据
base.InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
TransitionTypeEnum.Forward,
TransitionFlyingTypeEnum.NotFlying,
activityResource.AppRunner,
session);
//设置流程完成
ProcessInstanceManager pim = new ProcessInstanceManager();
pim.Complete(processInstance.ID, activityResource.AppRunner, session);
//发送流程结束消息给流程启动人
return(result);
}
private IDictionary <string, string> CreateWorkers(string workspaceSid, ActivityResource activity)
{
var attributesForBob = new
{
products = new List <object>()
{
"ProgrammableSMS"
},
contact_uri = Config.AgentForProgrammableSMS
};
var bobWorker = CreateWorker(workspaceSid, "Bob", activity.Sid, Json.Encode(attributesForBob));
var attributesForAlice = new
{
products = new List <object>()
{
"ProgrammableVoice"
},
contact_uri = Config.AgentForProgrammableVoice
};
var alice = CreateWorker(workspaceSid, "Alice", activity.Sid, Json.Encode(attributesForAlice));
return(new Dictionary <string, string>
{
{ Config.AgentForProgrammableSMS, bobWorker.Sid },
{ Config.AgentForProgrammableVoice, alice.Sid },
});
}
/// <summary>
/// OrJoin合并时的节点完成方法
/// 1. 如果有满足条件的OrJoin前驱转移，则会重新生成新的OrJoin节点实例
/// </summary>
/// <param name="processInstance"></param>
/// <param name="fromTransition"></param>
/// <param name="fromActivityInstance"></param>
/// <param name="activityResource"></param>
/// <param name="wfLinqDataContext"></param>
public GatewayExecutedResult CompleteAutomaticlly(ProcessInstanceEntity processInstance,
string transitionGUID,
ActivityInstanceEntity fromActivityInstance,
ActivityResource activityResource,
IDbSession session)
{
var gatewayActivityInstance = base.CreateActivityInstanceObject(base.GatewayActivity,
processInstance, activityResource.AppRunner);
gatewayActivityInstance.GatewayDirectionTypeID = (short)GatewayDirectionEnum.OrJoin;
base.InsertActivityInstance(gatewayActivityInstance,
session);
base.CompleteActivityInstance(gatewayActivityInstance.ID,
activityResource,
session);
gatewayActivityInstance.ActivityState = (short)ActivityStateEnum.Completed;
base.GatewayActivityInstance = gatewayActivityInstance;
base.InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
gatewayActivityInstance,
TransitionTypeEnum.Forward,
TransitionFlyingTypeEnum.NotFlying,
activityResource.AppRunner,
session);
GatewayExecutedResult result = GatewayExecutedResult.CreateGatewayExecutedResult(GatewayExecutedStatus.Successed);
return result;
}
/// <summary>
/// 创建多实例节点之间回滚时的活动实例，任务数据
/// </summary>
/// <param name="processInstance">流程实例</param>
/// <param name="originalBackwardToActivityInstance">原始退回到的节点实例</param>
/// <param name="backwardType">退回类型</param>
/// <param name="backSrcActivityInstanceID">源退回节点实例ID</param>
/// <param name="activityResource">资源</param>
/// <param name="session">会话</param>
internal void CreateBackwardActivityTaskOfInnerMultipleInstance(ProcessInstanceEntity processInstance,
ActivityInstanceEntity originalBackwardToActivityInstance,
BackwardTypeEnum backwardType,
int backSrcActivityInstanceID,
ActivityResource activityResource,
IDbSession session)
{
//创建回滚到的节点信息
var rollbackPreviousActivityInstance = base.CreateBackwardToActivityInstanceObject(processInstance,
backwardType,
backSrcActivityInstanceID,
originalBackwardToActivityInstance.ID,
activityResource.AppRunner);
rollbackPreviousActivityInstance.ActivityState = (short)ActivityStateEnum.Ready;
rollbackPreviousActivityInstance.MIHostActivityInstanceID = originalBackwardToActivityInstance.MIHostActivityInstanceID;
rollbackPreviousActivityInstance.CompleteOrder = originalBackwardToActivityInstance.CompleteOrder;
rollbackPreviousActivityInstance.ComplexType = originalBackwardToActivityInstance.ComplexType;
rollbackPreviousActivityInstance.SignForwardType = originalBackwardToActivityInstance.SignForwardType;
rollbackPreviousActivityInstance.AssignedToUserIDs = originalBackwardToActivityInstance.AssignedToUserIDs; //多实例节点为单一用户任务
rollbackPreviousActivityInstance.AssignedToUserNames = originalBackwardToActivityInstance.AssignedToUserNames;
//插入新活动实例数据
base.ActivityInstanceManager.Insert(rollbackPreviousActivityInstance,
session);
base.ReturnDataContext.ActivityInstanceID = rollbackPreviousActivityInstance.ID;
base.ReturnDataContext.ProcessInstanceID = rollbackPreviousActivityInstance.ProcessInstanceID;
//创建新任务数据
base.CreateNewTask(rollbackPreviousActivityInstance, activityResource, session);
}
/// <summary>
/// OrJoin合并时的节点完成方法
/// 1. 如果有满足条件的OrJoin前驱转移，则会重新生成新的OrJoin节点实例
/// </summary>
/// <param name="processInstance"></param>
/// <param name="fromTransition"></param>
/// <param name="fromActivityInstance"></param>
/// <param name="activityResource"></param>
/// <param name="wfLinqDataContext"></param>
public GatewayExecutedResult CompleteAutomaticlly(ProcessInstanceEntity processInstance,
TransitionEntity fromTransition,
ActivityInstanceEntity fromActivityInstance,
ActivityResource activityResource,
ISession session)
{
var toActivityInstance = base.CreateActivityInstanceObject(processInstance, activityResource.LogonUser);
base.InsertActivityInstance(toActivityInstance,
session);
base.CompleteActivityInstance(toActivityInstance.ActivityInstanceGUID,
activityResource,
session);
SyncActivityInstanceObjectState(NodeStateEnum.Completed);
base.InsertTransitionInstance(processInstance,
fromTransition,
fromActivityInstance,
toActivityInstance,
TransitionTypeEnum.Forward,
activityResource.LogonUser,
session);
GatewayExecutedResult result = GatewayExecutedResult.CreateGatewayExecutedResult(GatewayExecutedStatus.Successed);
return(result);
}
/// <summary>
/// 自动完成结束节点
/// </summary>
/// <param name="processInstance"></param>
/// <param name="fromActivityInstance"></param>
/// <param name="activityResource"></param>
/// <param name="wfLinqDataContext"></param>
public GatewayExecutedResult CompleteAutomaticlly(ProcessInstanceEntity processInstance,
string transitionGUID,
ActivityInstanceEntity fromActivityInstance,
ActivityResource activityResource,
IDbSession session)
{
GatewayExecutedResult result = null;
var toActivityInstance = base.CreateActivityInstanceObject(base.Linker.ToActivity,
processInstance, activityResource.AppRunner);
base.ActivityInstanceManager.Insert(toActivityInstance, session);
base.ActivityInstanceManager.Complete(toActivityInstance.ID,
activityResource.AppRunner,
session);
//写节点转移实例数据
base.InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
TransitionTypeEnum.Forward,
TransitionFlyingTypeEnum.NotFlying,
activityResource.AppRunner,
session);
//设置流程完成
ProcessInstanceManager pim = new ProcessInstanceManager();
pim.Complete(processInstance.ID, activityResource.AppRunner, session);
//发送流程结束消息给流程启动人
return 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)
{
//实例化Activity
var toActivityInstance = base.CreateActivityInstanceObject(toActivity, processInstance, activityResource.AppRunner);
//进入运行状态
toActivityInstance.ActivityState = (short)ActivityStateEnum.Ready;
toActivityInstance.AssignedToUserIDs = GenerateActivityAssignedUserIDs(
activityResource.NextActivityPerformers[toActivity.ActivityGUID]);
toActivityInstance.AssignedToUserNames = GenerateActivityAssignedUserNames(
activityResource.NextActivityPerformers[toActivity.ActivityGUID]);
//插入活动实例数据
base.ActivityInstanceManager.Insert(toActivityInstance, session);
//插入任务数据
base.CreateNewTask(toActivityInstance, activityResource, session);
//插入转移数据
InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
transitionType,
flyingType,
activityResource.AppRunner,
session);
}
/// <summary>
/// 创建多实例节点之间回滚时的活动实例，任务数据
/// </summary>
/// <param name="processInstance">流程实例</param>
/// <param name="originalBackwardToActivityInstance">原始退回到的节点实例</param>
/// <param name="backwardType">退回类型</param>
/// <param name="backSrcActivityInstanceID">源退回节点实例ID</param>
/// <param name="activityResource">资源</param>
/// <param name="session">会话</param>
internal void CreateBackwardActivityTaskOfInnerMultipleInstance(ProcessInstanceEntity processInstance,
ActivityInstanceEntity originalBackwardToActivityInstance,
BackwardTypeEnum backwardType,
int backSrcActivityInstanceID,
ActivityResource activityResource,
IDbSession session)
{
//创建回滚到的节点信息
var rollbackPreviousActivityInstance = base.CreateBackwardToActivityInstanceObject(processInstance,
backwardType,
backSrcActivityInstanceID,
originalBackwardToActivityInstance.ID,
activityResource.AppRunner);
rollbackPreviousActivityInstance.ActivityState = (short)ActivityStateEnum.Ready;
rollbackPreviousActivityInstance.MIHostActivityInstanceID = originalBackwardToActivityInstance.MIHostActivityInstanceID;
rollbackPreviousActivityInstance.CompleteOrder = originalBackwardToActivityInstance.CompleteOrder;
rollbackPreviousActivityInstance.ComplexType = originalBackwardToActivityInstance.ComplexType;
rollbackPreviousActivityInstance.SignForwardType = originalBackwardToActivityInstance.SignForwardType;
//人员来自步骤列表的用户数据
rollbackPreviousActivityInstance.AssignedToUserIDs = base.SendBackOperation.BackwardToTaskPerformer.UserID; //多实例节点为单一用户任务
rollbackPreviousActivityInstance.AssignedToUserNames = base.SendBackOperation.BackwardToTaskPerformer.UserName;
//插入新活动实例数据
base.ActivityInstanceManager.Insert(rollbackPreviousActivityInstance,
session);
//创建新任务数据
base.TaskManager.Insert(rollbackPreviousActivityInstance,
base.SendBackOperation.BackwardToTaskPerformer,
activityResource.AppRunner,
base.Session);
}
/// <summary>
/// 会签类型的主节点, 多实例节点处理
/// </summary>
/// <param name="processInstance"></param>
/// <param name="fromToTransition"></param>
/// <param name="fromActivityInstance"></param>
/// <param name="activityResource"></param>
/// <param name="session"></param>
internal void CreateMultipleInstance(ActivityEntity toActivity,
ProcessInstanceEntity processInstance,
ActivityInstanceEntity fromActivityInstance,
String transitionGUID,
TransitionTypeEnum transitionType,
TransitionFlyingTypeEnum flyingType,
ActivityResource activityResource,
IDbSession session)
{
//实例化主节点Activity
var toActivityInstance = base.CreateActivityInstanceObject(toActivity,
processInstance, activityResource.AppRunner);
//主节点实例数据
toActivityInstance.ActivityState = (short)ActivityStateEnum.Suspended;
toActivityInstance.ComplexType = (short)ComplexTypeEnum.MultipleInstance;
if (toActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Parallel)
{
toActivityInstance.CompleteOrder = toActivity.ActivityTypeDetail.CompleteOrder;
}
toActivityInstance.AssignedToUsers = GenerateActivityAssignedUsers(
activityResource.NextActivityPerformers[toActivity.ActivityGUID]);
//插入主节点实例数据
base.ActivityInstanceManager.Insert(toActivityInstance, session);
//插入主节点转移数据
InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
transitionType,
flyingType,
activityResource.AppRunner,
session);
//插入会签子节点实例数据
var plist = activityResource.NextActivityPerformers[toActivity.ActivityGUID];
ActivityInstanceEntity entity = new ActivityInstanceEntity();
for (short i = 0; i < plist.Count; i++)
{
entity = base.ActivityInstanceManager.CreateActivityInstanceObject(toActivityInstance);
entity.AssignedToUsers = plist[i].UserID.ToString();
entity.MIHostActivityInstanceID = toActivityInstance.ID;
entity.CompleteOrder = (short)(i + 1);
//如果是串行会签，只有第一个节点处于运行状态，其它节点挂起
if ((i > 0) && (toActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Sequence))
{
entity.ActivityState = (short)ActivityStateEnum.Suspended;
}
//插入活动实例数据，并返回活动实例ID
entity.ID = base.ActivityInstanceManager.Insert(entity, session);
//插入任务数据
base.TaskManager.Insert(entity, plist[i], activityResource.AppRunner, session);
}
}
/// <summary>
/// 创建流程跳转上下文对象
/// </summary>
/// <param name="jumpforwardActivity"></param>
/// <param name="processModel"></param>
/// <param name="processInstance"></param>
/// <param name="activityResource"></param>
/// <returns></returns>
internal static ActivityForwardContext CreateJumpforwardContext(ActivityEntity jumpforwardActivity,
ProcessModel processModel,
ProcessInstanceEntity processInstance,
ActivityResource activityResource)
{
return(new ActivityForwardContext(processModel, processInstance, jumpforwardActivity, activityResource));
}
/// <summary>
/// 自动完成结束节点
/// </summary>
/// <param name="processInstance"></param>
/// <param name="fromActivityInstance"></param>
/// <param name="activityResource"></param>
/// <param name="wfLinqDataContext"></param>
public GatewayExecutedResult CompleteAutomaticlly(ProcessInstanceEntity processInstance,
TransitionEntity fromToTransition,
ActivityInstanceEntity fromActivityInstance,
ActivityResource activityResource,
ISession session)
{
GatewayExecutedResult result = null;
var toActivityInstance = base.CreateActivityInstanceObject(processInstance, activityResource.LogonUser);
base.InsertActivityInstance(toActivityInstance,
session);
base.CompleteActivityInstance(toActivityInstance.ActivityInstanceGUID,
activityResource,
session);
//写节点转移实例数据
base.InsertTransitionInstance(processInstance,
fromToTransition,
fromActivityInstance,
toActivityInstance,
TransitionTypeEnum.Forward,
activityResource.LogonUser,
session);
//设置流程完成
ProcessInstanceManager pim = new ProcessInstanceManager();
pim.Complete(processInstance.ProcessInstanceGUID, activityResource.LogonUser, session);
return(result);
}
/// <summary>
/// 完成任务实例
/// </summary>
/// <param name="taskView">任务视图</param>
/// <param name="activityResource">活动资源</param>
/// <param name="session">会话</param>
internal bool CompleteWorkItem(TaskViewEntity taskView,
ActivityResource activityResource,
IDbSession session)
{
bool canContinueForwardCurrentNode = true;
WfAppRunner runner = new WfAppRunner
{
UserID = activityResource.AppRunner.UserID, //避免taskview为空
UserName = activityResource.AppRunner.UserName
};
//流程强制拉取向前跳转时，没有运行人的任务实例
if (taskView != null)
{
//完成本任务，返回任务已经转移到下一个会签任务，不继续执行其它节点
base.TaskManager.Complete(taskView.TaskID, activityResource.AppRunner, session);
}
//设置活动节点的状态为完成状态
base.ActivityInstanceManager.Complete(base.Linker.FromActivityInstance.ID,
activityResource.AppRunner,
session);
base.Linker.FromActivityInstance.ActivityState = (short)ActivityStateEnum.Completed;
return(canContinueForwardCurrentNode);
}
/// <summary>
/// 完成任务实例
/// </summary>
/// <param name="taskID">任务视图</param>
/// <param name="activityResource">活动资源</param>
/// <param name="session">会话</param>
internal bool CompleteWorkItem(int?taskID,
ActivityResource activityResource,
IDbSession session)
{
bool canContinueForwardCurrentNode = true;
WfAppRunner runner = new WfAppRunner
{
UserID = activityResource.AppRunner.UserID, //避免taskview为空
UserName = activityResource.AppRunner.UserName
};
//流程强制拉取向前跳转时，没有运行人的任务实例
if (taskID != null)
{
//完成本任务，返回任务已经转移到下一个会签任务，不继续执行其它节点
base.TaskManager.Complete(taskID.Value, activityResource.AppRunner, session);
//设置活动节点的状态为完成状态
var activityInstanceID = base.ActivityInstanceManager.GetByTask(taskID.Value).ID;
base.ActivityInstanceManager.Complete(activityInstanceID,
activityResource.AppRunner,
session);
}
return(canContinueForwardCurrentNode);
}
/// <summary>
/// 启动流程
/// </summary>
/// <param name="user"></param>
/// <param name="appInstanceID"></param>
/// <param name="processGUID"></param>
/// <param name="nextActivityGUID"></param>
/// <returns></returns>
public WfRuntimeManager GetRuntimeInstanceStartup(WfAppRunner runner)
{
//检查流程是否可以被启动
var pim = new ProcessInstanceManager();
var processInstance = pim.GetRunningProcess(runner.AppName, runner.AppInstanceID, runner.ProcessGUID);
if (processInstance != null)
{
throw new WfRuntimeException("当前应用已经有流程实例在运行中，除非终止或取消流程，否则流程不能被再次启动。");
}
this.AppRunner = runner;
//获取流程第一个可办理节点
this.ProcessModel = new ProcessModel(runner.ProcessGUID);
var firstActivity = this.ProcessModel.GetFirstActivity();
this.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(firstActivity.ActivityGUID,
runner.UserID,
runner.UserName);
this.ActivityResource = new ActivityResource(runner.UserID, runner.UserName, this.AppRunner.NextActivityPerformers);
return(this);
}
public GatewayExecutedResult CompleteAutomaticlly(ProcessInstanceEntity processInstance,
string transitionGUID,
ActivityInstanceEntity fromActivityInstance,
ActivityResource activityResource,
IDbSession session)
{
var gatewayActivityInstance = base.CreateActivityInstanceObject(base.GatewayActivity, processInstance, activityResource.AppRunner);
gatewayActivityInstance.GatewayDirectionTypeID = (short)GatewayDirectionEnum.OrSplit;
base.InsertActivityInstance(gatewayActivityInstance,
session);
base.CompleteActivityInstance(gatewayActivityInstance.ID,
activityResource,
session);
gatewayActivityInstance.ActivityState = (short)ActivityStateEnum.Completed;
base.GatewayActivityInstance = gatewayActivityInstance;
//写节点转移实例数据
base.InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
gatewayActivityInstance,
TransitionTypeEnum.Forward,
TransitionFlyingTypeEnum.NotFlying,
activityResource.AppRunner,
session);
GatewayExecutedResult result = GatewayExecutedResult.CreateGatewayExecutedResult(GatewayExecutedStatus.Successed);
return result;
}
/// <summary>
/// 结束节点活动及转移实例化，没有任务数据
/// </summary>
/// <param name="toActivity">当前Activity</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)
{
var toActivityInstance = base.CreateActivityInstanceObject(toActivity,
processInstance, activityResource.AppRunner);
base.ActivityInstanceManager.Insert(toActivityInstance, session);
base.ActivityInstanceManager.Complete(toActivityInstance.ID,
activityResource.AppRunner,
session);
//写节点转移实例数据
base.InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
transitionType,
flyingType,
activityResource.AppRunner,
session);
}
/// <summary>
/// 创建工作项及转移数据
/// </summary>
/// <param name="processInstance"></param>
/// <param name="fromToTransition"></param>
/// <param name="fromActivityInstance"></param>
/// <param name="activityResource"></param>
/// <param name="session"></param>
internal void CreateActivityTaskAndTransitionInstances(ProcessInstanceEntity processInstance,
ActivityInstanceEntity fromActivityInstance,
TransitionEntity fromToTransition,
TransitionTypeEnum transitionType,
ActivityResource activityResource,
ISession session)
{
//实例化Activity
var toActivityInstance = base.CreateActivityInstanceObject(processInstance, activityResource.LogonUser);
//进入运行状态
toActivityInstance.State = (short)NodeStateEnum.Ready;
//插入活动实例数据
base.InsertActivityInstance(toActivityInstance,
session);
//插入任务数据
CreateNewTask(activityResource, session);
//插入转移数据
base.InsertTransitionInstance(processInstance,
fromToTransition,
fromActivityInstance,
toActivityInstance,
transitionType,
activityResource.LogonUser,
session);
}
/// <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)
{
if (toActivity.ActivityTypeDetail.ComplexType == ComplexTypeEnum.SignTogether)
{
CreateMultipleInstance(toActivity, processInstance, fromActivityInstance,
transitionGUID, transitionType, flyingType, activityResource, session);
}
else
{
//实例化Activity
var toActivityInstance = CreateActivityInstanceObject(toActivity, processInstance, activityResource.AppRunner);
//进入运行状态
var performerList = activityResource.NextActivityPerformers[toActivity.ActivityGUID];
toActivityInstance.ActivityState = (short)ActivityStateEnum.Ready;
toActivityInstance.AssignedToUserIDs = GenerateActivityAssignedUserIDs(performerList);
toActivityInstance.AssignedToUserNames = GenerateActivityAssignedUserNames(performerList);
//插入活动实例数据
base.ActivityInstanceManager.Insert(toActivityInstance, session);
//插入任务数据
base.CreateNewTask(toActivityInstance, activityResource, session);
//插入转移数据
InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
transitionType,
flyingType,
activityResource.AppRunner,
session);
//启动子流程
WfExecutedResult startedResult = null;
var subProcessNode = (SubProcessNode)toActivity.Node;
subProcessNode.ActivityInstance = toActivityInstance;
WfAppRunner subRunner = CopyActivityForwardRunner(activityResource.AppRunner,
new Performer(activityResource.AppRunner.UserID,
activityResource.AppRunner.UserName),
subProcessNode);
var runtimeInstance = WfRuntimeManagerFactory.CreateRuntimeInstanceStartupSub(subRunner,
processInstance,
subProcessNode,
performerList,
ref startedResult);
runtimeInstance.OnWfProcessExecuted += runtimeInstance_OnWfProcessStarted;
runtimeInstance.Execute(Session);
}
}
/// <summary>
/// 启动流程的上下文对象
/// </summary>
/// <param name="processModel"></param>
/// <param name="processInstance"></param>
/// <param name="activity"></param>
/// <param name="activityResource"></param>
/// <returns></returns>
internal static ActivityForwardContext CreateStartupContext(ProcessModel processModel,
ProcessInstanceEntity processInstance,
ActivityEntity activity,
ActivityResource activityResource)
{
return(new ActivityForwardContext(processModel, processInstance, activity, activityResource));
}
/// <summary>
/// 创建多实例节点之间回滚时的活动实例，任务数据
/// </summary>
/// <param name="processInstance"></param>
/// <param name="originalBackwardToActivityInstance"></param>
/// <param name="backwardType"></param>
/// <param name="backSrcActivityInstanceID"></param>
/// <param name="activityResource"></param>
/// <param name="session"></param>
internal void CreateBackwardActivityTaskOfInnerMultipleInstance(ProcessInstanceEntity processInstance,
ActivityInstanceEntity originalBackwardToActivityInstance,
BackwardTypeEnum backwardType,
int backSrcActivityInstanceID,
ActivityResource activityResource,
IDbSession session)
{
//创建回滚到的节点信息
var rollbackPreviousActivityInstance = base.CreateBackwardToActivityInstanceObject(processInstance,
backwardType,
backSrcActivityInstanceID,
activityResource.AppRunner);
rollbackPreviousActivityInstance.ActivityState = (short)ActivityStateEnum.Ready;
rollbackPreviousActivityInstance.MIHostActivityInstanceID = originalBackwardToActivityInstance.MIHostActivityInstanceID;
rollbackPreviousActivityInstance.CompleteOrder = originalBackwardToActivityInstance.CompleteOrder;
rollbackPreviousActivityInstance.ComplexType = originalBackwardToActivityInstance.ComplexType;
rollbackPreviousActivityInstance.SignForwardType = originalBackwardToActivityInstance.SignForwardType;
rollbackPreviousActivityInstance.AssignedToUserIDs = originalBackwardToActivityInstance.AssignedToUserIDs; //多实例节点为单一用户任务
rollbackPreviousActivityInstance.AssignedToUserNames = originalBackwardToActivityInstance.AssignedToUserNames;
//插入新活动实例数据
base.ActivityInstanceManager.Insert(rollbackPreviousActivityInstance,
session);
//创建新任务数据
base.CreateNewTask(rollbackPreviousActivityInstance, activityResource, session);
}
/// <summary>
/// 创建任务执行上下文对象
/// </summary>
/// <param name="taskView">任务</param>
/// <param name="processModel">流程模型</param>
/// <param name="activityResource">活动资源</param>
/// <param name="isNotParsedForward">不需要解析的流转</param>
/// <param name="session">数据会话</param>
/// <returns>活动上下文</returns>
internal static ActivityForwardContext CreateRunningContextByTask(TaskViewEntity taskView,
IProcessModel processModel,
ActivityResource activityResource,
Boolean isNotParsedForward,
IDbSession session)
{
return(new ActivityForwardContext(taskView, processModel, activityResource, isNotParsedForward, session));
}
/// <summary>
/// Interrupt事件类型创建活动执行上下文对象
/// </summary>
/// <param name="activityInstance">活动实例</param>
/// <param name="processModel">流程模型</param>
/// <param name="activityResource">活动资源</param>
/// <param name="isNotParsedForward">不需要解析的流转</param>
/// <param name="session">数据会话</param>
/// <returns>活动上下文</returns>
internal static ActivityForwardContext CreateRunningContextByActivity(ActivityInstanceEntity activityInstance,
IProcessModel processModel,
ActivityResource activityResource,
Boolean isNotParsedForward,
IDbSession session)
{
return(new ActivityForwardContext(activityInstance, processModel, activityResource, isNotParsedForward, session));
}
/// <summary>
/// 节点对象的完成方法
/// </summary>
/// <param name="ActivityInstanceGUID"></param>
/// <param name="activityResource"></param>
/// <param name="wfLinqDataContext"></param>
internal virtual void CompleteActivityInstance(Guid ActivityInstanceGUID,
ActivityResource activityResource,
ISession session)
{
//设置完成状态
ActivityInstanceManager.Complete(ActivityInstanceGUID,
activityResource.LogonUser,
session);
}
public async Task <IActionResult> Insert(ActivityResource resource)
{
var activity = resource.GetModelFromResource();
_context.Add(activity);
await _context.SaveChangesAsync();
return(Ok(ActivityResource.GetActivityResource(activity)));
}
/// <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 = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceStartup.error");
return(rmins);
}
rmins.AppRunner = runner;
//获取流程第一个可办理节点
rmins.ProcessModel = ProcessModelFactory.Create(runner.ProcessGUID, runner.Version);
var startActivity = rmins.ProcessModel.GetStartActivity();
var firstActivity = rmins.ProcessModel.GetFirstActivity();
//var firstActivityList = rmins.ProcessModel.GetFirstActivityList(startActivity, runner.Conditions);
if (startActivity.ActivityTypeDetail.TriggerType == TriggerTypeEnum.None)
{
rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(firstActivity.ActivityGUID,
runner.UserID,
runner.UserName);
}
else if (startActivity.ActivityTypeDetail.TriggerType == TriggerTypeEnum.Timer ||
startActivity.ActivityTypeDetail.TriggerType == TriggerTypeEnum.Message)
{
if (!string.IsNullOrEmpty(runner.UserID))
{
rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(firstActivity.ActivityGUID,
runner.UserID,
runner.UserName);
}
else
{
rmins.AppRunner.NextActivityPerformers = rmins.ProcessModel.GetActivityPerformers(firstActivity.ActivityGUID);
}
}
rmins.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers);
return(rmins);
}
public async Task <IActionResult> CreateActivity(ActivityResource activityResource)
{
var activity = _mapper.Map <Activity>(activityResource);
this._activityRepo.Add(activity);
await this._unitOfWork.CompleteAsync();
return(Ok(activity));
}
public ValueTask StartActivityAsync(ActivityResource activityResource, CancellationToken cancellationToken)
{
return(_serviceClient.PostAsync(
ServiceConfiguration.ServiceName,
$"{RoutePrefix}",
EndpointAuthentication.Service,
activityResource,
cancellationToken));
}
/// <summary>
/// 节点对象的完成方法
/// </summary>
/// <param name="ActivityInstanceID">活动实例ID</param>
/// <param name="activityResource">活动资源</param>
/// <param name="session">会话</param>
internal virtual void CompleteActivityInstance(int ActivityInstanceID,
ActivityResource activityResource,
IDbSession session)
{
//设置完成状态
ActivityInstanceManager.Complete(ActivityInstanceID,
activityResource.AppRunner,
session);
}
/// <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);
}
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.AppName,
runner.AppInstanceID,
runner.ProcessGUID);
}
else
{
//子流程启动
processInstance = pim.GetProcessInstanceLatest(runner.AppName,
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);
}
public GatewayExecutedResult CompleteAutomaticlly(ProcessInstanceEntity processInstance,
TransitionEntity fromTransition,
ActivityInstanceEntity fromActivityInstance,
ActivityResource activityResource,
ISession session)
{
GatewayExecutedResult result = GatewayExecutedResult.CreateGatewayExecutedResult(GatewayExecutedStatus.Unknown);
bool canRenewInstance = false;
//检查是否有运行中的合并节点实例
ActivityInstanceEntity joinNode = base.ActivityInstanceManager.GetActivityWithRunningState(
processInstance.ProcessInstanceGUID,
base.Activity.ActivityGUID,
session);
if (joinNode == null)
{
canRenewInstance = true;
}
else
{
//判断是否可以激活下一步节点
canRenewInstance = (joinNode.CanRenewInstance == 1);
if (!canRenewInstance)
{
result = GatewayExecutedResult.CreateGatewayExecutedResult(GatewayExecutedStatus.FallBehindOfXOrJoin);
return(result);
}
}
if (canRenewInstance)
{
var toActivityInstance = base.CreateActivityInstanceObject(processInstance, activityResource.LogonUser);
base.InsertActivityInstance(toActivityInstance,
session);
base.CompleteActivityInstance(toActivityInstance.ActivityInstanceGUID,
activityResource,
session);
base.SyncActivityInstanceObjectState(NodeStateEnum.Completed);
//写节点转移实例数据
base.InsertTransitionInstance(processInstance,
fromTransition,
fromActivityInstance,
toActivityInstance,
TransitionTypeEnum.Forward,
activityResource.LogonUser,
session);
result = GatewayExecutedResult.CreateGatewayExecutedResult(GatewayExecutedStatus.Successed);
}
return(result);
}
/// <summary>
/// 开始节点的构造执行上下文对象
/// </summary>
/// <param name="processModel"></param>
/// <param name="processInstance"></param>
/// <param name="activity"></param>
/// <param name="activityResource"></param>
private ActivityForwardContext(ProcessModel processModel,
ProcessInstanceEntity processInstance,
ActivityEntity activity,
ActivityResource activityResource)
{
ProcessModel = processModel;
ProcessInstance = processInstance;
Activity = activity;
ActivityResource = activityResource;
}
/// <summary>
/// 开始节点的构造执行上下文对象
/// </summary>
/// <param name="processModel"></param>
/// <param name="processInstance"></param>
/// <param name="activity"></param>
/// <param name="activityResource"></param>
private ActivityForwardContext(ProcessModel processModel,
ProcessInstanceEntity processInstance,
ActivityEntity activity,
ActivityResource activityResource)
{
ProcessModel = processModel;
ProcessInstance = processInstance;
Activity = activity;
ActivityResource = activityResource;
}
private void HandleActivityStarted(string activityId, ActivityType activityType)
{
var location = GetLocationForActivity(activityId);
var characters = location.GetAllCharactersInActivity(activityId);
var activityResource = new ActivityResource(activityId, activityType, characters);
_activitiesClient.StartActivityAsync(activityResource, default)
.AsTask().GetAwaiter().GetResult();
}
public GatewayExecutedResult CompleteAutomaticlly(ProcessInstanceEntity processInstance,
string transitionGUID,
ActivityInstanceEntity fromActivityInstance,
ActivityResource activityResource,
IDbSession session)
{
//检查是否有运行中的合并节点实例
ActivityInstanceEntity joinNode = base.ActivityInstanceManager.GetActivityRunning(
processInstance.ID,
base.GatewayActivity.ActivityGUID,
session);
if (joinNode == null)
{
var joinActivityInstance = base.CreateActivityInstanceObject(base.GatewayActivity,
processInstance, activityResource.AppRunner);
//计算总需要的Token数目
joinActivityInstance.TokensRequired = GetTokensRequired();
joinActivityInstance.TokensHad = 1;
//进入运行状态
joinActivityInstance.ActivityState = (short)ActivityStateEnum.Running;
joinActivityInstance.GatewayDirectionTypeID = (short)GatewayDirectionEnum.AndJoin;
base.InsertActivityInstance(joinActivityInstance,
session);
}
else
{
//更新节点的活动实例属性
base.GatewayActivityInstance = joinNode;
int tokensRequired = base.GatewayActivityInstance.TokensRequired;
int tokensHad = base.GatewayActivityInstance.TokensHad;
//更新Token数目
base.ActivityInstanceManager.IncreaseTokensHad(base.GatewayActivityInstance.ID,
activityResource.AppRunner,
session);
if ((tokensHad + 1) == tokensRequired)
{
//如果达到完成节点的Token数，则设置该节点状态为完成
base.CompleteActivityInstance(base.GatewayActivityInstance.ID,
activityResource,
session);
base.GatewayActivityInstance.ActivityState = (short)ActivityStateEnum.Completed;
}
}
GatewayExecutedResult result = GatewayExecutedResult.CreateGatewayExecutedResult(
GatewayExecutedStatus.Successed);
return result;
}
/// <summary>
/// 任务执行的上下文对象
/// </summary>
/// <param name="task"></param>
/// <param name="processModel"></param>
/// <param name="activityResource"></param>
private ActivityForwardContext(TaskViewEntity task,
ProcessModel processModel,
ActivityResource activityResource)
{
this.TaskView = task;
//check task condition has load activity instance
this.FromActivityInstance = (new ActivityInstanceManager()).GetById(task.ActivityInstanceID);
this.ProcessInstance = (new ProcessInstanceManager()).GetById(task.ProcessInstanceID);
this.Activity = processModel.GetActivity(task.ActivityGUID);
this.ProcessModel = processModel;
this.ActivityResource = activityResource;
}
/// <summary>
/// 创建退回时的流转节点对象、任务和转移数据
/// </summary>
/// <param name="processInstance"></param>
/// <param name="fromActivityInstance"></param>
/// <param name="backMostPreviouslyActivityInstanceID"></param>
/// <param name="transitionGUID"></param>
/// <param name="transitionType"></param>
/// <param name="flyingType"></param>
/// <param name="activityResource"></param>
/// <param name="session"></param>
internal void CreateBackwardActivityTaskTransitionInstance(ProcessInstanceEntity processInstance,
ActivityInstanceEntity fromActivityInstance,
BackwardTypeEnum backwardType,
int backMostPreviouslyActivityInstanceID,
string transitionGUID,
TransitionTypeEnum transitionType,
TransitionFlyingTypeEnum flyingType,
ActivityResource activityResource,
IDbSession session)
{
//实例化Activity
var toActivityInstance = base.CreateBackwardToActivityInstanceObject(processInstance,
backwardType,
backMostPreviouslyActivityInstanceID,
activityResource.AppRunner);
//进入运行状态
toActivityInstance.ActivityState = (short)ActivityStateEnum.Ready;
toActivityInstance.AssignedToUsers = base.GenerateActivityAssignedUsers(
activityResource.NextActivityPerformers[base.BackwardContext.BackwardToTaskActivity.ActivityGUID]);
//插入活动实例数据
base.ActivityInstanceManager.Insert(toActivityInstance,
session);
//插入任务数据
base.CreateNewTask(toActivityInstance, activityResource, session);
//插入转移数据
base.InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
transitionType,
flyingType,
activityResource.AppRunner,
session);
}
/// <summary>
/// 创建工作项及转移数据
/// </summary>
/// <param name="toActivity"></param>
/// <param name="processInstance"></param>
/// <param name="fromActivityInstance"></param>
/// <param name="transitionGUID"></param>
/// <param name="transitionType"></param>
/// <param name="flyingType"></param>
/// <param name="activityResource"></param>
/// <param name="session"></param>
internal virtual void CreateActivityTaskTransitionInstance(ActivityEntity toActivity,
ProcessInstanceEntity processInstance,
ActivityInstanceEntity fromActivityInstance,
String transitionGUID,
TransitionTypeEnum transitionType,
TransitionFlyingTypeEnum flyingType,
ActivityResource activityResource,
IDbSession session)
{
}
/// <summary>
/// 创建任务的虚方法
/// 1. 对于自动执行的工作项，无需重写该方法
/// 2. 对于人工执行的工作项，需要重写该方法，插入待办的任务数据
/// </summary>
/// <param name="activityResource"></param>
/// <param name="wfLinqDataContext"></param>
internal virtual void CreateNewTask(ActivityInstanceEntity toActivityInstance,
ActivityResource activityResource,
IDbSession session)
{
if (activityResource.NextActivityPerformers == null)
{
throw new WorkflowException("无法创建任务，流程流转下一步的办理人员不能为空！");
}
TaskManager.Insert(toActivityInstance,
activityResource.NextActivityPerformers[toActivityInstance.ActivityGUID],
activityResource.AppRunner,
session);
}
/// <summary>
/// 会签类型的主节点, 多实例节点处理
/// </summary>
/// <param name="processInstance"></param>
/// <param name="fromToTransition"></param>
/// <param name="fromActivityInstance"></param>
/// <param name="activityResource"></param>
/// <param name="session"></param>
internal void CreateMultipleInstance(ActivityEntity toActivity,
ProcessInstanceEntity processInstance,
ActivityInstanceEntity fromActivityInstance,
String transitionGUID,
TransitionTypeEnum transitionType,
TransitionFlyingTypeEnum flyingType,
ActivityResource activityResource,
IDbSession session)
{
//实例化主节点Activity
var toActivityInstance = base.CreateActivityInstanceObject(toActivity,
processInstance, activityResource.AppRunner);
//主节点实例数据
toActivityInstance.ActivityState = (short)ActivityStateEnum.Suspended;
toActivityInstance.ComplexType = (short)ComplexTypeEnum.MultipleInstance;
if (toActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Parallel)
{
toActivityInstance.CompleteOrder = toActivity.ActivityTypeDetail.CompleteOrder;
}
toActivityInstance.AssignedToUsers = GenerateActivityAssignedUsers(
activityResource.NextActivityPerformers[toActivity.ActivityGUID]);
//插入主节点实例数据
base.ActivityInstanceManager.Insert(toActivityInstance, session);
//插入主节点转移数据
InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
transitionType,
flyingType,
activityResource.AppRunner,
session);
//插入会签子节点实例数据
var plist = activityResource.NextActivityPerformers[toActivity.ActivityGUID];
ActivityInstanceEntity entity = new ActivityInstanceEntity();
for (short i = 0; i < plist.Count; i++)
{
entity = base.ActivityInstanceManager.CreateActivityInstanceObject(toActivityInstance);
entity.AssignedToUsers = plist[i].UserID.ToString();
entity.MIHostActivityInstanceID = toActivityInstance.ID;
entity.CompleteOrder = (short)(i + 1);
//如果是串行会签，只有第一个节点处于运行状态，其它节点挂起
if ((i > 0) && (toActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Sequence))
{
entity.ActivityState = (short)ActivityStateEnum.Suspended;
}
//插入活动实例数据，并返回活动实例ID
entity.ID = base.ActivityInstanceManager.Insert(entity, session);
//插入任务数据
base.TaskManager.Insert(entity, plist[i], activityResource.AppRunner, session);
}
}
/// <summary>
/// 完成任务实例
/// </summary>
/// <param name="taskID"></param>
/// <param name="activityResource"></param>
/// <param name="session"></param>
internal bool CompleteWorkItem(TaskViewEntity taskView,
ActivityResource activityResource,
IDbSession session)
{
bool canContinueForwardCurrentNode = true;
//流程强制拉取向前跳转时，没有运行人的任务实例
if (taskView != null)
{
//完成本任务，返回任务已经转移到下一个会签任务，不继续执行其它节点
base.TaskManager.Complete(taskView.TaskID, activityResource.AppRunner, session);
}
//设置活动节点的状态为完成状态
base.ActivityInstanceManager.Complete(base.Linker.FromActivityInstance.ID,
activityResource.AppRunner,
session);
base.Linker.FromActivityInstance.ActivityState = (short)ActivityStateEnum.Completed;
//先判断是否是多实例类型的任务
if (base.Linker.FromActivity.ActivityTypeDetail.ComplexType == ComplexTypeEnum.MultipleInstance)
{
//取出主节点信息
var mainNodeIndex = base.Linker.FromActivityInstance.MIHostActivityInstanceID.Value;
var mainActivityInstance = base.ActivityInstanceManager.GetById(mainNodeIndex);
//取出多实例节点列表
var sqList = base.ActivityInstanceManager.GetActivityMulitipleInstance(
mainNodeIndex,
base.Linker.FromActivityInstance.ProcessInstanceID,
session).ToList<ActivityInstanceEntity>();
if (sqList == null || sqList.Count == 0)
{
throw new WfRuntimeException("会签主节点下没有多实例子节点，流程运行数据异常！");
}
if (base.Linker.FromActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Sequence)
{
//取出最大执行节点
short maxOrder = (short)sqList.Max<ActivityInstanceEntity>(t => t.CompleteOrder.Value);
if (base.Linker.FromActivityInstance.CompleteOrder < maxOrder)
{
//设置下一个任务进入准备状态
var currentNodeIndex = (short)base.Linker.FromActivityInstance.CompleteOrder.Value;
var nextActivityInstance = sqList[currentNodeIndex];
nextActivityInstance.ActivityState = (short)ActivityStateEnum.Ready;
base.ActivityInstanceManager.Update(nextActivityInstance, session);
canContinueForwardCurrentNode = false;
base.WfNodeMediatedResult.Feedback = WfNodeMediatedFeedback.ForwardToNextSequenceTask;
}
else if (base.Linker.FromActivityInstance.CompleteOrder == maxOrder)
{
//完成最后一个会签任务，会签主节点状态由挂起设置为准备状态
mainActivityInstance.ActivityState = (short)ActivityStateEnum.Completed;
base.ActivityInstanceManager.Update(mainActivityInstance, session);
}
}
else if (base.Linker.FromActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Parallel)
{
var allCount = sqList.Count();
var completedCount = sqList.Where<ActivityInstanceEntity>(w => w.ActivityState == (short)ActivityStateEnum.Completed)
.ToList<ActivityInstanceEntity>()
.Count();
if (completedCount / allCount >= mainActivityInstance.CompleteOrder)
{
//如果超过约定的比例数，则执行下一步节点
mainActivityInstance.ActivityState = (short)ActivityStateEnum.Completed;
base.ActivityInstanceManager.Update(mainActivityInstance, session);
}
else
{
canContinueForwardCurrentNode = false;
base.WfNodeMediatedResult.Feedback = WfNodeMediatedFeedback.WaitingForCompletedMore;
}
}
}
return canContinueForwardCurrentNode;
}
/// <summary>
/// 退回是会签情况下的处理：
/// 要退回的节点是会签节点
/// 1) 全部实例化会签节点下的多实例节点
/// 2) 只取得办理完成的节点，而且保证CompleteOrder的唯一性
/// </summary>
/// <param name="processInstance"></param>
/// <param name="originalBackwardToActivityInstance"></param>
/// <param name="backwardType"></param>
/// <param name="backSrcActivityInstanceID"></param>
/// <param name="activityResource"></param>
/// <param name="session"></param>
internal void CreateBackwardActivityTaskRepeatedSignTogetherMultipleInstance(ProcessInstanceEntity processInstance,
ActivityEntity backwardToTaskActvity,
ActivityInstanceEntity fromActivityInstance,
BackwardTypeEnum backwardType,
ActivityInstanceEntity previousMainInstance,
string transitionGUID,
TransitionTypeEnum transitionType,
TransitionFlyingTypeEnum flyingType,
ActivityResource activityResource,
IDbSession session)
{
//上一步节点是会签节点的退回处理
//需要重新实例化会签节点上的所有办理人的任务
//重新封装任务办理人为AssignedToUsers, AssignedToUsernames
var performerList = AntiGenerateActivityPerformerList(previousMainInstance);
activityResource.NextActivityPerformers.Clear();
activityResource.NextActivityPerformers = new Dictionary<string, PerformerList>();
activityResource.NextActivityPerformers.Add(backwardToTaskActvity.ActivityGUID, performerList);
//重新生成会签节点的多实例数据
CreateMultipleInstance(backwardToTaskActvity, processInstance, fromActivityInstance,
transitionGUID, transitionType, flyingType, activityResource, session);
}
/// <summary>
/// 启动流程的上下文对象
/// </summary>
/// <param name="processModel"></param>
/// <param name="processInstance"></param>
/// <param name="activity"></param>
/// <param name="activityResource"></param>
/// <returns></returns>
internal static ActivityForwardContext CreateStartupContext(ProcessModel processModel,
ProcessInstanceEntity processInstance,
ActivityEntity activity,
ActivityResource activityResource)
{
return new ActivityForwardContext(processModel, processInstance, activity, activityResource);
}
/// <summary>
/// 递归获取满足条件的下一步节点列表
/// </summary>
/// <param name="root"></param>
/// <param name="activityResource"></param>
/// <param name="expression"></param>
/// <returns></returns>
private NextActivityComponent GetNextActivityListByExpressionRecurisivly(NextActivityComponent root,
ActivityResource activityResource,
Expression<Func<ActivityResource, ActivityEntity, bool>> expression)
{
NextActivityComponent r1 = null;
foreach (NextActivityComponent c in root)
{
if (c.HasChildren)
{
NextActivityComponent child = GetNextActivityListByExpressionRecurisivly(c, activityResource, expression);
r1 = AddChildToNewGatewayComponent(r1, c, child);
}
else
{
if (expression.Compile().Invoke(activityResource, c.Activity))
{
r1 = AddChildToNewGatewayComponent(r1, root, c);
}
}
}
return r1;
}
/// <summary>
/// 创建活动任务转移实例数据
/// </summary>
/// <param name="toActivity"></param>
/// <param name="processInstance"></param>
/// <param name="fromActivityInstance"></param>
/// <param name="transitionGUID"></param>
/// <param name="transitionType"></param>
/// <param name="flyingType"></param>
/// <param name="activityResource"></param>
/// <param name="session"></param>
internal override void CreateActivityTaskTransitionInstance(ActivityEntity toActivity,
ProcessInstanceEntity processInstance,
ActivityInstanceEntity fromActivityInstance,
string transitionGUID,
TransitionTypeEnum transitionType,
TransitionFlyingTypeEnum flyingType,
ActivityResource activityResource,
IDbSession session)
{
//判断是否是会签节点，如果是创建会签节点
if (toActivity.ActivityTypeDetail != null
&& toActivity.ActivityTypeDetail.ComplexType == ComplexTypeEnum.SignTogether)
{
//创建会签节点的主节点，以及会签主节点下的实例子节点记录
CreateMultipleInstance(toActivity, processInstance, fromActivityInstance,
transitionGUID, transitionType, flyingType, activityResource, session);
}
else
{
//实例化Activity
var toActivityInstance = base.CreateActivityInstanceObject(toActivity, processInstance, activityResource.AppRunner);
//进入运行状态
toActivityInstance.ActivityState = (short)ActivityStateEnum.Ready;
toActivityInstance.AssignedToUserIDs = GenerateActivityAssignedUserIDs(
activityResource.NextActivityPerformers[toActivity.ActivityGUID]);
toActivityInstance.AssignedToUserNames = GenerateActivityAssignedUserNames(
activityResource.NextActivityPerformers[toActivity.ActivityGUID]);
//插入活动实例数据
base.ActivityInstanceManager.Insert(toActivityInstance, session);
//插入任务数据
base.CreateNewTask(toActivityInstance, activityResource, session);
//插入转移数据
InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
transitionType,
flyingType,
activityResource.AppRunner,
session);
}
}
/// <summary>
/// 创建运行时实例
/// </summary>
/// <param name="appName"></param>
/// <param name="appInstanceID"></param>
/// <param name="processGUID"></param>
/// <param name="userID"></param>
/// <param name="userName"></param>
/// <param name="nextActivityPerformers"></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.GetRunningNodeOfMine(runner, out taskView);
//判断是否是当前登录用户的任务
if (runningNode.AssignedToUsers.Contains(runner.UserID.ToString()) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.RunApp_HasNoTask;
result.Message = "当前没有登录用户要办理的任务，无法运行流程！";
return rmins;
}
var processModel = new ProcessModel(runningNode.ProcessGUID);
var activityResource = new ActivityResource(runner, runner.NextActivityPerformers, runner.Conditions);
var tm = new TaskManager();
rmins.TaskView = taskView;
rmins.RunningActivityInstance = runningNode;
rmins.ProcessModel = processModel;
rmins.ActivityResource = activityResource;
return rmins;
}
/// <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.GetRunningNodeOfMine(runner, out taskView);
//传递runner变量
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 = (new ProcessModel(runner.ProcessGUID));
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="taskID"></param>
/// <param name="activityResource"></param>
/// <param name="session"></param>
internal bool CompleteWorkItem(TaskViewEntity taskView,
ActivityResource activityResource,
IDbSession session)
{
bool canContinueForwardCurrentNode = true;
//流程强制拉取向前跳转时，没有运行人的任务实例
if (taskView != null)
{
//完成本任务，返回任务已经转移到下一个会签任务，不继续执行其它节点
base.TaskManager.Complete(taskView.TaskID, activityResource.AppRunner, session);
}
//设置活动节点的状态为完成状态
base.ActivityInstanceManager.Complete(base.Linker.FromActivityInstance.ID,
activityResource.AppRunner,
session);
base.Linker.FromActivityInstance.ActivityState = (short)ActivityStateEnum.Completed;
//多实例会签和加签处理
//先判断是否是会签和加签类型
//主节点不为空时不发起加签可以正常运行
var complexType = base.Linker.FromActivity.ActivityTypeDetail.ComplexType;
if (complexType == ComplexTypeEnum.SignTogether
|| complexType == ComplexTypeEnum.SignForward && base.Linker.FromActivityInstance.MIHostActivityInstanceID != null)
{
//取出主节点信息
var mainNodeIndex = base.Linker.FromActivityInstance.MIHostActivityInstanceID.Value;
var mainActivityInstance = base.ActivityInstanceManager.GetById(mainNodeIndex);
//取出处于多实例节点列表
var sqList = base.ActivityInstanceManager.GetActivityMulitipleInstanceWithState(
mainNodeIndex,
base.Linker.FromActivityInstance.ProcessInstanceID,
(short)ActivityStateEnum.Suspended,
session).ToList<ActivityInstanceEntity>();
//串行会签和并行会签的处理
if (complexType == ComplexTypeEnum.SignTogether)
{
if (base.Linker.FromActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Sequence) //串行会签处理
{
short maxOrder = 0;
if (sqList != null && sqList.Count > 0)
{
//取出最大执行节点
maxOrder = (short)sqList.Max<ActivityInstanceEntity>(t => t.CompleteOrder.Value);
}
else
{
//最后一个执行节点
maxOrder = (short)base.Linker.FromActivityInstance.CompleteOrder.Value;
}
//串行会签通过率（按人数判断）
if (mainActivityInstance.CompleteOrder != null && mainActivityInstance.CompleteOrder <= maxOrder)
{
maxOrder = (short)mainActivityInstance.CompleteOrder;
}
if (base.Linker.FromActivityInstance.CompleteOrder < maxOrder)
{
//设置下一个任务进入准备状态
var currentNodeIndex = (short)base.Linker.FromActivityInstance.CompleteOrder.Value;
var nextActivityInstance = sqList[0]; //始终取第一条挂起实例
nextActivityInstance.ActivityState = (short)ActivityStateEnum.Ready;
base.ActivityInstanceManager.Update(nextActivityInstance, session);
canContinueForwardCurrentNode = false;
base.WfNodeMediatedResult.Feedback = WfNodeMediatedFeedback.ForwardToNextSequenceTask;
}
else if (base.Linker.FromActivityInstance.CompleteOrder == maxOrder)
{
//完成最后一个会签任务，会签主节点状态由挂起设置为准备状态
mainActivityInstance.ActivityState = (short)ActivityStateEnum.Completed;
base.ActivityInstanceManager.Update(mainActivityInstance, session);
}
}
else if (base.Linker.FromActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Parallel) //并行会签处理
{
if (mainActivityInstance.CompleteOrder == null)//并行会签未设置通过率的判断
mainActivityInstance.CompleteOrder = 1;
var allCount = sqList.Count();
var completedCount = sqList.Where<ActivityInstanceEntity>(w => w.ActivityState == (short)ActivityStateEnum.Completed)
.ToList<ActivityInstanceEntity>()
.Count();
if ((completedCount * 0.01) / (allCount * 0.01) >= mainActivityInstance.CompleteOrder)
{
//如果超过约定的比例数，则执行下一步节点
mainActivityInstance.ActivityState = (short)ActivityStateEnum.Completed;
base.ActivityInstanceManager.Update(mainActivityInstance, session);
}
else
{
canContinueForwardCurrentNode = false;
base.WfNodeMediatedResult.Feedback = WfNodeMediatedFeedback.WaitingForCompletedMore;
}
}
}
else if (complexType == ComplexTypeEnum.SignForward) //加签的处理
{
//判断加签是否全部完成，如果是，则流转到下一步，否则不能流转
var signforwardType = (SignForwardTypeEnum)Enum.Parse(typeof(SignForwardTypeEnum),
base.ActivityForwardContext.FromActivityInstance.SignForwardType.Value.ToString());
if (signforwardType == SignForwardTypeEnum.SignForwardBehind
|| signforwardType == SignForwardTypeEnum.SignForwardBefore)
{
short maxOrder = 0;
if (sqList != null && sqList.Count > 0)
{
//取出最大执行节点
maxOrder = (short)sqList.Max<ActivityInstanceEntity>(t => t.CompleteOrder.Value);
}
else
{
//最后一个执行节点
maxOrder = (short)base.Linker.FromActivityInstance.CompleteOrder.Value;
}
//加签通过率
if (mainActivityInstance.CompleteOrder != null)
{
maxOrder = (short)mainActivityInstance.CompleteOrder;
}
if (base.Linker.FromActivityInstance.CompleteOrder < maxOrder)
{
//设置下一个节点进入等待办理状态
var currentNodeIndex = (short)base.Linker.FromActivityInstance.CompleteOrder.Value;
var nextActivityInstance = sqList[0];
nextActivityInstance.ActivityState = (short)ActivityStateEnum.Ready;
base.ActivityInstanceManager.Update(nextActivityInstance, session);
canContinueForwardCurrentNode = false;
base.WfNodeMediatedResult.Feedback = WfNodeMediatedFeedback.ForwardToNextSequenceTask;
}
else if (base.Linker.FromActivityInstance.CompleteOrder == maxOrder)
{
//最后一个节点执行完，主节点进入完成状态，整个流程向下执行
mainActivityInstance.ActivityState = (short)ActivityStateEnum.Completed;
base.ActivityInstanceManager.Update(mainActivityInstance, session);
}
}
else if (signforwardType == SignForwardTypeEnum.SignForwardParallel)
{
//并行加签，按照通过率来决定是否标识当前节点完成
var allCount = sqList.Count();
var completedCount = sqList.Where<ActivityInstanceEntity>(w => w.ActivityState == (short)ActivityStateEnum.Completed)
.ToList<ActivityInstanceEntity>()
.Count();
if ((completedCount * 0.01) / (allCount * 0.01) >= mainActivityInstance.CompleteOrder)
{
base.ActivityForwardContext.FromActivityInstance.ActivityState = (short)ActivityStateEnum.Completed;
mainActivityInstance.ActivityState = (short)ActivityStateEnum.Completed;
base.ActivityInstanceManager.Update(mainActivityInstance, base.Session);
}
else
{
canContinueForwardCurrentNode = false;
base.WfNodeMediatedResult.Feedback = WfNodeMediatedFeedback.WaitingForCompletedMore;
}
}
}
}
return canContinueForwardCurrentNode;
}
/// <summary>
/// 获取下一步节点列表（伴随条件和资源）
/// </summary>
/// <param name="currentActivity"></param>
/// <param name="conditionKeyValuePair"></param>
/// <returns></returns>
internal NextActivityMatchedResult GetNextActivityList(string currentActivityGUID,
IDictionary<string, string> conditionKeyValuePair,
ActivityResource activityResource,
Expression<Func<ActivityResource, ActivityEntity, bool>> expression)
{
NextActivityComponent newRoot = NextActivityComponentFactory.CreateNextActivityComponent();
//先获取未加运行时表达式过滤的下一步节点列表
NextActivityMatchedResult result = GetNextActivityList(currentActivityGUID,
conditionKeyValuePair);
foreach (NextActivityComponent c in result.Root)
{
if (c.HasChildren)
{
NextActivityComponent child = GetNextActivityListByExpressionRecurisivly(c, activityResource, expression);
if (child != null)
{
newRoot.Add(child);
}
}
else
{
if (expression.Compile().Invoke(activityResource, c.Activity))
{
newRoot.Add(c);
}
}
}
NextActivityMatchedResult newResult = null;
if (newRoot.HasChildren)
{
newResult = NextActivityMatchedResult.CreateNextActivityMatchedResultObject(result.MatchedType, newRoot);
}
else
{
newResult = NextActivityMatchedResult.CreateNextActivityMatchedResultObject(NextActivityMatchedType.NoneTransitionFilteredByCondition,
newRoot);
}
return newResult;
}
/// <summary>
/// 创建流程跳转上下文对象
/// </summary>
/// <param name="jumpforwardActivity"></param>
/// <param name="processModel"></param>
/// <param name="processInstance"></param>
/// <param name="activityResource"></param>
/// <returns></returns>
internal static ActivityForwardContext CreateJumpforwardContext(ActivityEntity jumpforwardActivity,
ProcessModel processModel,
ProcessInstanceEntity processInstance,
ActivityResource activityResource)
{
return new ActivityForwardContext(processModel, processInstance, jumpforwardActivity, activityResource);
}
public GatewayExecutedResult CompleteAutomaticlly(ProcessInstanceEntity processInstance,
string transitionGUID,
ActivityInstanceEntity fromActivityInstance,
ActivityResource activityResource,
IDbSession session)
{
GatewayExecutedResult result = GatewayExecutedResult.CreateGatewayExecutedResult(GatewayExecutedStatus.Unknown);
bool canRenewInstance = false;
//检查是否有运行中的合并节点实例
ActivityInstanceEntity joinNode = base.ActivityInstanceManager.GetActivityRunning(
processInstance.ID,
base.GatewayActivity.ActivityGUID,
session);
if (joinNode == null)
{
canRenewInstance = true;
}
else
{
//判断是否可以激活下一步节点
canRenewInstance = (joinNode.CanRenewInstance == 1);
if (!canRenewInstance)
{
result = GatewayExecutedResult.CreateGatewayExecutedResult(GatewayExecutedStatus.FallBehindOfXOrJoin);
return result;
}
}
if (canRenewInstance)
{
var gatewayActivityInstance = base.CreateActivityInstanceObject(base.GatewayActivity,
processInstance, activityResource.AppRunner);
gatewayActivityInstance.GatewayDirectionTypeID = (short)GatewayDirectionEnum.XOrJoin;
base.InsertActivityInstance(gatewayActivityInstance,
session);
base.CompleteActivityInstance(gatewayActivityInstance.ID,
activityResource,
session);
gatewayActivityInstance.ActivityState = (short)ActivityStateEnum.Completed;
base.GatewayActivityInstance = gatewayActivityInstance;
//写节点转移实例数据
base.InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
gatewayActivityInstance,
TransitionTypeEnum.Forward,
TransitionFlyingTypeEnum.NotFlying,
activityResource.AppRunner,
session);
result = GatewayExecutedResult.CreateGatewayExecutedResult(GatewayExecutedStatus.Successed);
}
return result;
}
/// <summary>
/// 完成任务实例
/// </summary>
/// <param name="taskID"></param>
/// <param name="activityResource"></param>
/// <param name="session"></param>
internal bool CompleteWorkItem(long taskID,
ActivityResource activityResource,
IDbSession session)
{
bool canContinueForwardCurrentNode = true;
//完成本任务，返回任务已经转移到下一个会签任务，不继续执行其它节点
base.TaskManager.Complete(taskID, activityResource.AppRunner, session);
//设置活动节点的状态为完成状态
base.ActivityInstanceManager.Complete(base.Linker.FromActivityInstance.ID,
activityResource.AppRunner,
session);
base.Linker.FromActivityInstance.ActivityState = (short)ActivityStateEnum.Completed;
//先判断是否是多实例类型的任务
if (base.Linker.FromActivity.ActivityTypeDetail.ComplexType == ComplexTypeEnum.SignTogether)
{
//取出主节点信息
var mainNodeIndex = base.Linker.FromActivityInstance.MIHostActivityInstanceID.Value;
var mainActivityInstance = base.ActivityInstanceManager.GetById(mainNodeIndex);
//取出多实例节点列表
var sqList = base.ActivityInstanceManager.GetActivityMulitipleInstanceWithState(
mainNodeIndex,
base.Linker.FromActivityInstance.ProcessInstanceID,
(short)ActivityStateEnum.Suspended,
session).ToList<ActivityInstanceEntity>();
if (base.Linker.FromActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Sequence)
{
//取出最大执行节点
short maxOrder = (short)sqList.Max<ActivityInstanceEntity>(t => t.CompleteOrder).Value;
if (base.Linker.FromActivityInstance.CompleteOrder < maxOrder)
{
//设置下一个任务进入准备状态
var currentNodeIndex = (short)base.Linker.FromActivityInstance.CompleteOrder.Value;
var nextActivityInstance = sqList[currentNodeIndex];
nextActivityInstance.ActivityState = (short)ActivityStateEnum.Ready;
base.ActivityInstanceManager.Update(nextActivityInstance, session);
//设置下一个任务对应的子流程进入运行状态
base.ProcessInstanceManager.RecallSubProcess(nextActivityInstance.ID,
activityResource.AppRunner,
Session);
canContinueForwardCurrentNode = false;
base.WfNodeMediatedResult.Feedback = WfNodeMediatedFeedback.ForwardToNextSequenceTask;
}
else if (base.Linker.FromActivityInstance.CompleteOrder == maxOrder)
{
//完成最后一个会签任务，会签主节点状态由挂起设置为准备状态
mainActivityInstance.ActivityState = (short)ActivityStateEnum.Completed;
base.ActivityInstanceManager.Update(mainActivityInstance, session);
//将执行权责交由会签主节点
base.Linker.FromActivityInstance = mainActivityInstance;
}
}
else if (base.Linker.FromActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Parallel)
{
var allCount = sqList.Count();
var completedCount = sqList.Where<ActivityInstanceEntity>(w => w.ActivityState == (short)ActivityStateEnum.Completed)
.ToList<ActivityInstanceEntity>()
.Count();
if (completedCount / allCount >= mainActivityInstance.CompleteOrder)
{
//如果超过约定的比例数，则执行下一步节点
mainActivityInstance.ActivityState = (short)ActivityStateEnum.Completed;
base.ActivityInstanceManager.Update(mainActivityInstance, session);
//将执行权责交由会签主节点
base.Linker.FromActivityInstance = mainActivityInstance;
}
else
{
canContinueForwardCurrentNode = false;
base.WfNodeMediatedResult.Feedback = WfNodeMediatedFeedback.WaitingForCompletedMore;
}
}
}
return canContinueForwardCurrentNode;
}
/// <summary>
/// 创建加签节点记录
/// </summary>
/// <param name="activityResource"></param>
private void CreateSignForwardTasks(ActivityResource activityResource)
{
SignForwardTypeEnum signForwardType = (SignForwardTypeEnum)Enum.Parse(typeof(SignForwardTypeEnum),
base.ActivityForwardContext.ActivityResource.DynamicVariables["SignForwardType"]);
//根据当前活动实例的记录为加签发起人创建一条新的记录，并修改CompleteOrder
var newActivityInstance = base.ActivityInstanceManager.CreateActivityInstanceObject(base.ActivityForwardContext.FromActivityInstance);
newActivityInstance.AssignedToUserIDs = activityResource.AppRunner.UserID;
newActivityInstance.AssignedToUserNames = activityResource.AppRunner.UserName;
newActivityInstance.MIHostActivityInstanceID = base.ActivityForwardContext.FromActivityInstance.ID;
newActivityInstance.SignForwardType = (short)signForwardType;
if (signForwardType == SignForwardTypeEnum.SignForwardParallel)
{
if (base.ActivityForwardContext.ActivityResource.DynamicVariables.ContainsKey("SignForwardCompleteOrder"))
newActivityInstance.CompleteOrder = float.Parse(base.ActivityForwardContext.ActivityResource.DynamicVariables["SignForwardCompleteOrder"]);
else
newActivityInstance.CompleteOrder = 1;
}
newActivityInstance.ComplexType = (short)ComplexTypeEnum.SignForward;
//获取加签人集合
var plist = activityResource.NextActivityPerformers[base.ActivityForwardContext.Activity.ActivityGUID];
//前加签是别人先审核，然后自己再审核
if (signForwardType == SignForwardTypeEnum.SignForwardBefore)
{
newActivityInstance.CompleteOrder = plist.Count + 1;
newActivityInstance.ActivityState = (short)ActivityStateEnum.Suspended;
}
else if (signForwardType == SignForwardTypeEnum.SignForwardBehind)
{
//后加签是自己审批后，其他接收人再加签
newActivityInstance.CompleteOrder = 1;
}
//主节点挂起后，插入当前人的加签记录信息, 并插入任务记录
base.ActivityInstanceManager.Insert(newActivityInstance, base.Session);
var signer = new Performer(base.ActivityForwardContext.ActivityResource.AppRunner.UserID,
base.ActivityForwardContext.ActivityResource.AppRunner.UserName);
base.TaskManager.Insert(newActivityInstance, signer, base.ActivityForwardContext.ActivityResource.AppRunner, base.Session);
//创建新加签节点记录
var signforwardActivityInstance = new ActivityInstanceEntity();
for (var i = 0; i < plist.Count; i++)
{
signforwardActivityInstance = base.ActivityInstanceManager.CreateActivityInstanceObject(base.ActivityForwardContext.FromActivityInstance);
signforwardActivityInstance.ComplexType = (short)ComplexTypeEnum.SignForward;
signforwardActivityInstance.AssignedToUserIDs = plist[i].UserID;
signforwardActivityInstance.AssignedToUserNames = plist[i].UserName;
signforwardActivityInstance.MIHostActivityInstanceID = base.ActivityForwardContext.FromActivityInstance.ID;
if (signForwardType == SignForwardTypeEnum.SignForwardBefore)
{
signforwardActivityInstance.CompleteOrder = (short)(i + 1);
if (i > 0)
{
//加签是串行加签，逐次完成
signforwardActivityInstance.ActivityState = (short)ActivityStateEnum.Suspended;
}
}
else if (signForwardType == SignForwardTypeEnum.SignForwardBehind)
{
signforwardActivityInstance.CompleteOrder = (short)(i + 2);
signforwardActivityInstance.ActivityState = (short)ActivityStateEnum.Suspended;
}
signforwardActivityInstance.SignForwardType = (short)signForwardType;
base.ActivityInstanceManager.Insert(signforwardActivityInstance, base.Session);
base.TaskManager.Insert(signforwardActivityInstance, plist[i], activityResource.AppRunner, base.Session);
}
}
/// <summary>
/// 会签类型的主节点, 多实例节点处理
/// </summary>
/// <param name="processInstance"></param>
/// <param name="fromToTransition"></param>
/// <param name="fromActivityInstance"></param>
/// <param name="activityResource"></param>
/// <param name="session"></param>
internal void CreateMultipleInstance(ActivityEntity toActivity,
ProcessInstanceEntity processInstance,
ActivityInstanceEntity fromActivityInstance,
String transitionGUID,
TransitionTypeEnum transitionType,
TransitionFlyingTypeEnum flyingType,
ActivityResource activityResource,
IDbSession session)
{
//实例化主节点Activity
var toActivityInstance = CreateActivityInstanceObject(toActivity,
processInstance, activityResource.AppRunner);
//主节点实例数据
toActivityInstance.ActivityState = (short)ActivityStateEnum.Suspended;
toActivityInstance.ComplexType = (short)ComplexTypeEnum.SignTogether;
if (toActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Parallel)
{
toActivityInstance.CompleteOrder = toActivity.ActivityTypeDetail.CompleteOrder;
}
toActivityInstance.AssignedToUserIDs = GenerateActivityAssignedUserIDs(
activityResource.NextActivityPerformers[toActivity.ActivityGUID]);
//插入主节点实例数据
base.ActivityInstanceManager.Insert(toActivityInstance, session);
//插入主节点转移数据
InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
transitionType,
flyingType,
activityResource.AppRunner,
session);
//插入会签子节点实例数据
var plist = activityResource.NextActivityPerformers[toActivity.ActivityGUID];
ActivityInstanceEntity entity = new ActivityInstanceEntity();
for (short i = 0; i < plist.Count; i++)
{
entity = base.ActivityInstanceManager.CreateActivityInstanceObject(toActivityInstance);
entity.AssignedToUserIDs = plist[i].UserID;
entity.AssignedToUserNames = plist[i].UserName;
entity.MIHostActivityInstanceID = toActivityInstance.ID;
entity.CompleteOrder = (short)(i + 1);
//只有第一个节点处于运行状态，其它节点挂起
if ((i > 0) && (toActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Sequence))
{
entity.ActivityState = (short)ActivityStateEnum.Suspended;
}
//插入活动实例数据，并返回活动实例ID
entity.ID = base.ActivityInstanceManager.Insert(entity, session);
//插入任务数据
base.TaskManager.Insert(entity, plist[i], activityResource.AppRunner, session);
//启动子流程
IDbSession subSession = SessionFactory.CreateSession();
WfExecutedResult startedResult = null;
var subProcessNode = (SubProcessNode)toActivity.Node;
subProcessNode.ActivityInstance = entity; //在流程实例表中记录激活子流程的活动节点ID
WfAppRunner subRunner = CopyActivityForwardRunner(activityResource.AppRunner,
plist[i],
subProcessNode);
var runtimeInstance = WfRuntimeManagerFactory.CreateRuntimeInstanceStartup(subRunner,
processInstance,
subProcessNode,
ref startedResult);
if (runtimeInstance.WfExecutedResult.Status == WfExecutedStatus.Exception)
{
throw new WfRuntimeException(runtimeInstance.WfExecutedResult.Message);
}
runtimeInstance.Execute(subSession);
//如果是串行会签，只有第一个子流程可以运行，其它子流程处于挂起状态
if ((i > 0) && (toActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Sequence))
{
var startResult = (WfExecutedResult)runtimeInstance.WfExecutedResult;
base.ProcessInstanceManager.Suspend(startedResult.ProcessInstanceIDStarted, subRunner, subSession);
}
}
}
/// <summary>
/// 加签操作
/// </summary>
/// <param name="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;
}
internal override void CreateActivityTaskTransitionInstance(ActivityEntity toActivity,
ProcessInstanceEntity processInstance,
ActivityInstanceEntity fromActivityInstance,
string transitionGUID,
TransitionTypeEnum transitionType,
TransitionFlyingTypeEnum flyingType,
ActivityResource activityResource,
IDbSession session)
{
if (toActivity.ActivityTypeDetail.ComplexType == ComplexTypeEnum.SignTogether)
{
CreateMultipleInstance(toActivity, processInstance, fromActivityInstance,
transitionGUID, transitionType, flyingType, activityResource, session);
}
else
{
//实例化Activity
var toActivityInstance = CreateActivityInstanceObject(toActivity, processInstance, activityResource.AppRunner);
//进入运行状态
toActivityInstance.ActivityState = (short)ActivityStateEnum.Ready;
toActivityInstance.AssignedToUserIDs = GenerateActivityAssignedUserIDs(
activityResource.NextActivityPerformers[toActivity.ActivityGUID]);
toActivityInstance.AssignedToUserNames = GenerateActivityAssignedUserNames(
activityResource.NextActivityPerformers[toActivity.ActivityGUID]);
//插入活动实例数据
base.ActivityInstanceManager.Insert(toActivityInstance, session);
//插入任务数据
base.CreateNewTask(toActivityInstance, activityResource, session);
//插入转移数据
InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
transitionType,
flyingType,
activityResource.AppRunner,
session);
//启动子流程
WfExecutedResult startedResult = null;
var subProcessNode = (SubProcessNode)toActivity.Node;
subProcessNode.ActivityInstance = toActivityInstance;
WfAppRunner subRunner = CopyActivityForwardRunner(activityResource.AppRunner,
new Performer(activityResource.AppRunner.UserID,
activityResource.AppRunner.UserName),
subProcessNode);
var runtimeInstance = WfRuntimeManagerFactory.CreateRuntimeInstanceStartup(subRunner,
processInstance,
subProcessNode,
ref startedResult);
runtimeInstance.Execute(Session);
}
}
/// <summary>
/// 置开始节点为结束状态
/// </summary>
/// <param name="processInstance"></param>
/// <param name="activityResource"></param>
/// <param name="session"></param>
/// <returns></returns>
private GatewayExecutedResult CompleteAutomaticlly(ProcessInstanceEntity processInstance,
ActivityResource activityResource,
IDbSession session)
{
//开始节点没前驱信息
var fromActivityInstance = base.CreateActivityInstanceObject(base.Linker.FromActivity, processInstance, activityResource.AppRunner);
base.ActivityInstanceManager.Insert(fromActivityInstance, session);
base.ActivityInstanceManager.Complete(fromActivityInstance.ID,
activityResource.AppRunner,
session);
fromActivityInstance.ActivityState = (short)ActivityStateEnum.Completed;
base.Linker.FromActivityInstance = fromActivityInstance;
GatewayExecutedResult result = GatewayExecutedResult.CreateGatewayExecutedResult(GatewayExecutedStatus.Successed);
return result;
}
/// <summary>
/// 节点对象的完成方法
/// </summary>
/// <param name="ActivityInstanceID"></param>
/// <param name="activityResource"></param>
/// <param name="wfLinqDataContext"></param>
internal virtual void CompleteActivityInstance(int ActivityInstanceID,
ActivityResource activityResource,
IDbSession session)
{
//设置完成状态
ActivityInstanceManager.Complete(ActivityInstanceID,
activityResource.AppRunner,
session);
}
/// <summary>
/// 创建任务执行上下文对象
/// </summary>
/// <param name="task"></param>
/// <param name="processModel"></param>
/// <param name="activityResource"></param>
/// <returns></returns>
internal static ActivityForwardContext CreateRunningContext(TaskViewEntity task,
ProcessModel processModel,
ActivityResource activityResource)
{
return new ActivityForwardContext(task, processModel, activityResource);
}
/// <summary>
/// 退回是加签情况下的处理：
/// 要退回的节点是加签节点
/// 只实例化当初的加签主节点
/// </summary>
/// <param name="processInstance"></param>
/// <param name="backwardToTaskActvity"></param>
/// <param name="fromActivityInstance"></param>
/// <param name="backwardType"></param>
/// <param name="previousMainInstance"></param>
/// <param name="transitionGUID"></param>
/// <param name="transitionType"></param>
/// <param name="flyingType"></param>
/// <param name="activityResource"></param>
/// <param name="session"></param>
internal void CreateBackwardActivityTaskRepateSignForwardMainNodeOnly(ProcessInstanceEntity processInstance,
ActivityEntity backwardToTaskActvity,
ActivityInstanceEntity fromActivityInstance,
BackwardTypeEnum backwardType,
ActivityInstanceEntity previousMainInstance,
string transitionGUID,
TransitionTypeEnum transitionType,
TransitionFlyingTypeEnum flyingType,
ActivityResource activityResource,
IDbSession session)
{
// 退回是加签情况下的处理：
// 要退回的节点是加签节点
// 只实例化当初的加签主节点
//重新封装任务办理人为AssignedToUsers, AssignedToUsernames
var performerList = AntiGenerateActivityPerformerList(previousMainInstance);
activityResource.NextActivityPerformers.Clear();
activityResource.NextActivityPerformers = new Dictionary<string, PerformerList>();
activityResource.NextActivityPerformers.Add(backwardToTaskActvity.ActivityGUID, performerList);
//实例化Activity
var toActivityInstance = base.CreateBackwardToActivityInstanceObject(processInstance,
backwardType,
previousMainInstance.ID,
activityResource.AppRunner);
//进入准备运行状态
toActivityInstance.ActivityState = (short)ActivityStateEnum.Ready;
toActivityInstance.AssignedToUserIDs = previousMainInstance.AssignedToUserIDs;
toActivityInstance.AssignedToUserNames = previousMainInstance.AssignedToUserNames;
toActivityInstance.ComplexType = previousMainInstance.ComplexType;
toActivityInstance.CompleteOrder = previousMainInstance.CompleteOrder;
toActivityInstance.SignForwardType = previousMainInstance.SignForwardType;
//插入活动实例数据
base.ActivityInstanceManager.Insert(toActivityInstance,
session);
//插入任务数据
base.CreateNewTask(toActivityInstance, activityResource, session);
//插入转移数据
base.InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
transitionType,
flyingType,
activityResource.AppRunner,
session);
}
