1

gx_api/GxPress/Api/GxPress.Api/WebControllers/WebFlowController.Actions.cs

@@ -0,0 +1,156 @@
+using System;
+using System.Threading.Tasks;
+using Datory;
+using GxPress.Common.Tools;
+using GxPress.EnumConst;
+using GxPress.Result;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace GxPress.Api.WebControllers
+{
+    public partial class WebFlowController
+    {
+
+        /// <summary>
+        /// 动作 - 审批
+        /// </summary>
+        /// <param name="request">审批意见</param>
+        /// <returns></returns>
+        [HttpPost("action/check")]
+        [AllowAnonymous]
+        public async Task<DefaultResult> ActionsCheck([FromBody] CheckRequest request)
+        {
+            if (!string.IsNullOrEmpty(request.Message) && request.Message.Length > 500)
+            {
+                throw new Exception("审批意见不能操作500字，请重新输入");
+            }
+            await _flowService.CheckAsync(request.TodoId, request.IsChecked, request.Message);
+
+            return new DefaultResult
+            {
+                Value = true
+            };
+        }
+
+        /// <summary>
+        /// 动作 - 下载
+        /// </summary>
+        /// <param name="request">请求</param>
+        /// <returns></returns>
+        [HttpPost("action/download")]
+        [AllowAnonymous]
+        public async Task<DownloadResult> ActionsDownload([FromBody] ActionRequest request)
+        {
+            // var url = await _flowService.DownloadAsync(request.FlowId);
+            // url = Request.Scheme + "://" + Request.Host.Host +
+            //           (Request.Host.Port > 0 ? $":{Request.Host.Port}" : string.Empty) +
+            //           "/" + url;
+            var url = await docService.MakeDoc(request.FlowId, _loginContext.AccountId);
+            return new DownloadResult
+            {
+                DownloadUrl = StringUtils.AddDomain(url),
+                PreviewUrl = StringUtils.GetPreviewDocUrl(url)
+            };
+        }
+
+        /// <summary>
+        /// 动作 - 催办
+        /// </summary>
+        /// <param name="request">请求</param>
+        /// <returns></returns>
+        [HttpPost("action/remind")]
+        [AllowAnonymous]
+        public async Task<DefaultResult> ActionsRemind([FromBody] ActionRequest request)
+        {
+            return new DefaultResult
+            {
+                Value = await _flowService.RemindAsync(request.FlowId, _loginContext.AccountId)
+            };
+        }
+
+        /// <summary>
+        /// 动作 - 上会
+        /// </summary>
+        /// <param name="request">请求</param>
+        /// <returns></returns>
+        [HttpPost("action/meeting")]
+        [AllowAnonymous]
+        public async Task<DefaultResult> ActionsMeeting([FromBody] ActionRequest request)
+        {
+            //await _flowRepository.UpdateStateAsync(request.FlowId, nameof(FlowState.Meeting));
+            //修改当前用户的审核状态
+            await _flowTodoRepository.UpdateAsync(Q.Set(nameof(Entity.WorkFlow.FlowTodo.IsDone), true).Set(nameof(Entity.WorkFlow.FlowTodo.IsChecked), false).Set(nameof(Entity.WorkFlow.FlowTodo.DoneType), 1).Where(nameof(Entity.WorkFlow.FlowTodo.FlowId), request.FlowId).Where(nameof(Entity.WorkFlow.FlowTodo.Type), nameof(TodoTypeConst.ApproverCheck)).Where(nameof(Entity.WorkFlow.FlowTodo.UserId), _loginContext.AccountId));
+            return new DefaultResult
+            {
+                Value = true
+            };
+        }
+
+        /// <summary>
+        /// 动作 - 撤销上会
+        /// </summary>
+        /// <param name="request">请求</param>
+        /// <returns></returns>
+        [HttpPost("action/cancelMeeting")]
+        [AllowAnonymous]
+        public async Task<DefaultResult> ActionsCancelMeeting([FromBody] ActionRequest request)
+        {
+            //await _flowRepository.UpdateStateAsync(request.FlowId, nameof(FlowState.Checking));
+            //修改当前操作人为带审核
+            await _flowTodoRepository.UpdateAsync(Q.Where(nameof(Entity.WorkFlow.FlowTodo.FlowId), request.FlowId).Where(nameof(Entity.WorkFlow.FlowTodo.UserId), _loginContext.AccountId).Set(nameof(Entity.WorkFlow.FlowTodo.IsDone), false).Set(nameof(Entity.WorkFlow.FlowTodo.IsChecked), false).Set(nameof(Entity.WorkFlow.FlowTodo.DoneType), 0).Set(nameof(Entity.WorkFlow.FlowTodo.IsOperate), true));
+            return new DefaultResult
+            {
+                Value = true
+            };
+        }
+
+        /// <summary>
+        /// 动作 - 转审
+        /// </summary>
+        /// <param name="request">请求</param>
+        /// <returns></returns>
+        [HttpPost("action/transferCheck")]
+        [AllowAnonymous]
+        public async Task<DefaultResult> ActionsTransferCheck([FromBody] ActionTransferCheckRequest request)
+        {
+            await _flowService.TransferCheckAsync(request.TodoId, request.TransferUserIds, request.Message, request.FileIds);
+            // //修改当前用户的审核状态
+            // await _flowTodoRepository.UpdateAsync(Q.Set(nameof(Entity.WorkFlow.FlowTodo.IsDone), true).Where(nameof(Entity.WorkFlow.FlowTodo.Id), request.TodoId).Where(nameof(Entity.WorkFlow.FlowTodo.UserId), _loginContext.AccountId));
+            return new DefaultResult
+            {
+                Value = true
+            };
+        }
+
+        /// <summary>
+        /// 动作 - 重新提交
+        /// </summary>
+        /// <param name="request">请求</param>
+        /// <returns></returns>
+        [HttpPost("action/reAdd")]
+        [AllowAnonymous]
+        public async Task<DefaultResult> ActionsReAddCheck([FromBody] ActionRequest request)
+        {
+            await _flowService.ReAddAsync(request.FlowId);
+
+            return new DefaultResult
+            {
+                Value = true
+            };
+        }
+        /// <summary>
+        /// 上会待定
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        [HttpPost("action/wait")]
+        public async Task<DefaultResult> ActionsWait(ActionRequest request)
+        {
+            return new DefaultResult
+            {
+                Value = await _flowService.ActionsWait(request.FlowId, _loginContext.AccountId)
+            };
+        }
+    }
+}

