public virtual ReturnInfo <bool> ModifyToReadedById([DisplayName2("ID"), Id] int id, string connectionId = null, BasicUserInfo currUser = null)
{
return(ExecReturnFuncAndConnectionId <bool>((reInfo, connId) =>
{
WorkflowHandleInfo wh = Persistence.Select(id, connId);
if (wh == null)
{
reInfo.SetFailureMsg("找不到该工作流处理记录");
return false;
}
var user = UserTool.GetCurrUser(currUser);
if (wh.HandlerId != user.Id)
{
reInfo.SetFailureMsg("Sorry!不是您处理的无权限修改");
return false;
}
if (wh.IsReaded)
{
return false;
}
wh.IsReaded = true;
wh.SetModifyInfo(currUser);
return Persistence.UpdateIsReadedById(wh, connId) > 0;
}, null, connectionId));
}
public virtual ReturnInfo <WorkflowInfo> FindAuditDetail([DisplayName2("ID"), Id] int id, [DisplayName2("处理ID"), Id] int handleId, string connectionId = null, BasicUserInfo currUser = null)
{
ReturnInfo <WorkflowInfo> returnInfo = FindContainHandlesAndAllConfigs(id, connectionId, currUser);
if (returnInfo.Failure())
{
return(returnInfo);
}
WorkflowHandleInfo currHandle = null;
foreach (var h in returnInfo.Data.Handles)
{
if (h.Id == handleId)
{
currHandle = h;
break;
}
}
BasicReturnInfo basicReturn = WorkflowUtil.CanCurrUserAudit(currHandle, currUser);
if (basicReturn.Failure())
{
returnInfo.FromBasic(basicReturn);
}
return(returnInfo);
}
public virtual ReturnInfo <WorkflowInfo> FindAuditedDetail([DisplayName2("ID"), Id] int id, [DisplayName2("处理ID"), Id] int handleId, string connectionId = null, BasicUserInfo currUser = null)
{
ReturnInfo <WorkflowInfo> returnInfo = FindContainHandlesAndAllConfigs(id, connectionId, currUser);
if (returnInfo.Failure())
{
return(returnInfo);
}
WorkflowHandleInfo currHandle = null;
foreach (var h in returnInfo.Data.Handles)
{
if (h.Id == handleId)
{
currHandle = h;
break;
}
}
if (currHandle.HandleStatus == HandleStatusEnum.UN_HANDLE)
{
returnInfo.SetFailureMsg("您还未处理该流程");
return(returnInfo);
}
if (currHandle.HandleStatus == HandleStatusEnum.EFFICACYED)
{
returnInfo.SetFailureMsg("您还处理的流程已失效");
return(returnInfo);
}
return(returnInfo);
}
/// <summary>
/// 根据ID查找待审核明细信息
/// </summary>
/// <param name="id">ID</param>
/// <param name="handleId">处理ID</param>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
/// <returns>返回信息</returns>
public virtual ReturnInfo <WorkflowInfo> FindWaitDetail([DisplayName2("ID"), Id] int id, [DisplayName2("处理ID"), Id] int handleId, CommonUseData comData = null, string connectionId = null)
{
ReturnInfo <WorkflowInfo> returnInfo = FindContainHandlesAndAllConfigs(id, connectionId: connectionId, comData: comData);
if (returnInfo.Failure())
{
return(returnInfo);
}
WorkflowHandleInfo currHandle = null;
foreach (var h in returnInfo.Data.Handles)
{
if (h.Id == handleId)
{
currHandle = h;
break;
}
}
if (currHandle.HandleStatus == HandleStatusEnum.EFFICACYED)
{
returnInfo.SetFailureMsg("您还未处理的流程已失效");
return(returnInfo);
}
return(returnInfo);
}
/// <summary>
/// 根据ID更新是否已读
/// </summary>
/// <param name="workflowHandle">工作流处理</param>
/// <param name="connectionId">连接ID</param>
/// <returns>影响行数</returns>
public int UpdateIsReadedById(WorkflowHandleInfo workflowHandle, string connectionId = null)
{
int result = 0;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
string sql = $"UPDATE `{Table}` SET `{GetFieldByProp("IsReaded")}`=@IsReaded{GetModifyInfoSql(workflowHandle)} WHERE {GetFieldByProp("Id") }=@Id";
result = dbConn.Execute(sql, workflowHandle, GetDbTransaction(connId));
});
return(result);
}
/// <summary>
/// 根据工作流ID更新处理状态为已失效但排除ID
/// </summary>
/// <param name="workflowHandle">工作流处理</param>
/// <param name="connectionId">连接ID</param>
/// <returns>影响行数</returns>
public int UpdateEfficacyedNotIdByWorkflowId(WorkflowHandleInfo workflowHandle, string connectionId = null)
{
int result = 0;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
string sql = $"UPDATE `{Table}` SET `{GetFieldByProp("HandleStatus")}`={(byte)HandleStatusEnum.EFFICACYED},`{GetFieldByProp("HandleTime")}`=@HandleTime" +
$"{GetModifyInfoSql(workflowHandle)} WHERE {GetFieldByProp("Id") }!=@Id AND {GetFieldByProp("WorkflowId") }=@WorkflowId AND {GetFieldByProp("HandleStatus") }={(byte)HandleStatusEnum.UN_HANDLE} AND {GetFieldByProp("HandleType")}={(byte)HandleTypeEnum.AUDIT}";
result = dbConn.Execute(sql, workflowHandle, GetDbTransaction(connId));
});
return(result);
}
/// <summary>
/// 根据ID更新处理状态
/// </summary>
/// <param name="workflowHandle">工作流处理</param>
/// <param name="connectionId">连接ID</param>
/// <returns>影响行数</returns>
public int UpdateHandleStatusById(WorkflowHandleInfo workflowHandle, string connectionId = null)
{
int result = 0;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
string sql = $"UPDATE `{Table}` SET `{GetFieldByProp("HandleStatus")}`=@HandleStatus,`{GetFieldByProp("HandleTime")}`=@HandleTime,`{GetFieldByProp("Idea")}`=@Idea" +
$"{GetModifyInfoSql(workflowHandle)} WHERE {GetFieldByProp("Id") }=@Id";
Log.TraceAsync(sql, source: this.GetType().Name, tags: "UpdateHandleStatusById");
result = dbConn.Execute(sql, workflowHandle, GetDbTransaction(connId));
});
return(result);
}
/// <summary>
/// 根据工作流ID、流程关卡ID和处理人ID查询工作流处理信息
/// </summary>
/// <param name="workflowId">工作流ID</param>
/// <param name="flowCensorshipId">流程关卡ID</param>
/// <param name="handleId">处理人ID</param>
/// <param name="connectionId">连接ID</param>
/// <returns>工作流处理信息</returns>
public WorkflowHandleInfo SelectByWorkflowIdAndFlowCensorshipIdAndHandlerId(int workflowId, int flowCensorshipId, int handleId, string connectionId = null)
{
WorkflowHandleInfo result = null;
DynamicParameters parameters = new DynamicParameters();
parameters.Add("WorkflowId", workflowId);
parameters.Add("FlowCensorshipId", flowCensorshipId);
parameters.Add("HandlerId", handleId);
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
string sql = $"{SelectSql()} WHERE {GetFieldByProp("WorkflowId")}=@WorkflowId AND {GetFieldByProp("FlowCensorshipId")}=@FlowCensorshipId AND {GetFieldByProp("HandlerId")}=@HandlerId";
result = dbConn.QueryFirstOrDefault <WorkflowHandleInfo>(sql, parameters, GetDbTransaction(connId));
}, AccessMode.SLAVE);
return(result);
}
/// <summary>
/// 判断当前用户能否审核
/// </summary>
/// <param name="workflowHandle">工作流处理</param>
/// <param name="currUser">当前用户</param>
/// <returns>当前用户能否审核</returns>
public static BasicReturnInfo CanCurrUserAudit(WorkflowHandleInfo workflowHandle, BasicUserInfo currUser = null)
{
BasicReturnInfo returnInfo = new BasicReturnInfo();
var user = UserTool.GetCurrUser(currUser);
if (user == null)
{
returnInfo.SetFailureMsg("您还未登录，请先登录系统");
return(returnInfo);
}
if (workflowHandle == null)
{
returnInfo.SetFailureMsg("找不到处理信息");
return(returnInfo);
}
if (workflowHandle.HandlerId != user.Id)
{
returnInfo.SetFailureMsg("Sorry,您不是此流程的处理者,无权限审核");
return(returnInfo);
}
if (workflowHandle.HandleStatus == HandleStatusEnum.EFFICACYED)
{
returnInfo.SetFailureMsg("Sorry,您的处理信息已无效");
return(returnInfo);
}
if (workflowHandle.HandleStatus == HandleStatusEnum.SENDED || workflowHandle.HandleStatus == HandleStatusEnum.RETURNED)
{
returnInfo.SetFailureMsg("Sorry,您的处理信息已处理，无需重复处理");
return(returnInfo);
}
return(returnInfo);
}
/// <summary>
/// 执行获取到用户数组
/// 且构造处理者
/// </summary>
/// <param name="returnInfo">返回信息</param>
/// <param name="findFlowCensorshipIn">查找流程关卡输入</param>
/// <param name="flowCensorship">流程关卡</param>
/// <param name="concreteCensorships">具体关卡列表</param>
/// <param name="funcToUsers">回调获取到用户数组</param>
/// <param name="currUser">当前用户</param>
private void ExecGetToUsers(ReturnInfo <FlowCensorshipOutInfo> returnInfo,
FlowCensorshipInInfo findFlowCensorshipIn,
FlowCensorshipInfo flowCensorship,
IList <ConcreteCensorshipInfo> concreteCensorships,
Func <ReturnInfo <FindHandlerUserOutInfo> > funcToUsers,
BasicUserInfo currUser = null)
{
ReturnInfo <FindHandlerUserOutInfo> reUsers = funcToUsers();
if (reUsers.Failure())
{
returnInfo.FromBasic(reUsers);
return;
}
if (reUsers.Data == null || reUsers.Data.Users.IsNullOrLength0())
{
return;
}
IList <WorkflowHandleInfo> workflowHandles = new List <WorkflowHandleInfo>(reUsers.Data.Users.Length);
foreach (var u in reUsers.Data.Users)
{
bool isExists = false;
// 查找是否已经存在处理者
foreach (var fc in concreteCensorships)
{
if (fc.WorkflowHandles.IsNullOrLength0())
{
continue;
}
foreach (var h in fc.WorkflowHandles)
{
if (h.HandlerId == u.Id)
{
isExists = true;
break;
}
}
if (isExists)
{
break;
}
}
if (isExists)
{
continue;
}
// 构造处理者数组
WorkflowHandleInfo wh = new WorkflowHandleInfo()
{
ConcreteConcrete = reUsers.Data.ConcreteCensorship.Name,
ConcreteConcreteId = reUsers.Data.ConcreteCensorship.Id,
FlowCensorshipId = flowCensorship.Id,
Handler = u.Name,
HandlerId = u.Id,
HandleType = HandleTypeEnum.AUDIT,
HandleStatus = HandleStatusEnum.UN_HANDLE,
};
if (findFlowCensorshipIn.Workflow != null)
{
wh.WorkflowId = findFlowCensorshipIn.Workflow.Id;
}
wh.SetCreateInfo(currUser);
workflowHandles.Add(wh);
}
if (workflowHandles.Count == 0)
{
return;
}
concreteCensorships.Add(new ConcreteCensorshipInfo()
{
Id = reUsers.Data.ConcreteCensorship.Id,
Code = reUsers.Data.ConcreteCensorship.Code,
Name = reUsers.Data.ConcreteCensorship.Name,
WorkflowHandles = workflowHandles.ToArray(),
FlowCensorship = flowCensorship
});
}
/// <summary>
/// 审核处理
/// </summary>
/// <param name="returnInfo">返回信息</param>
/// <param name="findFlowCensorshipIn">查找流程关卡输入</param>
/// <param name="connectionId">连接ID</param>
/// <param name="currUser">当前用户</param>
private void AuditHandle(ReturnInfo <FlowCensorshipOutInfo> returnInfo, FlowCensorshipInInfo findFlowCensorshipIn, string connectionId = null, BasicUserInfo currUser = null)
{
if (findFlowCensorshipIn.CurrWorkflowHandle == null)
{
returnInfo.SetFailureMsg("当前工作流处理不能为null");
return;
}
if (findFlowCensorshipIn.ActionType == ActionType.SAVE)
{
returnInfo.SetFailureMsg("审核阶段不能保存");
return;
}
returnInfo.Data.Workflow = findFlowCensorshipIn.Workflow;
FlowCensorshipInfo currFlowCens = FindFlowCensorshipByFlowCensorshipId(findFlowCensorshipIn, findFlowCensorshipIn.CurrWorkflowHandle.FlowCensorshipId);
if (currFlowCens == null)
{
returnInfo.SetFailureMsg("找不到当前处理的流程关卡");
return;
}
findFlowCensorshipIn.CurrWorkflowHandle.HandleTime = DateTime.Now;
returnInfo.Data.CurrConcreteCensorship = new ConcreteCensorshipInfo()
{
Id = findFlowCensorshipIn.CurrWorkflowHandle.ConcreteConcreteId,
Name = findFlowCensorshipIn.CurrWorkflowHandle.ConcreteConcrete,
WorkflowHandles = new WorkflowHandleInfo[] { findFlowCensorshipIn.CurrWorkflowHandle },
FlowCensorship = currFlowCens
};
string idea = findFlowCensorshipIn.Idea;
if (findFlowCensorshipIn.ActionType == ActionType.SEND)
{
if (string.IsNullOrWhiteSpace(idea))
{
idea = "送件";
}
findFlowCensorshipIn.CurrWorkflowHandle.Idea = idea;
findFlowCensorshipIn.CurrWorkflowHandle.HandleStatus = HandleStatusEnum.SENDED;
// 查找是否存在其他并行流程关卡未处理状态，如果有则只更新本次处理为已处理状态，不往下一关卡发送
int existsOtherUnHandleCount = WorkflowHandlePersistence.CountNotFlowCensorshipIdByWorkflowIdAndHandleStatus(findFlowCensorshipIn.Workflow.Id,
HandleStatusEnum.UN_HANDLE, findFlowCensorshipIn.CurrWorkflowHandle.FlowCensorshipId, connectionId);
if (existsOtherUnHandleCount > 0)
{
return;
}
// 查找下一个送件流程关卡
FlowCensorshipInfo[] nextSendFlowCensorships = FindSendNextFlowCensorships(returnInfo, findFlowCensorshipIn, findFlowCensorshipIn.CurrWorkflowHandle.FlowCensorshipId);
if (nextSendFlowCensorships.IsNullOrLength0())
{
returnInfo.SetFailureMsg("找不到下一个处理流程关卡");
return;
}
// 结束的标准关卡
StandardCensorshipInfo endStand = FindStandardCensorshipByStandardCode(findFlowCensorshipIn, StandardCensorshipDefine.END);
if (endStand == null)
{
returnInfo.SetFailureMsg("找不到结束的标准关卡");
return;
}
// 如果下一个关卡为结束，则直接通知申请者
foreach (var f in nextSendFlowCensorships)
{
if (f.OwnerCensorshipType == CensorshipTypeEnum.STANDARD && f.OwnerCensorshipId == endStand.Id)
{
// 查找结束流程关卡ID
FlowCensorshipInfo applyFlowCensors = FindFlowCensorshipByStandardCode(findFlowCensorshipIn, StandardCensorshipDefine.END);
StandardCensorshipInfo applyStandCensors = FindStandardCensorshipByStandardCode(findFlowCensorshipIn, StandardCensorshipDefine.END);
ConcreteCensorshipInfo applyConsors = new ConcreteCensorshipInfo()
{
Id = applyFlowCensors.Id,
Code = applyStandCensors.Code,
Name = applyStandCensors.Name,
WorkflowHandles = new WorkflowHandleInfo[]
{
new WorkflowHandleInfo()
{
ConcreteConcrete = applyStandCensors.Name,
ConcreteConcreteId = applyStandCensors.Id,
FlowCensorshipId = applyFlowCensors.Id,
Handler = findFlowCensorshipIn.Workflow.Creater,
HandlerId = findFlowCensorshipIn.Workflow.CreaterId,
HandleStatus = HandleStatusEnum.UN_HANDLE,
HandleType = HandleTypeEnum.NOTIFY
}
},
FlowCensorship = applyFlowCensors
};
applyConsors.WorkflowHandles[0].SetCreateInfo(currUser);
returnInfo.Data.Workflow.FlowStatus = FlowStatusEnum.AUDIT_PASS;
returnInfo.Data.Workflow.SetModifyInfo(currUser);
ConcreteCensorshipInfo[] nextConcreteCens = new ConcreteCensorshipInfo[] { applyConsors };
UpdateCurrWorkflowHandleInfo(nextConcreteCens, returnInfo.Data.Workflow);
returnInfo.Data.NextConcreteCensorshipHandles = nextConcreteCens;
return;
}
}
// 查找具体的送件流程关卡
ConcreteCensorshipInfo[] concreteCensorships = FindMappingConcreteCensorships(returnInfo, findFlowCensorshipIn, nextSendFlowCensorships, connectionId, currUser);
if (returnInfo.Failure())
{
return;
}
UpdateCurrWorkflowHandleInfo(concreteCensorships, returnInfo.Data.Workflow);
returnInfo.Data.NextConcreteCensorshipHandles = concreteCensorships;
}
else
{
if (string.IsNullOrWhiteSpace(idea))
{
idea = "退件";
}
findFlowCensorshipIn.CurrWorkflowHandle.Idea = idea;
// 查找下一个退件流程关卡
FlowCensorshipInfo[] nextReturnFlowCensorships = FindReturnNextFlowCensorships(returnInfo, findFlowCensorshipIn, findFlowCensorshipIn.CurrWorkflowHandle.FlowCensorshipId);
if (nextReturnFlowCensorships.IsNullOrLength0())
{
returnInfo.SetFailureMsg("找不到下一个处理流程关卡");
return;
}
// 申请者的标准关卡
StandardCensorshipInfo applyStand = FindStandardCensorshipByStandardCode(findFlowCensorshipIn, StandardCensorshipDefine.APPLICANT);
if (applyStand == null)
{
returnInfo.SetFailureMsg("找不到申请者的标准关卡");
return;
}
findFlowCensorshipIn.CurrWorkflowHandle.HandleStatus = HandleStatusEnum.RETURNED;
// 如果下一个关卡为申请者，则直接通知申请者
foreach (var f in nextReturnFlowCensorships)
{
if (f.OwnerCensorshipType == CensorshipTypeEnum.STANDARD && applyStand.Id == f.OwnerCensorshipId)
{
// 查找申请者流程关卡ID
FlowCensorshipInfo applyFlowCensors = FindFlowCensorshipByStandardCode(findFlowCensorshipIn, StandardCensorshipDefine.APPLICANT);
StandardCensorshipInfo applyStandCensors = FindStandardCensorshipByStandardCode(findFlowCensorshipIn, StandardCensorshipDefine.APPLICANT);
ConcreteCensorshipInfo applyConsors = new ConcreteCensorshipInfo()
{
Id = applyFlowCensors.Id,
Code = applyStandCensors.Code,
Name = applyStandCensors.Name,
WorkflowHandles = new WorkflowHandleInfo[]
{
new WorkflowHandleInfo()
{
ConcreteConcrete = applyStandCensors.Name,
ConcreteConcreteId = applyStandCensors.Id,
FlowCensorshipId = applyFlowCensors.Id,
Handler = findFlowCensorshipIn.Workflow.Creater,
HandlerId = findFlowCensorshipIn.Workflow.CreaterId,
HandleStatus = HandleStatusEnum.UN_HANDLE,
HandleType = HandleTypeEnum.NOTIFY
}
},
FlowCensorship = applyFlowCensors
};
applyConsors.WorkflowHandles[0].SetCreateInfo(currUser);
returnInfo.Data.Workflow.FlowStatus = FlowStatusEnum.AUDIT_NOPASS;
returnInfo.Data.Workflow.SetModifyInfo(currUser);
var nextConcreteCens = new ConcreteCensorshipInfo[] { applyConsors };
UpdateCurrWorkflowHandleInfo(nextConcreteCens, returnInfo.Data.Workflow);
returnInfo.Data.NextConcreteCensorshipHandles = nextConcreteCens;
return;
}
}
int[] nextFlowCIds = new int[nextReturnFlowCensorships.Length];
for (var i = 0; i < nextFlowCIds.Length; i++)
{
nextFlowCIds[i] = nextReturnFlowCensorships[i].Id;
}
// 退件直接找从已处理列表中的各流程关卡的处理人
IList <WorkflowHandleInfo> returnWorkflowHandles = WorkflowHandlePersistence.SelectSendedByWorkflowIdAndFlowCensorshipIds(findFlowCensorshipIn.Workflow.Id, nextFlowCIds, connectionId);
if (returnWorkflowHandles.IsNullOrCount0())
{
returnInfo.SetFailureMsg("找不到可退件的人");
return;
}
List <ConcreteCensorshipInfo> conList = new List <ConcreteCensorshipInfo>();
// 具体ID映射工作流处理列表
IDictionary <int, IList <WorkflowHandleInfo> > dicConIdMapHandles = new Dictionary <int, IList <WorkflowHandleInfo> >();
// 处理人ID列表
IList <int> handleIds = new List <int>();
foreach (var w in returnWorkflowHandles)
{
// 过滤重复的处理人ID
if (handleIds.Contains(w.HandlerId))
{
continue;
}
handleIds.Add(w.HandlerId);
WorkflowHandleInfo newHandle = w.Clone() as WorkflowHandleInfo;
newHandle.HandleStatus = HandleStatusEnum.UN_HANDLE;
newHandle.HandleTime = null;
newHandle.Idea = null;
newHandle.IsReaded = false;
var c = conList.Find(x => x.Id == w.ConcreteConcreteId);
if (c == null)
{
c = new ConcreteCensorshipInfo()
{
Id = w.ConcreteConcreteId,
Name = w.ConcreteConcrete,
FlowCensorship = new FlowCensorshipInfo()
{
Id = w.FlowCensorshipId
}
};
dicConIdMapHandles.Add(c.Id, new List <WorkflowHandleInfo>()
{
newHandle
});
conList.Add(c);
}
else
{
dicConIdMapHandles[c.Id].Add(newHandle);
}
}
foreach (var c in conList)
{
foreach (KeyValuePair <int, IList <WorkflowHandleInfo> > item in dicConIdMapHandles)
{
if (c.Id == item.Key)
{
c.WorkflowHandles = item.Value.ToArray();
break;
}
}
}
ConcreteCensorshipInfo[] cons = conList.ToArray();
UpdateCurrWorkflowHandleInfo(cons, returnInfo.Data.Workflow);
returnInfo.Data.NextConcreteCensorshipHandles = cons;
}
}
/// <summary>
/// 执行核心
/// </summary>
/// <param name="returnInfo">返回信息</param>
/// <param name="flowIn">流程输入</param>
/// <param name="findFlowCensorshipOut">查找流程关卡输出</param>
/// <param name="connectionId">连接ID</param>
protected override void ExecCore(ReturnInfo <bool> returnInfo, FlowInInfo <FlowAuditInfo> flowIn,
FlowCensorshipOutInfo findFlowCensorshipOut, string connectionId = null)
{
// 更新工作流状态
WorkflowPersistence.UpdateFlowStatusAndCensorshipAndHandlerById(findFlowCensorshipOut.Workflow, connectionId);
// 更新当前工作流处理状态
WorkflowHandlePersistence.UpdateHandleStatusById(findFlowCensorshipOut.CurrConcreteCensorship.WorkflowHandles[0], connectionId);
string actionStr = flowIn.Flow.ActionType == ActionType.SEND ? "送件" : "退件";
if (findFlowCensorshipOut.NextConcreteCensorshipHandles.IsNullOrLength0())
{
returnInfo.SetSuccessMsg($"申请单号[{findFlowCensorshipOut.Workflow.ApplyNo}]已{actionStr}，等待其他人处理");
return;
}
else
{
WorkflowHandleInfo updateEf = new WorkflowHandleInfo()
{
Id = flowIn.Flow.HandleId,
FlowCensorshipId = flowIn.Flow.WorkflowHandle.FlowCensorshipId,
ConcreteConcreteId = flowIn.Flow.WorkflowHandle.ConcreteConcreteId,
WorkflowId = flowIn.Flow.WorkflowHandle.WorkflowId
};
updateEf.SetModifyInfo();
if (flowIn.Flow.ActionType == ActionType.SEND)
{
WorkflowHandlePersistence.UpdateEfficacyedNotIdByWorkflowIdAndFlowCensorshipId(updateEf, connectionId);
}
else
{
WorkflowHandlePersistence.UpdateEfficacyedNotIdByWorkflowId(updateEf, connectionId);
}
// 插入下一个处理者
IList <WorkflowHandleInfo> handlers = new List <WorkflowHandleInfo>();
foreach (var c in findFlowCensorshipOut.NextConcreteCensorshipHandles)
{
foreach (var h in c.WorkflowHandles)
{
h.WorkflowId = findFlowCensorshipOut.Workflow.Id;
handlers.Add(h);
}
}
ReturnInfo <bool> reHandle = WorkflowHandle.Add(handlers, connectionId);
if (reHandle.Failure())
{
returnInfo.FromBasic(reHandle);
return;
}
}
StringBuilder msg = new StringBuilder($"申请单号[{findFlowCensorshipOut.Workflow.ApplyNo}]");
if (findFlowCensorshipOut.ActionType == ActionType.SEND)
{
msg.AppendFormat("已送到[{0}]", findFlowCensorshipOut.Workflow.CurrHandlers);
if (findFlowCensorshipOut.IsNextEndCensorship())
{
msg.Append(",审核通过,流程结束");
}
else
{
msg.Append("审核");
}
}
else
{
msg.AppendFormat("已退给[{0}]", findFlowCensorshipOut.Workflow.CurrHandlers);
if (findFlowCensorshipOut.IsNextApplicantCensorship())
{
msg.Append(",审核驳回,流程结束");
}
else
{
msg.Append("审核");
}
}
returnInfo.SetMsg(msg.ToString());
}
