/// <summary>
/// 主页
/// </summary>
/// <returns>动作结果</returns>
public ActionResult Index()
{
var comData = HttpContext.CreateCommonUseData(ComUseDataFactory, menuCode: "Home", functionCodes: "Query");
var user = UserTool <int> .GetCurrUser(comData);
return(View(UserMenuService.CanAccessMenus(user.Id, comData)));
}
public virtual ReturnInfo <bool> ModifyCurrUserPassword(CurrUserModifyPasswordInfo currUserModifyPassword)
{
var user = UserTool.GetCurrUser();
currUserModifyPassword.LoginId = user.LoginId;
return(Service.ModifyPasswordByLoginId(currUserModifyPassword));
}
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));
}
/// <summary>
/// 添加用户角色
/// </summary>
/// <param name="model">模型</param>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
/// <returns>影响行数</returns>
private int AddUserRoles(UserInfo model, CommonUseData comData = null, string connectionId = null)
{
if (model.OwnRoles.IsNullOrCount0())
{
return(0);
}
IList <UserRoleInfo> userRoles = new List <UserRoleInfo>(model.OwnRoles.Count);
foreach (RoleInfo r in model.OwnRoles)
{
UserRoleInfo ur = new UserRoleInfo()
{
UserId = model.Id,
RoleId = r.Id
};
ur.SetCreateInfo(UserTool <int> .GetCurrUser(comData));
userRoles.Add(ur);
}
if (userRoles.IsNullOrCount0())
{
return(0);
}
return(UserRolePersistence.Insert(userRoles, connectionId: connectionId, comData: comData));
}
/// <summary>
/// 执行流程后
/// </summary>
/// <param name="workflow">工作流</param>
/// <param name="removeType">移除类型</param>
/// <param name="isSuccess">是否成功</param>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
/// <returns>返回信息</returns>
public override ReturnInfo <bool> AfterExecFlow(WorkflowInfo workflow, RemoveType removeType, bool isSuccess, CommonUseData comData = null, string connectionId = null)
{
if (isSuccess)
{
var currUser = UserTool <int> .GetCurrUser(comData);
switch (removeType)
{
case RemoveType.REMOVE:
case RemoveType.FORCE_REMOVE:
return(FormService.RemoveByWorkflowId(workflow.Id, connectionId: connectionId, comData: comData));
case RemoveType.UNDO:
ConcreteFormInfoT form = typeof(ConcreteFormInfoT).CreateInstance <ConcreteFormInfoT>();
form.WorkflowId = workflow.Id;
form.FlowStatus = FlowStatusEnum.REVERSED;
form.SetModifyInfo(currUser);
return(FormService.ModifyFlowStatusByWorkflowId(form, connectionId: connectionId, comData: comData));
}
}
return(new ReturnInfo <bool>());
}
/// <summary>
/// 执行
/// </summary>
/// <typeparam name="FormT">表单类型</typeparam>
/// <param name="flowInit">流程初始</param>
/// <param name="workflowInit">工作流初始</param>
/// <param name="comData">通用数据</param>
/// <returns>返回信息</returns>
private ReturnInfo <WorkflowBasicInfo> Execute <FormT>(FlowInitInfo <FormT> flowInit, IWorkflowForm workflowInit, CommonUseData comData = null)
where FormT : PersonTimeInfo <int>
{
var returnInfo = new ReturnInfo <WorkflowBasicInfo>();
var currUser = UserTool <int> .GetCurrUser(comData);
if (string.IsNullOrWhiteSpace(flowInit.ApplyNo))
{
flowInit.ApplyNo = BuilderApplyNo(flowInit, returnInfo, comData);
if (returnInfo.Failure())
{
return(returnInfo);
}
}
var flowInfo = flowInit.ToFlowIn();
ReturnInfo <bool> reWorkflow = workflowInit.Execute(flowInfo, comData);
returnInfo.FromBasic(reWorkflow);
if (reWorkflow.Failure())
{
return(returnInfo);
}
returnInfo.Data = new WorkflowBasicInfo()
{
Id = flowInit.Id,
ApplyNo = flowInit.ApplyNo
};
return(returnInfo);
}
public virtual ReturnInfo <bool> ModifyCurrUserPassword(CurrUserModifyPasswordInfo currUserModifyPassword)
{
var comData = HttpContext.CreateCommonUseData(ComUseDataFactory, menuCode: MenuCode(), functionCodes: FunCodeDefine.RESET_PASSWORD_CODE);
var user = UserTool <int> .GetCurrUser(comData);
currUserModifyPassword.LoginId = user.LoginId;
return(Service.ModifyPasswordByLoginId(currUserModifyPassword, comData));
}
/// <summary>
/// 验证数据库参数
/// </summary>
/// <param name="returnInfo">返回信息</param>
/// <param name="flowIn">流程输入</param>
/// <param name="workflow">工作流</param>
/// <param name="connectionId">连接ID</param>
/// <param name="currUser">当前用户</param>
private void ValiDbParam(ReturnInfo <bool> returnInfo, FlowInInfo <FlowInitInfo <PersonTimeInfo <int> > > flowIn, out WorkflowInfo workflow, string connectionId = null, BasicUserInfo <int> currUser = null)
{
workflow = null;
ReturnInfo <WorkflowDefineInfo> reWorkFlowConfig = WorkflowConfigReader.ReaderAllConfig(flowIn.Flow.WorkflowCode, connectionId, currUser);
if (reWorkFlowConfig.Failure())
{
returnInfo.FromBasic(reWorkFlowConfig);
return;
}
var user = UserTool <int> .GetCurrUser(currUser);
if (flowIn.Flow.Id > 0)
{
var reInfo = WorkflowService.Find(flowIn.Flow.Id, connectionId, currUser);
if (reInfo.Failure())
{
returnInfo.FromBasic(reInfo);
return;
}
if (reInfo.Data == null)
{
returnInfo.SetFailureMsg($"找不到工作流ID[{flowIn.Flow.Id}]的数据");
return;
}
if (reInfo.Data.CreaterId != user.Id)
{
returnInfo.SetFailureMsg($"Sorry，此流程不是您创建的，无权限操作");
return;
}
workflow = reInfo.Data;
flowIn.Flow.Id = workflow.Id;
flowIn.Flow.ApplyNo = workflow.ApplyNo;
}
else
{
ReturnInfo <bool> reInfo = WorkflowService.ExistsByApplyNo(flowIn.Flow.ApplyNo, connectionId, currUser);
if (reInfo.Failure())
{
returnInfo.FromBasic(reInfo);
return;
}
if (reInfo.Data)
{
returnInfo.SetFailureMsg($"申请单号[{flowIn.Flow.ApplyNo}]已存在");
return;
}
}
}
/// <summary>
/// 验证
/// </summary>
/// <param name="returnInfo">返回信息</param>
/// <param name="workflow">工作流</param>
/// <param name="comData">通用数据</param>
protected override void Vali(ReturnInfo <bool> returnInfo, WorkflowInfo workflow, CommonUseData comData = null)
{
var user = UserTool <int> .GetCurrUser(comData);
if (workflow.CreaterId != user.Id)
{
returnInfo.SetFailureMsg("Sorry，您不是此流程的发起者，故不能撤消");
return;
}
switch (workflow.FlowStatus)
{
case FlowStatusEnum.DRAFT:
returnInfo.SetFailureMsg("Sorry，此流程是草稿状态不能撤消");
return;
case FlowStatusEnum.REVERSED:
returnInfo.SetFailureMsg("Sorry，此流程已经撤消，不能重复撤消");
return;
case FlowStatusEnum.AUDIT_PASS:
returnInfo.SetFailureMsg("Sorry，此流程已经审核通过，不能撤消");
return;
case FlowStatusEnum.AUDIT_NOPASS:
returnInfo.SetFailureMsg("Sorry，此流程已经审核不通过，不能撤消");
return;
case FlowStatusEnum.AUDITING:
// 只有所有审核者未读才允许撤消
foreach (var h in workflow.Handles)
{
// 本人处理忽略
if (h.HandlerId == user.Id)
{
continue;
}
if (h.IsReaded)
{
returnInfo.SetFailureMsg("Sorry，此流程已经被审核者读过，不能撤消");
return;
}
}
return;
default:
returnInfo.SetFailureMsg("Sorry，此流程未知状态，不能撤消");
return;
}
}
/// <summary>
/// 拦截
/// </summary>
/// <param name="basicReturn">基本返回</param>
/// <param name="invocation">拦截参数</param>
/// <param name="attr">特性</param>
/// <param name="isExecProceeded">是否已执行</param>
protected override void Intercept(BasicReturnInfo basicReturn, IInvocation invocation, AuthAttribute attr, out bool isExecProceeded)
{
isExecProceeded = false;
var currUser = attr.CurrUserParamIndex == -1 ? null : invocation.Arguments[attr.CurrUserParamIndex];
var user = UserTool.GetCurrUser(currUser as BasicUserInfo);
if (user == null)
{
basicReturn.SetCodeMsg(403, "您还未授权，无权限访问");
}
}
/// <summary>
/// 设置修改信息
/// </summary>
/// <param name="model">模型</param>
/// <param name="currUser">当前用户</param>
public static void SetModifyInfo(this PersonTimeInfo model, BasicUserInfo currUser = null)
{
var user = UserTool.GetCurrUser(currUser);
if (user == null)
{
return;
}
model.ModifierId = user.Id;
model.Modifier = user.Name;
model.ModifyTime = DateTime.Now;
}
/// <summary>
/// 设置创建信息
/// </summary>
/// <typeparam name="IdT">ID类型</typeparam>
/// <param name="model">模型</param>
/// <param name="currUser">当前用户</param>
public static void SetCreateInfo <IdT>(this PersonTimeInfo <IdT> model, BasicUserInfo <IdT> currUser = null)
{
var user = UserTool <IdT> .GetCurrUser(currUser);
if (user == null)
{
return;
}
model.CreaterId = model.ModifierId = user.Id;
model.Creater = model.Modifier = user.Name;
model.CreateTime = model.ModifyTime = DateTime.Now;
}
/// <summary>
/// 查询当前用户的待办的工作流列表并分页
/// </summary>
/// <param name="pageIndex">页码</param>
/// <param name="pageSize">每页记录数</param>
/// <param name="filter">筛选</param>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
/// <returns>返回信息</returns>
public virtual ReturnInfo <PagingInfo <WorkflowInfo> > QueryCurrUserWaitHandlePage(int pageIndex, int pageSize, WaitHandleFilterInfo filter, CommonUseData comData = null, string connectionId = null)
{
if (filter == null)
{
filter = new WaitHandleFilterInfo();
}
var user = UserTool <int> .GetCurrUser(comData);
filter.HandlerId = user.Id;
filter.EndCreateTime = filter.EndCreateTime.AddThisDayLastTime();
return(ExecReturnFuncAndConnectionId <PagingInfo <WorkflowInfo> >((reInfo, connId) =>
{
return Persistence.SelectWaitHandlePage(pageIndex, pageSize, filter, connId);
}, null, connectionId, AccessMode.SLAVE));
}
public virtual ReturnInfo <PagingInfo <WorkflowInfo> > QueryCurrUserAuditedFlowPage(int pageIndex, int pageSize, AuditFlowFilterInfo filter, string connectionId = null, BasicUserInfo currUser = null)
{
if (filter == null)
{
filter = new AuditFlowFilterInfo();
}
var user = UserTool.GetCurrUser(currUser);
filter.HandlerId = user.Id;
filter.EndCreateTime = filter.EndCreateTime.AddThisDayLastTime();
return(ExecReturnFuncAndConnectionId <PagingInfo <WorkflowInfo> >((reInfo, connId) =>
{
return Persistence.SelectAuditedHandlePage(pageIndex, pageSize, filter, connId);
}, null, connectionId, AccessMode.SLAVE));
}
/// <summary>
/// 验证
/// </summary>
/// <param name="returnInfo">返回信息</param>
/// <param name="workflow">工作流</param>
/// <param name="comData">通用数据</param>
protected override void Vali(ReturnInfo <bool> returnInfo, WorkflowInfo workflow, CommonUseData comData = null)
{
var user = UserTool <int> .GetCurrUser(comData);
if (workflow.CreaterId != user.Id)
{
returnInfo.SetFailureMsg("Sorry，您不是此流程的发起者，故不能移除");
return;
}
if (workflow.FlowStatus != FlowStatusEnum.DRAFT)
{
returnInfo.SetFailureMsg("Sorry，只有草稿状态才能移除");
return;
}
}
public virtual ReturnInfo <WorkflowInfo> FindCurrUserApplyDetail([DisplayName2("ID"), Id] int id, string connectionId = null, BasicUserInfo currUser = null)
{
ReturnInfo <WorkflowInfo> returnInfo = FindContainHandlesAndAllConfigs(id, connectionId, currUser);
if (returnInfo.Failure())
{
return(returnInfo);
}
var user = UserTool.GetCurrUser(currUser);
if (returnInfo.Data.CreaterId != user.Id)
{
returnInfo.SetFailureMsg("此工作流不是您申请的，无权限查看");
return(returnInfo);
}
return(returnInfo);
}
/// <summary>
/// 重置用户密码
/// </summary>
/// <param name="modifyPassword">修改密码</param>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
/// <returns>返回信息</returns>
public virtual ReturnInfo <bool> ResetUserPassword([Model] ModifyPasswordInfo modifyPassword, CommonUseData comData = null, string connectionId = null)
{
return(ExecReturnFuncAndConnectionId <bool>((reInfo, connId) =>
{
UserInfo user = new UserInfo()
{
Id = modifyPassword.Id,
Password = MD5Util.Encryption16(modifyPassword.NewPassword)
};
user.SetModifyInfo(UserTool <int> .GetCurrUser(comData));
bool result = Persistence.UpdatePasswordById(user, connId) > 0;
if (result)
{
reInfo.SetSuccessMsg("修改成功，请记住新密码！");
}
return result;
}, null, connectionId));
}
/// <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="roleId">角色ID</param>
/// <param name="menuFunctionIds">菜单功能ID列表</param>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
/// <returns>返回信息</returns>
public virtual ReturnInfo <bool> SaveRoleMenuFunctions([DisplayName2("角色ID"), Id] int roleId, IList <int> menuFunctionIds, CommonUseData comData = null, string connectionId = null)
{
IList <RoleMenuFunctionInfo> rmfs = new List <RoleMenuFunctionInfo>(menuFunctionIds.Count);
foreach (var id in menuFunctionIds)
{
RoleMenuFunctionInfo rmf = new RoleMenuFunctionInfo()
{
RoleId = roleId,
MenuFunctionId = id
};
rmf.SetCreateInfo(UserTool <int> .GetCurrUser(comData));
rmfs.Add(rmf);
}
ReturnInfo <bool> returnInfo = new ReturnInfo <bool>();
ExecSaveRoleMenuFunctions(returnInfo, roleId, rmfs, connectionId: connectionId, comData: comData);
return(returnInfo);
}
/// <summary>
/// 是否存在租赁ID
/// </summary>
/// <param name="currUserTenantId">当前用户租户ID</param>
/// <returns>是否存在租赁ID</returns>
protected virtual bool IsExistsTenantId(out IdT currUserTenantId)
{
currUserTenantId = default(IdT);
if (ModelContainerTenantId())
{
var currUser = UserTool <IdT> .GetCurrUser();
if (currUser == null)
{
throw new ArgumentNullException("当前用户为空");
}
if (Identity.IsEmpty(currUser.TenantId))
{
throw new ArgumentException("当前用户的租户ID为空");
}
currUserTenantId = currUser.TenantId;
return(true);
}
return(false);
}
/// <summary>
/// 根据登录ID修改密码
/// </summary>
/// <param name="currUserModifyPassword">当前用户修改密码</param>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
/// <returns>返回信息</returns>
public virtual ReturnInfo <bool> ModifyPasswordByLoginId([Model] CurrUserModifyPasswordInfo currUserModifyPassword, CommonUseData comData = null, string connectionId = null)
{
return(ExecReturnFuncAndConnectionId <bool>((reInfo, connId) =>
{
UserInfo user = Persistence.SelectByLoginIdAndPassword(currUserModifyPassword.LoginId, MD5Util.Encryption16(currUserModifyPassword.OldPassword), connId);
if (user == null)
{
reInfo.SetFailureMsg("旧密码不对");
return false;
}
user.Password = MD5Util.Encryption16(currUserModifyPassword.NewPassword);
user.SetModifyInfo(UserTool <int> .GetCurrUser(comData));
bool result = Persistence.UpdatePasswordById(user, connId) > 0;
if (result)
{
reInfo.SetSuccessMsg("修改成功，请记住新密码！");
}
return result;
}, null, connectionId));
}
/// <summary>
/// 执行核心
/// </summary>
/// <param name="returnInfo">返回信息</param>
/// <param name="workflow">工作流</param>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
protected override void ExecCore(ReturnInfo <bool> returnInfo, WorkflowInfo workflow, CommonUseData comData = null, string connectionId = null)
{
var user = UserTool <int> .GetCurrUser(comData);
// 除本人外，所有处理者都删除
foreach (var h in workflow.Handles)
{
if (h.HandlerId == user.Id)
{
workflow.CurrHandlerIds = h.HandlerId.ToString();
workflow.CurrHandlers = h.Handler;
workflow.CurrConcreteCensorshipIds = h.ConcreteConcreteId.ToString();
workflow.CurrConcreteCensorships = h.ConcreteConcrete;
workflow.CurrFlowCensorshipIds = h.FlowCensorshipId.ToString();
workflow.FlowStatus = FlowStatusEnum.REVERSED;
continue;
}
WorkflowHandlePersistence.DeleteById(h.Id, connectionId: connectionId, comData: comData);
}
WorkflowPersistence.UpdateFlowStatusAndCensorshipAndHandlerById(workflow, connectionId);
}
/// <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="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="connectionId">连接ID</param>
/// <param name="currUser">当前用户</param>
/// <returns>返回信息</returns>
public virtual ReturnInfo <bool> IsCurrUserAdministrators(string connectionId = null, BasicUserInfo <int> currUser = null)
{
var user = UserTool <int> .GetCurrUser(currUser);
return(IsUserAdministrators(user.Id, connectionId));
}
/// <summary>
/// 根据菜单编码查询当前用户所拥有的功能信息列表
/// </summary>
/// <param name="menuCode">菜单编码</param>
/// <param name="connectionId">连接ID</param>
/// <param name="currUser">当前用户</param>
/// <returns>返回信息</returns>
public virtual ReturnInfo <IList <FunctionInfo> > QueryCurrUserOwnFunctionsByMenuCode([DisplayName2("菜单编码"), Required] string menuCode, string connectionId = null, BasicUserInfo <int> currUser = null)
{
var user = UserTool <int> .GetCurrUser(currUser);
return(QueryUserOwnFunctionsByMenuCode(user.Id, menuCode, connectionId, currUser));
}
/// <summary>
/// 根据菜单编码和功能编码集合判断当前用户是否有权限
/// </summary>
/// <param name="menuCode">菜单编码</param>
/// <param name="functionCodes">功能编码集合</param>
/// <param name="connectionId">连接ID</param>
/// <param name="currUser">当前用户</param>
/// <returns>返回信息</returns>
public virtual ReturnInfo <bool> IsCurrUserPermission(string menuCode, string[] functionCodes, string connectionId = null, BasicUserInfo <int> currUser = null)
{
var user = UserTool <int> .GetCurrUser(currUser);
return(IsPermission(user.Id, menuCode, functionCodes, connectionId));
}
/// <summary>
/// 判断当前用户是否是系统管理组
/// </summary>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
/// <returns>返回信息</returns>
public virtual ReturnInfo <bool> IsCurrUserAdministrators(CommonUseData comData = null, string connectionId = null)
{
var user = UserTool <int> .GetCurrUser(comData);
return(IsUserAdministrators(user.Id, connectionId: connectionId, comData: comData));
}
/// <summary>
/// 验证流程输入
/// </summary>
/// <param name="returnInfo">返回信息</param>
/// <param name="flowIn">流程输入</param>
/// <param name="workflow">工作流</param>
/// <param name="connectionId">连接ID</param>
/// <param name="currUser">当前用户</param>
/// <returns>工作流定义</returns>
protected override WorkflowDefineInfo ValiFlowIn(ReturnInfo <bool> returnInfo, FlowInInfo <FlowAuditInfo> flowIn, out WorkflowInfo workflow, string connectionId = null, BasicUserInfo <int> currUser = 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, currUser);
if (reHandle.Failure())
{
returnInfo.FromBasic(reHandle);
return(null);
}
if (reHandle.Data == null)
{
returnInfo.SetFailureMsg("找不到工作流处理信息");
return(null);
}
var user = UserTool <int> .GetCurrUser(currUser);
if (reHandle.Data.HandlerId != user.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, connectionId, currUser);
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, currUser);
if (reWorkFlowConfig.Failure())
{
returnInfo.FromBasic(reWorkFlowConfig);
return(null);
}
return(reWorkFlowConfig.Data);
}
/// <summary>
/// 主页
/// </summary>
/// <returns>动作结果</returns>
public ActionResult Index()
{
var user = UserTool <int> .GetCurrUser();
return(View(UserMenuService.CanAccessMenus(user.Id)));
}