gx_api/GxPress/Api/GxPress.Api/WebControllers/WebFlowController.Dto.cs

@@ -0,0 +1,138 @@
+using System.Collections.Generic;
+using GxPress.Entity.WorkFlow;
+using GxPress.EnumConst;
+
+namespace GxPress.Api.WebControllers
+{
+    public partial class WebFlowController
+    {
+        public class TodoListResult
+        {
+            /// <summary>
+            /// 当前页
+            /// </summary>
+            public int Count { get; set; }
+
+            /// <summary>
+            /// 每页显示多少项
+            /// </summary>
+            public IEnumerable<FlowTodoResult> Items { get; set; }
+        }
+
+        public class GetCountResult
+        {
+            /// <summary>
+            /// 我审批的 - 待审批
+            /// </summary>
+            public int MyCheckingCount { get; set; }
+
+            /// <summary>
+            /// 我审批的 - 已审批
+            /// </summary>
+            public int MyCheckedCount { get; set; }
+
+            /// <summary>
+            /// 我发起的 - 待审批
+            /// </summary>
+            public int SubmittedCheckingCount { get; set; }
+
+            /// <summary>
+            /// 我发起的 - 已审批
+            /// </summary>
+            public int SubmittedCheckedCount { get; set; }
+
+            /// <summary>
+            /// 抄送我的 - 未读
+            /// </summary>
+            public int CcUnreadCount { get; set; }
+
+            /// <summary>
+            /// 抄送我的 - 全部
+            /// </summary>
+            public int CcAllCount { get; set; }
+        }
+
+        public class FlowTodoResult : FlowTodo
+        {
+            public FlowState State { get; set; }
+            /// <summary>
+            /// 当前页
+            /// </summary>
+            public string Title { get; set; }
+
+            public string AvatarUrl { get; set; }
+
+            /// <summary>
+            /// 每页显示多少项
+            /// </summary>
+            public List<string> Summaries { get; set; }
+        }
+
+        public class CheckRequest
+        {
+            /// <summary>
+            /// 工作流Id
+            /// </summary>
+            public int FlowId { get; set; }
+
+            /// <summary>
+            /// 待办Id
+            /// </summary>
+            public int TodoId { get; set; }
+
+            /// <summary>
+            /// 是否审核通过
+            /// </summary>
+            public bool IsChecked { get; set; }
+
+            /// <summary>
+            /// 留言
+            /// </summary>
+            public string Message { get; set; }
+        }
+
+        public class ActionRequest
+        {
+            /// <summary>
+            /// 工作流Id
+            /// </summary>
+            public int FlowId { get; set; }
+        }
+
+        public class ActionTransferCheckRequest
+        {
+            /// <summary>
+            /// 待办Id
+            /// </summary>
+            public int TodoId { get; set; }
+
+            /// <summary>
+            /// 转审用户Id列表
+            /// </summary>
+            public List<int> TransferUserIds { get; set; }
+
+            /// <summary>
+            /// 审批意见
+            /// </summary>
+            public string Message { get; set; }
+
+            /// <summary>
+            /// 附件Id列表
+            /// </summary>
+            public List<int> FileIds { get; set; }
+        }
+
+        public class DownloadResult
+        {
+            /// <summary>
+            /// 下载地址
+            /// </summary>
+            public string DownloadUrl { get; set; }
+
+            /// <summary>
+            /// 预览
+            /// </summary>
+            public string PreviewUrl { get; set; }
+        }
+    }
+}

