public virtual ReturnInfo <bool> Upload(IList <AttachmentInfo> attachments, IList <Stream> streams)
{
ReturnInfo <bool> re = new ReturnInfo <bool>();
AttachmentStreamInfo[] attachmentStreams = new AttachmentStreamInfo[attachments.Count];
for (var i = 0; i < attachments.Count; i++)
{
attachments[i].FileSize = Convert.ToSingle(streams[i].Length / 1024.00);
ValiFile(attachments[i], re);
if (re.Failure())
{
return(re);
}
attachmentStreams[i] = new AttachmentStreamInfo()
{
FileName = attachments[i].FileName,
Stream = streams[i]
};
}
ReturnInfo <IList <string> > returnInfo = AttachmentUploadStore.Upload(attachmentStreams);
if (returnInfo.Failure())
{
ReturnInfo <bool> result = new ReturnInfo <bool>();
result.FromBasic(returnInfo);
return(result);
}
for (var i = 0; i < returnInfo.Data.Count; i++)
{
attachments[i].FileAddress = returnInfo.Data[i];
attachments[i].ExpandName = attachments[i].FileName.FileExpandName();
}
return(Add(attachments));
}
public virtual ReturnInfo <bool> Upload([DisplayName2("附件"), Model] AttachmentInfo attachment, Stream stream, BasicUserInfo currUser = null)
{
AttachmentStreamInfo attachmentStream = new AttachmentStreamInfo()
{
FileName = attachment.FileName,
Stream = stream
};
ReturnInfo <IList <string> > returnInfo = AttachmentUploadStore.Upload(currUser, attachmentStream);
if (returnInfo.Failure())
{
ReturnInfo <bool> result = new ReturnInfo <bool>();
result.FromBasic(returnInfo);
return(result);
}
attachment.FileAddress = returnInfo.Data[0];
attachment.ExpandName = attachment.FileName.FileExpandName();
attachment.FileSize = Convert.ToSingle(stream.Length / 1024.00);
return(Add(attachment, currUser: currUser));
}
public virtual FileContentResult Export()
{
IDictionary <string, string> dicParams = Request.QueryString.Value.ToDictionaryFromUrlParams();
KeywordFilterInfo filter = dicParams.ToObject <KeywordFilterInfo, string>();
ReturnInfo <IList <RoleInfo> > returnInfo = Service.QueryByFilter(filter);
if (returnInfo.Failure())
{
return(File(new byte[] { 0 }, null));
}
Response.Headers.Add("Content-Disposition", "attachment;filename=" + WebUtility.UrlEncode("角色_" + DateTime.Now.ToFixedDate() + ".xlsx"));
try
{
return(File(returnInfo.Data.ToExcelBytes(), "application/vnd.ms-excel"));
}
catch (Exception ex)
{
Log.ErrorAsync("导出Excel发生异常", ex);
return(null);
}
}
/// <summary>
/// 根据ID查找工作流信息且包含处理列表和所有配置信息
/// </summary>
/// <param name="id">ID</param>
/// <param name="connectionId">连接ID</param>
/// <param name="currUser">当前用户</param>
/// <returns>返回信息</returns>
public virtual ReturnInfo <WorkflowInfo> FindContainHandlesAndAllConfigs([DisplayName2("ID"), Id] int id, string connectionId = null, BasicUserInfo currUser = null)
{
return(ExecReturnFuncAndConnectionId <WorkflowInfo>((reInfo, connId) =>
{
WorkflowInfo workflow = Persistence.SelectContainHandles(id, connId);
if (workflow == null)
{
reInfo.SetFailureMsg("找不到此工作流信息");
return null;
}
if (workflow.Handles.IsNullOrCount0())
{
reInfo.SetFailureMsg("找不到此工作流处理信息");
return null;
}
ReturnInfo <WorkflowDefineInfo> reDefine = WorkflowConfigReader.ReaderAllConfig(workflow.WorkflowDefineId, connId, currUser);
if (reDefine.Failure())
{
reInfo.FromBasic(reDefine);
return null;
}
if (reDefine.Data == null)
{
reInfo.SetFailureMsg("找不到此工作流定义信息");
return null;
}
workflow.WorkflowDefine = reDefine.Data;
return workflow;
}, null, connectionId, AccessMode.SLAVE));
}
public virtual FileContentResult Export()
{
var comData = HttpContext.CreateCommonUseData(ComUseDataFactory, menuCode: MenuCode(), functionCodes: FunCodeDefine.EXPORT_EXCEL_CODE);
IDictionary <string, string> dicParams = Request.QueryString.Value.ToDictionaryFromUrlParams();
UserFilterInfo filter = dicParams.ToObject <UserFilterInfo, string>();
ReturnInfo <IList <UserInfo> > returnInfo = Service.QueryByFilter(filter, comData);
if (returnInfo.Failure())
{
return(File(new byte[] { 0 }, null));
}
Response.Headers.Add("Content-Disposition", "attachment;filename=" + WebUtility.UrlEncode("用户_" + DateTime.Now.ToFixedDate() + ".xlsx"));
try
{
return(File(returnInfo.Data.ToExcelBytes(), "application/vnd.ms-excel"));
}
catch (Exception ex)
{
Log.ErrorAsync("导出Excel发生异常", ex);
return(null);
}
}
/// <summary>
/// 请求IdentityServer
/// </summary>
/// <param name="httpClient">http客户端</param>
/// <param name="clientId">客户端ID</param>
/// <param name="successCallback">请求成功后回调</param>
/// <returns>返回令牌</returns>
private async Task <ReturnInfo <IdentityModel.Client.TokenResponse> > RequestIdentityServer(HttpClient httpClient, string clientId, Action <ReturnInfo <IdentityModel.Client.TokenResponse>, ClientInfo, DiscoveryDocumentResponse> successCallback)
{
var re = new ReturnInfo <IdentityModel.Client.TokenResponse>();
string identityServerUrl;
var clientInfo = GetValiParam(re, clientId, out identityServerUrl);
if (re.Failure())
{
return(re);
}
var disco = await httpClient.GetDiscoveryDocumentAsync(identityServerUrl);
if (disco.IsError)
{
re.SetFailureMsg(disco.Error);
return(re);
}
successCallback(re, clientInfo, disco);
return(re);
}
/// <summary>
/// 执行
/// </summary>
/// <param name="flowIn">流程输入</param>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
/// <returns>返回信息</returns>
public virtual ReturnInfo <bool> Execute(FlowInT flowIn, CommonUseData comData = null, string connectionId = null)
{
return(ExecReturnFuncAndConnectionId <bool>((reInfo, connId) =>
{
WorkflowInfo workflow;
WorkflowDefineInfo workflowDefine = ValiFlowIn(reInfo, flowIn, out workflow, connectionId: connId, comData: comData);
if (reInfo.Failure())
{
return false;
}
FlowCensorshipInInfo findFlowCensorshipIn = new FlowCensorshipInInfo()
{
WorkflowDefine = workflowDefine,
Workflow = workflow
};
AppendSetFindFlowCensorshipIn(flowIn, findFlowCensorshipIn);
ReturnInfo <FlowCensorshipOutInfo> reOut = FindFlowCensorship.NextHandler(findFlowCensorshipIn, connectionId: connId, comData: comData);
if (reOut.Failure())
{
reInfo.FromBasic(reOut);
return false;
}
ReturnInfo <bool> reTrans = ExecTransaction(reInfo, workflowDefine, flowIn, reOut.Data, connectionId: connId, comData: comData);
reInfo.FromBasic(reTrans);
if (reTrans.Failure())
{
return false;
}
return true;
}));
}
public virtual ReturnInfo <FindHandlerUserOutInfo> FindById([DisplayName2("ID"), Id] int id, int userId, string connectionId = null)
{
ReturnInfo <FindHandlerUserOutInfo> returnInfo = new ReturnInfo <FindHandlerUserOutInfo>();
ReturnInfo <UserInfo> reUser = UserService.Find(id, connectionId);
if (reUser.Failure())
{
returnInfo.FromBasic(reUser);
return(returnInfo);
}
if (reUser.Data == null || reUser.Data.SystemHide || !reUser.Data.Enabled)
{
return(returnInfo);
}
returnInfo.Data = new FindHandlerUserOutInfo()
{
ConcreteCensorship = reUser.Data,
Users = new UserInfo[] { reUser.Data }
};
return(returnInfo);
}
public virtual ReturnInfo <UserMenuInfo> CanAccessMenus([DisplayName2("用户ID"), Id] int userId, string connectionId = null)
{
return(ExecReturnFuncAndConnectionId <UserMenuInfo>((reInfo, connId) =>
{
ReturnInfo <UserInfo> protoReturnInfo = Find(userId, connId);
if (protoReturnInfo.Failure())
{
reInfo.FromBasic(protoReturnInfo);
return null;
}
if (protoReturnInfo.Data == null)
{
reInfo.SetFailureMsg("找不到该用户");
return null;
}
protoReturnInfo.Data.Password = null;
// 查找该用户所属角色
ReturnInfo <IList <RoleInfo> > reRoleInfo = UserRoleService.OwnRolesByUserId(userId, connId);
if (reRoleInfo.Failure())
{
reInfo.FromBasic(reRoleInfo);
return null;
}
protoReturnInfo.Data.OwnRoles = reRoleInfo.Data;
var result = Mapper.Map <UserInfo, UserMenuInfo>(protoReturnInfo.Data);
// 查找能拥有的权限菜单
IList <MenuInfo> menus = null;
if ("Role".Equals(AppConfig["User:PermissionBenchmark"]))
{
if (!reRoleInfo.Data.IsNullOrCount0())
{
int[] roleIds = new int[reRoleInfo.Data.Count];
for (var i = 0; i < roleIds.Length; i++)
{
roleIds[i] = reRoleInfo.Data[i].Id;
}
menus = MenuPersistence.SelectByRoleIds(roleIds, connId);
}
}
else
{
menus = MenuPersistence.SelectByUserId(userId, connId);
}
if (menus.IsNullOrCount0())
{
return result;
}
// 如果没有查询权限则需要移除
IList <MenuInfo> tempMenus = new List <MenuInfo>();
foreach (MenuInfo m in menus)
{
if (m.Functions.IsNullOrCount0())
{
continue;
}
foreach (FunctionInfo funInfo in m.Functions)
{
if (FunCodeDefine.QUERY_CODE.Equals(funInfo.Code))
{
tempMenus.Add(m);
break;
}
}
}
result.Menus = tempMenus.ToOrigAndSort();
return result;
}, connectionId: connectionId, accessMode: AccessMode.SLAVE));
}
/// <summary>
/// 读取其他配置
/// </summary>
/// <param name="workflowDefine">工作流定义</param>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
private BasicReturnInfo ReaderOtherConfig(WorkflowDefineInfo workflowDefine, string connectionId, CommonUseData comData = null)
{
BasicReturnInfo basicReturn = new BasicReturnInfo();
if (workflowDefine == null)
{
basicReturn.SetFailureMsg("找不到工作流定义信息");
return(basicReturn);
}
#region 查找流程/表单/流程关卡
ReturnInfo <FlowInfo> reFlow = FlowService.Find(workflowDefine.FlowId, connectionId: connectionId, comData: comData);
if (reFlow.Failure())
{
basicReturn.FromBasic(reFlow);
return(basicReturn);
}
if (reFlow.Data == null)
{
basicReturn.SetFailureMsg("找不到工作流的流程信息");
return(basicReturn);
}
ReturnInfo <FormInfo> reForm = FormService.Find(workflowDefine.FormId, connectionId: connectionId, comData: comData);
workflowDefine.Flow = reFlow.Data;
if (reForm.Failure())
{
basicReturn.FromBasic(reForm);
return(basicReturn);
}
if (reForm.Data == null)
{
basicReturn.SetFailureMsg("找不到工作流的表单信息");
return(basicReturn);
}
workflowDefine.Form = reForm.Data;
ReturnInfo <IList <FlowCensorshipInfo> > reFlowCensorships = FlowCensorshipService.QueryByFlowId(workflowDefine.FlowId, connectionId: connectionId, comData: comData);
if (reFlowCensorships.Failure())
{
basicReturn.FromBasic(reFlowCensorships);
return(basicReturn);
}
if (reFlowCensorships.Data.IsNullOrCount0())
{
basicReturn.SetFailureMsg("找不到工作流的流程关卡信息");
return(basicReturn);
}
workflowDefine.Flow.FlowCensorships = reFlowCensorships.Data.ToArray();
// 构造流程关卡ID数组
int[] flowCensorshipIds = new int[workflowDefine.Flow.FlowCensorships.Length];
IList <int> stFlowCensorshipIds = new List <int>();
for (var i = 0; i < flowCensorshipIds.Length; i++)
{
var f = workflowDefine.Flow.FlowCensorships[i];
flowCensorshipIds[i] = f.Id;
if (f.OwnerCensorshipType == CensorshipTypeEnum.STANDARD)
{
stFlowCensorshipIds.Add(f.OwnerCensorshipId);
}
}
#endregion
#region 查找送件/退件路线/标准关卡
IList <StandardCensorshipInfo> standardCensorships = null;
// 标准关卡
if (!stFlowCensorshipIds.IsNullOrCount0())
{
ReturnInfo <IList <StandardCensorshipInfo> > reStand = StandardCensorshipService.Find(stFlowCensorshipIds.ToArray(), connectionId: connectionId, comData: comData);
if (reStand.Failure())
{
basicReturn.FromBasic(reStand);
return(basicReturn);
}
if (reStand.Data.IsNullOrCount0())
{
basicReturn.SetFailureMsg("找不到标准关卡信息");
return(basicReturn);
}
standardCensorships = reStand.Data;
}
ReturnInfo <IList <SendFlowRouteInfo> > reSend = SendFlowRouteService.QueryByFlowCensorshipIds(flowCensorshipIds, connectionId: connectionId, comData: comData);
if (reSend.Failure())
{
basicReturn.FromBasic(reSend);
return(basicReturn);
}
if (reSend.Data.IsNullOrCount0())
{
basicReturn.SetFailureMsg("找不到工作流的送件路线信息");
}
ReturnInfo <IList <ReturnFlowRouteInfo> > reReturn = ReturnFlowRouteService.QueryByFlowCensorshipIds(flowCensorshipIds, connectionId: connectionId, comData: comData);
if (reReturn.Failure())
{
basicReturn.FromBasic(reReturn);
return(basicReturn);
}
foreach (var f in workflowDefine.Flow.FlowCensorships)
{
switch (f.OwnerCensorshipType)
{
case CensorshipTypeEnum.STANDARD:
IList <StandardCensorshipInfo> stdList = new List <StandardCensorshipInfo>();
foreach (var s in standardCensorships)
{
if (f.OwnerCensorshipId == s.Id)
{
stdList.Add(s);
}
}
if (stdList.Count == 0)
{
basicReturn.SetFailureMsg($"找不到归属ID为{f.OwnerCensorshipId}的标准关卡信息");
return(basicReturn);
}
f.StandardCensorships = stdList.ToArray();
break;
}
IList <SendFlowRouteInfo> sendRotes = new List <SendFlowRouteInfo>();
foreach (var send in reSend.Data)
{
if (f.Id == send.FlowCensorshipId)
{
sendRotes.Add(send);
}
}
if (!sendRotes.IsNullOrCount0())
{
f.SendFlowRoutes = sendRotes.ToArray();
}
if (!reReturn.Data.IsNullOrCount0())
{
IList <ReturnFlowRouteInfo> returnRotes = new List <ReturnFlowRouteInfo>();
foreach (var re in reReturn.Data)
{
if (f.Id == re.FlowCensorshipId)
{
returnRotes.Add(re);
}
}
if (!returnRotes.IsNullOrCount0())
{
f.ReturnFlowRoutes = returnRotes.ToArray();
}
}
}
#endregion
return(basicReturn);
}
/// <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="flowCensorships">流程关卡数组</param>
/// <param name="connectionId">连接ID</param>
/// <param name="currUser">当前用户</param>
/// <returns>具体关卡数组</returns>
private ConcreteCensorshipInfo[] FindMappingConcreteCensorships(ReturnInfo <FlowCensorshipOutInfo> returnInfo, FlowCensorshipInInfo findFlowCensorshipIn, FlowCensorshipInfo[] flowCensorships, string connectionId = null, BasicUserInfo currUser = null)
{
IList <ConcreteCensorshipInfo> concreteCensorships = new List <ConcreteCensorshipInfo>();
var user = UserTool.GetCurrUser(currUser);
ExecProcConnectionId(connId =>
{
foreach (var f in flowCensorships)
{
switch (f.OwnerCensorshipType)
{
case CensorshipTypeEnum.ROLE:
ExecGetToUsers(returnInfo, findFlowCensorshipIn, f, concreteCensorships,
() =>
{
return(FindHandlerRoleUser.FindById(f.OwnerCensorshipId, user.Id, connId, currUser));
}, currUser);
if (returnInfo.Failure())
{
return;
}
break;
case CensorshipTypeEnum.USER:
ExecGetToUsers(returnInfo, findFlowCensorshipIn, f, concreteCensorships,
() =>
{
return(FindHandlerConcreteUser.FindById(f.OwnerCensorshipId, user.Id, connId, currUser));
}, currUser);
if (returnInfo.Failure())
{
return;
}
break;
case CensorshipTypeEnum.STANDARD:
StandardCensorshipInfo standardCensorship = FindStandardCensorshipByStandardId(findFlowCensorshipIn, f.OwnerCensorshipId);
if (standardCensorship != null)
{
if (standardCensorship.Code == StandardCensorshipDefine.SUPERVISOR)
{
ExecGetToUsers(returnInfo, findFlowCensorshipIn, f, concreteCensorships,
() =>
{
return(FindHandlerSupervisorUser.FindById(f.OwnerCensorshipId, user.Id, connId, currUser));
}, currUser);
if (returnInfo.Failure())
{
return;
}
}
}
break;
}
}
}, connectionId, AccessMode.SLAVE);
if (returnInfo.Failure())
{
return(null);
}
if (concreteCensorships.Count == 0)
{
returnInfo.SetFailureMsg("找不到下一个处理者");
return(null);
}
return(concreteCensorships.ToArray());
}
/// <summary>
/// 执行流程后
/// </summary>
/// <param name="flowCensorshipOut">流程关卡输出</param>
/// <param name="flowIn">流程输入</param>
/// <param name="isSuccess">是否成功</param>
/// <param name="connectionId">连接ID</param>
/// <param name="currUser">当前用户</param>
/// <returns>返回信息</returns>
public override ReturnInfo <bool> AfterExecFlow(FlowCensorshipOutInfo flowCensorshipOut, object flowIn, bool isSuccess, string connectionId = null, BasicUserInfo currUser = null)
{
ReturnInfo <bool> returnInfo = new ReturnInfo <bool>();
if (isSuccess)
{
// 当前为申请者关卡
if (flowCensorshipOut.IsCurrApplicantCensorship() &&
(flowCensorshipOut.ActionType == ActionType.SAVE || flowCensorshipOut.ActionType == ActionType.SEND))
{
FlowInInfo <FlowInitInfo <PersonTimeInfo> > conFlowIn;
ConcreteFormInfoT form = ToApplyConcreteFormInfo(flowCensorshipOut, flowIn, returnInfo, out conFlowIn);
if (returnInfo.Failure())
{
return(returnInfo);
}
ReturnInfo <ConcreteFormInfo> reFormInfo = FormDataReaderFactory.Create(conFlowIn.Flow.WorkflowCode).ReaderByWorkflowId(flowCensorshipOut.Workflow.Id, connectionId, currUser);
if (reFormInfo.Failure())
{
returnInfo.FromBasic(reFormInfo);
return(returnInfo);
}
if (reFormInfo.Data != null)
{
switch (reFormInfo.Data.FlowStatus)
{
case FlowStatusEnum.AUDITING:
returnInfo.SetFailureMsg("此表单在审核中不允许重复申请");
return(returnInfo);
case FlowStatusEnum.AUDIT_PASS:
returnInfo.SetFailureMsg("此表单已审核通过不允许重复申请");
return(returnInfo);
case FlowStatusEnum.AUDIT_NOPASS:
returnInfo.SetFailureMsg("此表单已审核驳回不允许重复申请");
return(returnInfo);
}
form.SetModifyInfo(currUser);
}
else
{
form.SetCreateInfo(currUser);
}
form.ApplyNo = flowCensorshipOut.Workflow.ApplyNo;
form.WorkflowId = flowCensorshipOut.Workflow.Id;
form.FlowStatus = flowCensorshipOut.Workflow.FlowStatus;
returnInfo = FormService.Set(form, connectionId, currUser);
} // 下一关卡如果是结束关卡（送件）或是申请关卡（退件）
else if ((flowCensorshipOut.IsNextEndCensorship() && flowCensorshipOut.ActionType == ActionType.SEND) ||
(flowCensorshipOut.IsNextApplicantCensorship() && flowCensorshipOut.ActionType == ActionType.RETURN))
{
ConcreteFormInfoT form = typeof(ConcreteFormInfoT).CreateInstance <ConcreteFormInfoT>();
form.WorkflowId = flowCensorshipOut.Workflow.Id;
form.FlowStatus = flowCensorshipOut.Workflow.FlowStatus;
form.SetModifyInfo(currUser);
returnInfo = FormService.ModifyFlowStatusByWorkflowId(form, connectionId, currUser);
}
}
return(returnInfo);
}
/// <summary>
/// 申请者处理
/// </summary>
/// <param name="returnInfo">返回信息</param>
/// <param name="findFlowCensorshipIn">查找流程关卡输入</param>
/// <param name="connectionId">连接ID</param>
/// <param name="currUser">当前用户</param>
private void ApplyHandle(ReturnInfo <FlowCensorshipOutInfo> returnInfo, FlowCensorshipInInfo findFlowCensorshipIn, string connectionId = null, BasicUserInfo currUser = null)
{
if (findFlowCensorshipIn.ActionType == ActionType.RETURN)
{
returnInfo.SetFailureMsg("申请阶段必须不能退件");
return;
}
// 查找申请者流程关卡ID
StandardCensorshipInfo applyStand = FindStandardCensorshipByStandardCode(findFlowCensorshipIn, StandardCensorshipDefine.APPLICANT);
if (applyStand == null)
{
returnInfo.SetFailureMsg("找不到申请者的标准关卡");
return;
}
var user = UserTool.GetCurrUser(currUser);
if (returnInfo.Data.Workflow == null)
{
if (findFlowCensorshipIn.Workflow == null)
{
returnInfo.Data.Workflow = new WorkflowInfo()
{
ApplyNo = findFlowCensorshipIn.ApplyNo,
Title = findFlowCensorshipIn.Title,
WorkflowDefineId = findFlowCensorshipIn.WorkflowDefine.Id
};
returnInfo.Data.Workflow.SetCreateInfo(currUser);
}
else
{
returnInfo.Data.Workflow = findFlowCensorshipIn.Workflow;
returnInfo.Data.Workflow.SetModifyInfo(currUser);
}
}
else
{
returnInfo.Data.Workflow.SetModifyInfo(currUser);
}
returnInfo.Data.Workflow.FlowStatus = findFlowCensorshipIn.ActionType == ActionType.SEND ? FlowStatusEnum.AUDITING : FlowStatusEnum.DRAFT;
string idea = findFlowCensorshipIn.Idea;
returnInfo.Data.Workflow.Title = findFlowCensorshipIn.Title;
// 申请者需要构造一条申请处理的记录
FlowCensorshipInfo applyFlowCensors = FindFlowCensorshipByStandardCode(findFlowCensorshipIn, StandardCensorshipDefine.APPLICANT);
// 送件才需要找下一个处理
if (findFlowCensorshipIn.ActionType == ActionType.SEND)
{
FlowCensorshipInfo[] nextSendFlowCensorships = FindSendNextFlowCensorships(returnInfo, findFlowCensorshipIn, applyFlowCensors.Id);
if (nextSendFlowCensorships.IsNullOrLength0())
{
returnInfo.SetFailureMsg("找不到申请者的下一个处理流程关卡");
return;
}
ConcreteCensorshipInfo[] concreteCensorships = FindMappingConcreteCensorships(returnInfo, findFlowCensorshipIn, nextSendFlowCensorships, connectionId, currUser);
if (returnInfo.Failure())
{
return;
}
UpdateCurrWorkflowHandleInfo(concreteCensorships, returnInfo.Data.Workflow);
returnInfo.Data.NextConcreteCensorshipHandles = concreteCensorships;
if (string.IsNullOrWhiteSpace(idea))
{
idea = "提交申请";
}
}
else
{
returnInfo.Data.Workflow.CurrConcreteCensorshipIds = applyStand.Id.ToString();
returnInfo.Data.Workflow.CurrConcreteCensorships = applyStand.Name;
returnInfo.Data.Workflow.CurrFlowCensorshipIds = applyFlowCensors.Id.ToString();
returnInfo.Data.Workflow.CurrHandlerIds = user.Id.ToString();
returnInfo.Data.Workflow.CurrHandlers = user.Name;
if (string.IsNullOrWhiteSpace(idea))
{
idea = "保存草稿";
}
}
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 = user.Name,
HandlerId = user.Id,
HandleStatus = findFlowCensorshipIn.ActionType == ActionType.SEND ? HandleStatusEnum.SENDED : HandleStatusEnum.UN_HANDLE,
Idea = idea,
IsReaded = true,
HandleType = HandleTypeEnum.APPLY,
HandleTime = DateTime.Now
}
},
FlowCensorship = applyFlowCensors
};
if (findFlowCensorshipIn.ActionType == ActionType.SEND)
{
applyConsors.WorkflowHandles[0].HandleTime = DateTime.Now;
}
applyConsors.WorkflowHandles[0].SetCreateInfo(currUser);
returnInfo.Data.CurrConcreteCensorship = applyConsors;
}
/// <summary>
/// 验证流程输入
/// </summary>
/// <param name="returnInfo">返回信息</param>
/// <param name="flowIn">流程输入</param>
/// <param name="workflow">工作流</param>
/// <param name="connectionId">连接ID</param>
/// <returns>工作流定义</returns>
protected override WorkflowDefineInfo ValiFlowIn(ReturnInfo <bool> returnInfo, FlowInInfo <FlowAuditInfo> flowIn, out WorkflowInfo workflow, string connectionId = null)
{
workflow = null;
if (flowIn == null)
{
returnInfo.SetFailureMsg("流程输入不能为null");
return(null);
}
if (flowIn.Flow == null)
{
returnInfo.SetFailureMsg("流程不能为null");
return(null);
}
ReturnInfo <WorkflowHandleInfo> reHandle = WorkflowHandle.Find(flowIn.Flow.HandleId, connectionId);
if (reHandle.Failure())
{
returnInfo.FromBasic(reHandle);
return(null);
}
if (reHandle.Data == null)
{
returnInfo.SetFailureMsg("找不到工作流处理信息");
return(null);
}
if (reHandle.Data.HandlerId != UserTool.CurrUser.Id)
{
returnInfo.SetFailureMsg("此处理流程不属于您审核");
return(null);
}
if (reHandle.Data.HandleType == HandleTypeEnum.NOTIFY)
{
returnInfo.SetFailureMsg("您的处理流程是通知类型，不能审核");
return(null);
}
if (reHandle.Data.HandleStatus == HandleStatusEnum.SENDED || reHandle.Data.HandleStatus == HandleStatusEnum.RETURNED)
{
returnInfo.SetFailureMsg("您的处理流程是已审核过，不能重复审核");
return(null);
}
if (reHandle.Data.HandleStatus == HandleStatusEnum.EFFICACYED)
{
returnInfo.SetFailureMsg("您的处理流程已失效，不能审核");
return(null);
}
ReturnInfo <WorkflowInfo> reWorkflow = WorkflowService.Find(reHandle.Data.WorkflowId);
if (reWorkflow.Failure())
{
returnInfo.FromBasic(reWorkflow);
return(null);
}
if (reWorkflow.Data == null)
{
returnInfo.SetFailureMsg("找不到工作流信息");
return(null);
}
if (reWorkflow.Data.FlowStatus == FlowStatusEnum.DRAFT)
{
returnInfo.SetFailureMsg("此工作流是草稿状态不能审核");
return(null);
}
if (reWorkflow.Data.FlowStatus == FlowStatusEnum.AUDIT_NOPASS || reWorkflow.Data.FlowStatus == FlowStatusEnum.AUDIT_PASS)
{
returnInfo.SetFailureMsg("此工作流已审核结束");
return(null);
}
reHandle.Data.Workflow = reWorkflow.Data;
flowIn.Flow.WorkflowHandle = reHandle.Data;
ReturnInfo <WorkflowDefineInfo> reWorkFlowConfig = WorkflowConfigReader.ReaderAllConfig(reWorkflow.Data.WorkflowDefineId, connectionId);
if (reWorkFlowConfig.Failure())
{
returnInfo.FromBasic(reWorkFlowConfig);
return(null);
}
return(reWorkFlowConfig.Data);
}
/// <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());
}
/// <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>
/// <param name="currUser">当前用户</param>
protected override void ExecCore(ReturnInfo <bool> returnInfo, FlowInInfo <FlowInitInfo <PersonTimeInfo <int> > > flowIn,
FlowCensorshipOutInfo findFlowCensorshipOut, string connectionId = null, BasicUserInfo <int> currUser = null)
{
// 操作工作流
ReturnInfo <bool> reWorkflow = WorkflowService.Set(findFlowCensorshipOut.Workflow, connectionId, currUser);
if (reWorkflow.Failure())
{
returnInfo.FromBasic(reWorkflow);
return;
}
if (flowIn.Flow.Id < 1)
{
flowIn.Flow.Id = findFlowCensorshipOut.Workflow.Id;
}
// 操作工作流处理
var currHandle = findFlowCensorshipOut.CurrConcreteCensorship.WorkflowHandles[0];
currHandle.WorkflowId = findFlowCensorshipOut.Workflow.Id;
var existsHandleReturnInfo = WorkflowHandle.FindByWorkflowIdAndFlowCensorshipIdAndHandlerId(currHandle.WorkflowId, currHandle.FlowCensorshipId, currHandle.HandlerId, connectionId, currUser);
if (existsHandleReturnInfo.Failure())
{
returnInfo.FromBasic(existsHandleReturnInfo);
return;
}
var user = UserTool <int> .GetCurrUser(currUser);
if (existsHandleReturnInfo.Data != null)
{
if (existsHandleReturnInfo.Data.HandlerId != user.Id)
{
returnInfo.SetFailureMsg($"Sorry，此流程不是您处理的，无权限操作");
return;
}
currHandle.Id = existsHandleReturnInfo.Data.Id;
currHandle.SetModifyInfo(currUser);
}
ReturnInfo <bool> reHandle = WorkflowHandle.Set(findFlowCensorshipOut.CurrConcreteCensorship.WorkflowHandles[0], connectionId, currUser);
if (reHandle.Failure())
{
returnInfo.FromBasic(reHandle);
return;
}
if (findFlowCensorshipOut.NextConcreteCensorshipHandles.IsNullOrLength0())
{
returnInfo.SetMsg($"申请单号[{findFlowCensorshipOut.Workflow.ApplyNo}]已保存为草稿");
return;
}
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);
}
}
reHandle = WorkflowHandle.Add(handlers, connectionId, currUser);
if (reHandle.Failure())
{
returnInfo.FromBasic(reHandle);
return;
}
returnInfo.SetMsg($"申请单号[{findFlowCensorshipOut.Workflow.ApplyNo}]已送到[{findFlowCensorshipOut.Workflow.CurrHandlers}]审核");
}
