/// <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))); }