gx_api/GxPress/Api/GxPress.Api/WebControllers/WebFlowController.cs

@@ -0,0 +1,313 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using GxPress.Api.AdminControllers;
+using GxPress.Auth;
+using GxPress.Entity.WorkFlowDto;
+using GxPress.EnumConst;
+using GxPress.Repository.Interface;
+using GxPress.Repository.Interface.WorkFlow;
+using GxPress.Repository.Interface.WorkProcess;
+using GxPress.Request.App.Flow;
+using GxPress.Result.App;
+using GxPress.Result.App.Flow;
+using GxPress.Service.Interface;
+using GxPress.Service.Interface.Doc;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+
+namespace GxPress.Api.WebControllers
+{
+    /// <summary>
+    /// 通讯录用户信息
+    /// </summary>
+    [Route("api/web/flow")]
+    [ApiController]
+    [Authorize]
+    public partial class WebFlowController : Controller
+    {
+        private readonly ILogger<WebFlowController> _logger;
+        private readonly IWebHostEnvironment _environment;
+        private readonly ILoginContext _loginContext;
+        private readonly IFlowMessageRepository _flowMessageRepository;
+        private readonly IFlowTodoRepository _flowTodoRepository;
+        private readonly IProcessRepository _processRepository;
+        private readonly IProcessService _processService;
+        private readonly IFlowService _flowService;
+        private readonly IUserRepository _userRepository;
+        private readonly IFlowRepository _flowRepository;
+        private readonly IDocService docService;
+
+        public WebFlowController(
+            ILogger<WebFlowController> logger,
+            IWebHostEnvironment environment,
+            ILoginContext loginContext,
+            IFlowMessageRepository flowMessageRepository,
+            IFlowTodoRepository flowTodoRepository,
+            IProcessRepository processRepository,
+            IProcessService processService,
+            IFlowService flowService,
+            IUserRepository userRepository,
+            IFlowRepository flowRepository, IDocService docService
+            )
+        {
+            _logger = logger;
+            _environment = environment;
+            _loginContext = loginContext;
+            _flowMessageRepository = flowMessageRepository;
+            _flowTodoRepository = flowTodoRepository;
+            _processRepository = processRepository;
+            _processService = processService;
+            _flowService = flowService;
+            _userRepository = userRepository;
+            _flowRepository = flowRepository;
+            this.docService = docService;
+        }
+
+        /// <summary>
+        /// 删除
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [HttpDelete("{id}")]
+        public async Task Delete(int id)
+        {
+            await _flowService.DeleteAsync(id);
+        }
+
+        /// <summary>
+        /// 添加工作项
+        /// </summary>
+        /// <param name="flow">工作项</param>
+        /// <returns></returns>
+        [HttpPost]
+        [AllowAnonymous]
+        public async Task<FlowDto> Add([FromBody] FlowDto flow)
+        {
+            flow.State = FlowState.Checking;
+            flow.UserId = _loginContext.AccountId;
+            if (flow.Id > 0)
+                await _flowService.DeleteAsync(flow.Id);
+            flow.Id = await _flowService.AddAsync(flow);
+            await _flowService.AddInboxAsyc(flow);
+            return flow;
+        }
+
+        /// <summary>
+        /// 获取详情
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [HttpGet("{id}")]
+        [AllowAnonymous]
+        public async Task<FlowResult> Get(int id)
+        {
+            await _flowTodoRepository.UpdateCCIsDoneAsync(_loginContext.AccountId, id);
+            return await _flowService.GetFlowResult(id, _loginContext.AccountId);
+        }
+        /// <summary>
+        /// 获取详情 web专属
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [HttpGet("web/{id}")]
+        [AllowAnonymous]
+        public async Task<FlowResult> GetWeb(int id)
+        {
+            //await _flowTodoRepository.UpdateCCIsDoneAsync(_loginContext.AccountId, id);
+            return await _flowService.GetFlowResult(id, 0);
+        }
+        /// <summary>
+        /// 获取工作项列表
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet]
+        [AllowAnonymous]
+        public async Task<ListResult> List([FromQuery] FlowListRequest request)
+        {
+            var userId = _loginContext.AccountId;
+
+            if (request.Type == nameof(FlowListTypeConst.MyChecking))
+            {
+                return await _flowService.ListMyCheckingAsync(userId, request, nameof(FlowListTypeConst.MyChecking));
+            }
+
+            if (request.Type == nameof(FlowListTypeConst.MyChecked))
+            {
+                return await _flowService.ListMyCheckedAsync(userId, request, nameof(FlowListTypeConst.MyChecked));
+            }
+
+            if (request.Type == nameof(FlowListTypeConst.CcUnread))
+            {
+                return await _flowService.ListCcUnreadAsync(userId, request);
+            }
+
+            if (request.Type == nameof(FlowListTypeConst.CcAll))
+            {
+                return await _flowService.ListCcAllAsync(userId, request);
+            }
+
+            if (request.Type == nameof(FlowListTypeConst.SubmittedChecking))
+            {
+                return await _flowService.ListSubmittedCheckingAsync(userId, request);
+            }
+
+            if (request.Type == nameof(FlowListTypeConst.SubmittedChecked))
+            {
+                return await _flowService.ListSubmittedCheckedAsync(userId, request);
+            }
+
+            return new ListResult();
+        }
+        /// <summary>
+        /// 获取工作项列表
+        /// </summary>
+        /// <returns></returns>
+        [HttpPost("list")]
+        public async Task<ListResult> PostList(FlowListRequest request)
+        {
+            var userId = _loginContext.AccountId;
+
+            if (request.Type == nameof(FlowListTypeConst.MyChecking))
+            {
+                return await _flowService.ListMyCheckingAsync(userId, request, nameof(FlowListTypeConst.MyChecking));
+            }
+
+            if (request.Type == nameof(FlowListTypeConst.MyChecked))
+            {
+                return await _flowService.ListMyCheckedAsync(userId, request, nameof(FlowListTypeConst.MyChecked));
+            }
+
+            if (request.Type == nameof(FlowListTypeConst.CcUnread))
+            {
+                return await _flowService.ListCcUnreadAsync(userId, request);
+            }
+
+            if (request.Type == nameof(FlowListTypeConst.CcAll))
+            {
+                return await _flowService.ListCcAllAsync(userId, request, nameof(FlowListTypeConst.CcAll));
+            }
+
+            if (request.Type == nameof(FlowListTypeConst.SubmittedChecking))
+            {
+                return await _flowService.ListSubmittedCheckingAsync(userId, request, nameof(FlowListTypeConst.SubmittedChecking));
+            }
+
+            if (request.Type == nameof(FlowListTypeConst.SubmittedChecked))
+            {
+                return await _flowService.ListSubmittedCheckedAsync(userId, request);
+            }
+
+            return new ListResult();
+        }
+
+        /// <summary>
+        /// 待办事项
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet("todo")]
+        [AllowAnonymous]
+        public async Task<ListResult> TodoList([FromQuery] AdminFlowController.ListRequest request)
+        {
+            var userId = _loginContext.AccountId;
+            var flowListRequest = new FlowListRequest();
+            flowListRequest.Page = request.Page;
+            flowListRequest.PerPage = request.PerPage;
+            var result = await _flowService.ListMyCheckingAsync(userId, flowListRequest, nameof(FlowListTypeConst.MyChecking));
+            return new ListResult
+            {
+                Count = result.Count,
+                Items = result.Items
+            };
+            // var flowTodoList = await _flowService.GetTodoListAsync(userId, request.Page, request.PerPage, request.ProcessId);
+            // var resultList = new List<FlowTodoResult>();
+            // foreach (var flowTodo in flowTodoList)
+            // {
+            //     //新增
+            //     if (flowTodo.IsDone)
+            //         continue;
+            //     var flow = await _flowService.GetAsync(flowTodo.FlowId);
+            //     var user = await _userRepository.GetAsync(flow.UserId);
+            //     if (user == null || flow == null) continue;
+
+            //     var result = new FlowTodoResult
+            //     {
+            //         Id = flowTodo.Id,
+            //         ProcessId = flowTodo.ProcessId,
+            //         FlowId = flowTodo.FlowId,
+            //         UserId = flowTodo.UserId,
+            //         Type = flowTodo.Type,
+            //         State = flow.State,
+            //         IsDone = false,
+            //         CreatedDate = flowTodo.CreatedDate
+            //     };
+            //     var (title, summaries) = await _flowService.GetFlowTitleAndSummaryAsync(user, flow.ProcessId, flow.Id);
+            //     result.Title = title;
+            //     result.AvatarUrl = _userRepository.GetAvatarUrl(user);
+            //     result.Summaries = summaries;
+            //     resultList.Add(result);
+            // }
+
+            // return new TodoListResult
+            // {
+            //     Count = await _flowService.GetTodoCountAsync(userId),
+            //     Items = resultList
+            // };
+
+            //    //return resultList.ToList();
+            //}
+        }
+
+        /// <summary>
+        /// 获取数字
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet("count")]
+        [AllowAnonymous]
+        public async Task<GetCountResult> GetCount()
+        {
+            var userId = _loginContext.AccountId;
+            var request = new FlowListRequest();
+
+            var result = new GetCountResult
+            {
+                MyCheckingCount =
+                   await _flowTodoRepository.GetCountAsync(userId, nameof(TodoTypeConst.ApproverCheck), false,
+                    request),
+                MyCheckedCount =
+                    await _flowTodoRepository.GetCountAsync(userId, nameof(TodoTypeConst.ApproverCheck), true, request),
+                SubmittedCheckingCount = await _flowRepository.GetCountByUserIdAsync(userId, true, request),
+                //SubmittedCheckedCount= await _flowTodoRepository.GetUReadCountAsync(userId, "CarbonCopy",false,request),
+                SubmittedCheckedCount = await _flowRepository.GetCountByUserIdAsync(userId, false, request),
+                CcUnreadCount =
+                    await _flowTodoRepository.GetReadCountAsync(userId, nameof(TodoTypeConst.CarbonCopy), request, false),
+                CcAllCount = await _flowTodoRepository.GetReadCountAsync(userId, nameof(TodoTypeConst.CarbonCopy), request, true)
+            };
+            return result;
+        }
+
+        /// <summary>
+        /// 获取筛选
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet("filter")]
+        [AllowAnonymous]
+        public async Task<List<Option>> Filter()
+        {
+            var processes = await _processRepository.GetListByDepartmentIdAsync(_loginContext.DepartmentId);
+            var list = processes.Select(x => new Option
+            {
+                Label = x.Name,
+                Value = x.Id
+            }).ToList();
+            list.Insert(0, new Option
+            {
+                Label = "全部",
+                Value = 0
+            });
+            return list;
+        }
+    }
+}

gx_api/GxPress/Api/GxPress.Api/WebControllers/WebProcessController.cs

@@ -0,0 +1,89 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using GxPress.Auth;
+using GxPress.Repository.Interface.WorkProcess;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using GxPress.Entity.WorkProcess;
+using GxPress.Result.App.Process;
+using GxPress.Service.Interface;
+using System.Linq;
+using GxPress.Common.Tools;
+
+namespace GxPress.Api.WebControllers
+{
+    [Route("api/web/process")]
+    [ApiController]
+    [Authorize]
+    public class WebProcessController : ControllerBase
+    {
+        private readonly IProcessGroupRepository _processGroupRepository;
+        private readonly IProcessRepository _processRepository;
+        private readonly IProcessService _processService;
+        private readonly ILoginContext _loginContext;
+
+        public WebProcessController(IProcessGroupRepository processGroupRepository, IProcessRepository processRepository, IProcessService processService, ILoginContext loginContext)
+        {
+            _processGroupRepository = processGroupRepository;
+            _processRepository = processRepository;
+            _processService = processService;
+            _loginContext = loginContext;
+        }
+
+        /// <summary>
+        /// 获取工作流程列表
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet]
+        [AllowAnonymous]
+        public async Task<IEnumerable<Process>> GetProcessList()
+        {
+            return await _processRepository.GetListByDepartmentIdAsync(_loginContext.DepartmentId);
+        }
+
+        /// <summary>
+        /// 获取工作流程
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet("{id}")]
+        public async Task<GetProcessResult> GetProcess(int id)
+        {
+            var processDto = await _processService.GetAsync(id);
+            var result = new GetProcessResult
+            {
+                Id = processDto.Id,
+                Name = processDto.Name,
+                IconUrl = StringUtils.AddDomain(processDto.IconUrl),
+                Description = processDto.Description,
+                FormFields = processDto.FormFields,
+                AllowApproverCheck = processDto.AllowApproverCheck,
+                AllowCarbonCopy = processDto.AllowCarbonCopy
+            };
+            result.ApproverCheckUserIds = new List<int>();
+            //获取流程接点
+            foreach (var item in processDto.ProcessNodes)
+                //添加系统审核人
+                result.ApproverCheckUserIds.AddRange(item.ApproverChecks.Select(n => n.UserId));
+            result.ApproverCheckUserIds.Add(_loginContext.AccountId);
+            return result;
+        }
+
+        /// <summary>
+        /// 获取流程组与流程列表
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet("groups")]
+        [AllowAnonymous]
+        public async Task<IEnumerable<ProcessGroup>> GetProcessGroupList()
+        {
+            var groups = await _processGroupRepository.GetListAsync();
+            foreach (var processGroup in groups)
+            {
+                var processes = await _processRepository.GetListByGroupIdAsync(processGroup.Id);
+                processGroup.Processes = processes;
+            }
+
+            return groups;
+        }
+    }
+}