修改知识库流程

src/Hotline.Api/Controllers/KnowledgeCommonController.cs

@@ -141,7 +141,7 @@ namespace Hotline.Api.Controllers
         /// <returns></returns>
         [HttpGet("typelist")]
         [AllowAnonymous]
-        public async Task<List<KnowledgeType>> GetTypeList(string ParentId)
+        public async Task<List<KnowledgeType>> GetTypeList(string? ParentId)
         {
             if (string.IsNullOrEmpty(ParentId))
                 ParentId = Guid.Empty.ToString();

src/Hotline.Api/Controllers/KnowledgeController.cs

@@ -1,14 +1,17 @@
-using Hotline.Application.Knowledge;
+using Hotline.Application.FlowEngine;
+using Hotline.Application.Knowledge;
+using Hotline.FlowEngine.Workflows;
 using Hotline.KnowledgeBase;
 using Hotline.KnowledgeBase.Notifies;
 using Hotline.Permissions;
 using Hotline.Repository.SqlSugar.Extensions;
+using Hotline.Settings;
 using Hotline.Share.Dtos;
+using Hotline.Share.Dtos.FlowEngine;
 using Hotline.Share.Dtos.Knowledge;
 using Hotline.Share.Enums.KnowledgeBase;
 using MapsterMapper;
 using MediatR;
-using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using SqlSugar;
 using XF.Domain.Authentications;
@@ -28,6 +31,8 @@ namespace Hotline.Api.Controllers
         private readonly IMapper _mapper;
         private readonly IKnowApplication _knowApplication;
         private readonly IMediator _mediator;
+        private readonly IWorkflowApplication _workflowApplication;
+        private readonly IWorkflowDomainService _workflowDomainService;
 
         /// <summary>
         /// 
@@ -39,9 +44,11 @@ namespace Hotline.Api.Controllers
         /// <param name="mapper"></param>
         /// <param name="knowApplication"></param>
         /// <param name="mediator"></param>
+        /// <param name="workflowApplication"></param>
+        /// <param name="workflowDomainService"></param>
         public KnowledgeController(IKnowledgeRepository knowledgeRepository, IKnowledgeTempRepository knowledgeTempRepository,
            ISessionContext sessionContext, IKnowledgeDomainService knowledgeDomainService, IMapper mapper, IKnowApplication knowApplication,
-           IMediator mediator)
+           IMediator mediator, IWorkflowApplication workflowApplication, IWorkflowDomainService workflowDomainService)
         {
             _knowledgeRepository = knowledgeRepository;
             _knowledgeTempRepository = knowledgeTempRepository;
@@ -50,6 +57,8 @@ namespace Hotline.Api.Controllers
             _mapper = mapper;
             _knowApplication = knowApplication;
             _mediator = mediator;
+            _workflowApplication = workflowApplication;
+            _workflowDomainService = workflowDomainService;
         }
         #region 草稿箱
         /// <summary>
@@ -171,7 +180,24 @@ namespace Hotline.Api.Controllers
         [HttpPost("knowadd")]
         public async Task<string> KnowledgeAdd([FromBody] AddKnowledgeDto dto)
         {
-            return await _knowledgeDomainService.KnowledgeAdd(dto, HttpContext.RequestAborted);
+            //知识处理逻辑
+            var knowId = await _knowledgeDomainService.KnowledgeAdd(dto, HttpContext.RequestAborted);
+            //处理流程
+            if (!string.IsNullOrEmpty(knowId))
+            {
+                //调用流程创建
+                var exists = await _workflowDomainService.ExsitsAsync(WorkflowModuleConsts.KnowledgeAdd, knowId, HttpContext.RequestAborted);
+                if (exists)
+                    throw UserFriendlyException.SameMessage($"该知识已发起过{WorkflowModule.Modules[WorkflowModuleConsts.KnowledgeAdd]}流程");
+                var workFlowId = await _workflowApplication.StartWorkflowAsync(dto.StartWorkflowDto, knowId, HttpContext.RequestAborted);
+                if (string.IsNullOrEmpty(workFlowId))
+                {
+                    //创建流程失败
+                    await _knowledgeRepository.RemoveAsync(p => p.Id == knowId, false, HttpContext.RequestAborted);
+                }
+            }
+            return knowId;
+
         }
 
         /// <summary>
@@ -183,40 +209,52 @@ namespace Hotline.Api.Controllers
         [HttpPut("knowupdate")]
         public async Task KnowledgeUpdate([FromBody] UpdateKnowledgeDto dto)
         {
-            //新增一条数据
-            await _knowledgeDomainService.KnowledgeUpdate(dto, HttpContext.RequestAborted);
+            //知识更新流程业务
+            var knowId = await _knowledgeDomainService.KnowledgeUpdate(dto, HttpContext.RequestAborted);
+            if (!string.IsNullOrEmpty(knowId))
+            {
+                //知识更新流程创建
+                var workFlowId = await _workflowApplication.StartWorkflowAsync(dto.StartWorkflowDto, knowId, HttpContext.RequestAborted);
+                if (string.IsNullOrEmpty(workFlowId))
+                {
+                    //创建流程失败
+                    await _knowledgeRepository.RemoveAsync(p => p.Id == knowId, false, HttpContext.RequestAborted);
+                }
+            }
         }
 
         /// <summary>
         /// 知识库-删除
         /// </summary>
         /// <param name="Id"></param>
+        /// <param name="workDto"></param>
         /// <returns></returns>
         [Permission(EPermission.KnowledgeDelete)]
         [HttpDelete("knowdelete")]
-        public async Task KnowledgeDelete(string Id)
+        public async Task KnowledgeDelete(string Id, [FromBody] StartWorkflowDto workDto)
         {
-            await _knowledgeDomainService.KnowledgeDelete(Id, HttpContext.RequestAborted);
+            var know = await _knowledgeRepository.GetAsync(Id, HttpContext.RequestAborted);
+            if (know != null && know.IsDeleted == false)
+            {
+                //如果审批不通过可以直接删除此条信息
+                if (know.Status == EKnowledgeStatus.Failed)
+                {
+                    await _knowledgeRepository.RemoveAsync(know, false, HttpContext.RequestAborted);
+                }
+                else//审批通过需要走删除流程
+                {
+                    //调用流程创建
+                    var exists = await _workflowDomainService.ExsitsAsync(WorkflowModuleConsts.KnowledgeDelete, Id, HttpContext.RequestAborted);
+                    if (exists)
+                        throw UserFriendlyException.SameMessage($"该知识已发起过{WorkflowModule.Modules[WorkflowModuleConsts.KnowledgeDelete]}流程");
+
+                    await _workflowApplication.StartWorkflowAsync(workDto, know.Id, HttpContext.RequestAborted);
+                }
+            }
+            else
+                throw UserFriendlyException.SameMessage("知识删除失败");
         }
 
-        ///// <summary>
-        ///// 审批操作
-        ///// </summary>
-        ///// <param name="Ids">需要审批的数据ID</param>
-        ///// <param name="ApprovalStatus">审核状态：0：通过；1：不通过</param>
-        ///// <param name="HandleOpinions">办理意见</param>
-        ///// <returns></returns>
-        //[HttpPut("approvalhandle")]
-        //public async Task ApprovalHandle(List<string> Ids, string ApprovalStatus, string? HandleOpinions)
-        //{
-        //    if (Ids is null || Ids.Count == 0)
-        //        throw UserFriendlyException.SameMessage("数据不能为空");
-        //    if (ApprovalStatus == "1" && string.IsNullOrEmpty(HandleOpinions))
-        //        throw UserFriendlyException.SameMessage("办理意见不能为空");
-        //    //审批操作
-        //   await _knowledgeDomainService.ApprovalHandle(Ids, ApprovalStatus, HandleOpinions, HttpContext.RequestAborted);
-        //}
-
         /// <summary>
         /// 知识库-知识下架
         /// </summary>

src/Hotline.Application/Handlers/FlowEngine/EndWorkflowHandler.cs

@@ -1,21 +1,17 @@
-using Google.Type;
-using Hotline.Application.Knowledge;
-using Hotline.FlowEngine.Notifies;
+using Hotline.FlowEngine.Notifies;
 using Hotline.KnowledgeBase;
 using Hotline.Settings;
-using Hotline.Share.Enums.KnowledgeBase;
 using MediatR;
-using XF.Domain.Exceptions;
 
 namespace Hotline.Application.Handlers.FlowEngine;
 
 public class EndWorkflowHandler : INotificationHandler<EndWorkflowNotify>
 {
-    private readonly IKnowApplication _knowApplication;
+    private readonly IKnowledgeDomainService _knowledgeDomainService;
 
-    public EndWorkflowHandler(IKnowApplication knowApplication)
+    public EndWorkflowHandler(IKnowledgeDomainService knowledgeDomainService)
     {
-        _knowApplication = knowApplication;
+        _knowledgeDomainService = knowledgeDomainService;
     }
 
     /// <summary>Handles a notification</summary>
@@ -30,7 +26,7 @@ public class EndWorkflowHandler : INotificationHandler<EndWorkflowNotify>
             case WorkflowModuleConsts.KnowledgeAdd://新增
             case WorkflowModuleConsts.KnowledgeUpdate://修改
             case WorkflowModuleConsts.KnowledgeDelete://删除
-                await _knowApplication.EndWorkKnowledge(workflow, cancellationToken);
+                await _knowledgeDomainService.EndWorkKnowledge(workflow, cancellationToken);
                 break;
         }
     }

src/Hotline.Application/Knowledge/IKnowApplication.cs

@@ -1,5 +1,4 @@
-using Hotline.FlowEngine.Workflows;
-using Hotline.KnowledgeBase;
+using Hotline.KnowledgeBase;
 using Hotline.Share.Dtos;
 using Hotline.Share.Dtos.Knowledge;
 
@@ -7,14 +6,6 @@ namespace Hotline.Application.Knowledge
 {
     public interface IKnowApplication
     {
-        /// <summary>
-        ///  流程审批完成，处理知识状态
-        /// </summary>
-        /// <param name="workflow"></param>
-        /// <param name="cancellationToken"></param>
-        /// <returns></returns>
-        Task EndWorkKnowledge(Workflow workflow, CancellationToken cancellationToken);
-
         /// <summary>
         /// 知识库查询
         /// </summary>

src/Hotline.Application/Knowledge/KnowApplication.cs

@@ -37,45 +37,6 @@ namespace Hotline.Application.Knowledge
             _mapper = mapper;
         }
 
-        /// <summary>
-        /// 流程审批完成，处理知识状态
-        /// </summary>
-        /// <param name="workflow"></param>
-        /// <param name="cancellationToken"></param>
-        /// <returns></returns>
-        /// <exception cref="UserFriendlyException"></exception>
-        public async Task EndWorkKnowledge(Workflow workflow, CancellationToken cancellationToken)
-        {
-            var knowledge = await _knowledgeRepository.GetAsync(d => d.WorkflowId == workflow.Id, cancellationToken);
-            if (knowledge == null)
-                throw new UserFriendlyException($"知识查询失败, workflowId: {workflow.Id}", "无效流程编号");
-            switch (workflow.ModuleCode)
-            {
-                case WorkflowModuleConsts.KnowledgeAdd://新增
-                    //修改知识状态为已上架
-                    knowledge.Status = EKnowledgeStatus.OnShelf;
-                    knowledge.OnShelfTime = System.DateTime.Now;
-                    await _knowledgeRepository.UpdateAsync(knowledge);
-                    break;
-                case WorkflowModuleConsts.KnowledgeUpdate://修改
-                    //修改知识状态为已上架
-                    knowledge.Status = EKnowledgeStatus.OnShelf;
-                    knowledge.OnShelfTime = System.DateTime.Now;
-                    await _knowledgeRepository.UpdateAsync(knowledge);
-
-                    break;
-
-                case WorkflowModuleConsts.KnowledgeDelete://删除
-                    //知识先下架，在删除                                       
-                    knowledge.Status = EKnowledgeStatus.OffShelf;
-                    knowledge.OffShelfTime = System.DateTime.Now;
-                    await _knowledgeRepository.UpdateAsync(knowledge);
-                    //删除知识
-                    await _knowledgeRepository.RemoveAsync(knowledge, true, cancellationToken);
-                    break;
-            }
-        }
-
         /// <summary>
         /// 知识库查询
         /// </summary>

src/Hotline.Share/Dtos/Knowledge/KnowledgeDto.cs

@@ -1,4 +1,6 @@
-namespace Hotline.Share.Dtos.Knowledge
+using Hotline.Share.Dtos.FlowEngine;
+
+namespace Hotline.Share.Dtos.Knowledge
 {
     /// <summary>
     /// 编辑
@@ -81,5 +83,10 @@
         /// 关联知识
         /// </summary>
         public List<string> Knowledges { get; set; }
+
+        /// <summary>
+        /// 工作流信息
+        /// </summary>
+        public StartWorkflowDto StartWorkflowDto { get; set; }
     }
 }

src/Hotline/KnowledgeBase/IKnowledgeDomainService.cs

@@ -1,4 +1,5 @@
-using Hotline.Share.Dtos.Knowledge;
+using Hotline.FlowEngine.Workflows;
+using Hotline.Share.Dtos.Knowledge;
 
 namespace Hotline.KnowledgeBase
 {
@@ -23,30 +24,22 @@ namespace Hotline.KnowledgeBase
         /// </summary>
         /// <param name="dto"></param>
         /// <returns></returns>
-        Task KnowledgeUpdate(UpdateKnowledgeDto dto, CancellationToken cancellationToken);
+        Task<string> KnowledgeUpdate(UpdateKnowledgeDto dto, CancellationToken cancellationToken);
 
         /// <summary>
-        /// 知识库-删除
-        /// </summary>
-        /// <param name="Id"></param>
-        /// <returns></returns>
-        Task KnowledgeDelete(string Id, CancellationToken cancellationToken);
-
-        /// <summary>
-        /// 审批操作
+        /// 
         /// </summary>
-        /// <param name="Ids">需要审批的数据ID</param>
-        /// <param name="ApprovalStatus">审核状态：0：通过；1：不通过</param>
-        /// <param name="HandleOpinions">办理意见</param>
+        /// <param name="know"></param>
+        /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        Task ApprovalHandle(List<string> Ids, string ApprovalStatus, string HandleOpinions, CancellationToken cancellationToken);
+        Task KnowledgePvIncreaseAsync(Knowledge know, CancellationToken cancellationToken);
 
         /// <summary>
-        /// 
+        /// 流程审批完成，处理知识状态
         /// </summary>
-        /// <param name="know"></param>
+        /// <param name="workflow"></param>
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        Task KnowledgePvIncreaseAsync(Knowledge know, CancellationToken cancellationToken);
+        Task EndWorkKnowledge(Workflow workflow, CancellationToken cancellationToken);
     }
 }

src/Hotline/KnowledgeBase/KnowledgeDomainService.cs

@@ -1,4 +1,5 @@
 using Hotline.FlowEngine.Workflows;
+using Hotline.Settings;
 using Hotline.Share.Dtos.Knowledge;
 using Hotline.Share.Enums.KnowledgeBase;
 using MapsterMapper;
@@ -85,10 +86,6 @@ namespace Hotline.KnowledgeBase
             kn.Status = EKnowledgeStatus.Auditing;
 
             return await _knowledgeRepository.AddAsync(kn, cancellationToken);
-            //调用流程创建
-
-            //如果流程创建失败需要删除此条数据
-            //await _knowledgeRepository.RemoveAsync(knowledge);
         }
 
         /// <summary>
@@ -96,7 +93,7 @@ namespace Hotline.KnowledgeBase
         /// </summary>
         /// <param name="dto"></param>
         /// <returns></returns>
-        public async Task KnowledgeUpdate(UpdateKnowledgeDto dto, CancellationToken cancellationToken)
+        public async Task<string> KnowledgeUpdate(UpdateKnowledgeDto dto, CancellationToken cancellationToken)
         {
             //知识修改逻辑
             //如果可以修改，此条数据不动，重新写入一条新数据，知识编号不变，版本号+1
@@ -110,72 +107,114 @@ namespace Hotline.KnowledgeBase
 
             var knowledge = _mapper.Map<Knowledge>(dto);
             knowledge.Code = know.Code;
-            knowledge.PageView = 0;
+            knowledge.PageView = know.PageView;
             knowledge.Status = EKnowledgeStatus.Auditing;
             knowledge.Id = "";
-            knowledge.Version = know.Version + 1;
+            knowledge.Version = 0;
             //新增一条数据
-            await _knowledgeRepository.AddAsync(knowledge, cancellationToken);
-
-            //调用流程创建
+            return await _knowledgeRepository.AddAsync(knowledge, cancellationToken);
 
-            //如果流程创建失败需要删除此条数据
-            //await _knowledgeRepository.RemoveAsync(knowledge);
         }
 
         /// <summary>
-        /// 知识库-删除
+        /// 流程审批完成，处理知识状态
         /// </summary>
-        /// <param name="Id"></param>
+        /// <param name="workflow"></param>
+        /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        public async Task KnowledgeDelete(string Id, CancellationToken cancellationToken)
+        /// <exception cref="UserFriendlyException"></exception>
+        public async Task EndWorkKnowledge(Workflow workflow, CancellationToken cancellationToken)
         {
-            var know = await _knowledgeRepository.GetAsync(Id, cancellationToken);
-            if (know != null && know.IsDeleted == false)
+            var knowledge = await _knowledgeRepository.GetAsync(workflow.ExternalId, cancellationToken);
+            if (knowledge == null)
+                throw new UserFriendlyException($"知识查询失败, workflowId: {workflow.Id}", "无效流程编号");
+            switch (workflow.ModuleCode)
             {
-                //调用流程创建
+                case WorkflowModuleConsts.KnowledgeAdd://新增
+                    //修改知识状态为已上架
+                    knowledge.Status = EKnowledgeStatus.OnShelf;
+                    knowledge.OnShelfTime = System.DateTime.Now;
+                    await _knowledgeRepository.UpdateAsync(knowledge);
+                    break;
+                case WorkflowModuleConsts.KnowledgeUpdate://修改
+                    ////处理知识版本号
+                    ////根据Code查询目前使用的版本号，版本号+1
+                    //var oldKnowledge = await _knowledgeRepository
+                    //    .Queryable()
+                    //    .Where(p => p.Code == knowledge.Code && p.Status != EKnowledgeStatus.Auditing && p.Status != EKnowledgeStatus.Failed && p.IsDeleted == false)
+                    //    .OrderByDescending(p => p.Version)
+                    //    .Take(1)
+                    //    .FirstAsync();
+                    //if (oldKnowledge == null)
+                    //    knowledge.Version = 1;
+                    //else
+                    //    knowledge.Version = oldKnowledge.Version + 1;
+                    ////修改知识状态为已上架
+                    //knowledge.Status = EKnowledgeStatus.OnShelf;
+                    //knowledge.OnShelfTime = System.DateTime.Now;
+                    //await _knowledgeRepository.UpdateAsync(knowledge);
+                    await KnowledgeUpdate(knowledge);
+                    break;
+
+                case WorkflowModuleConsts.KnowledgeDelete://删除
+                    ////知识先下架，在删除                                       
+                    //knowledge.Status = EKnowledgeStatus.OffShelf;
+                    //knowledge.OffShelfTime = System.DateTime.Now;
+                    //await _knowledgeRepository.UpdateAsync(knowledge);
+                    //删除知识
+                    await _knowledgeRepository.RemoveAsync(p => p.Code == knowledge.Code, true, cancellationToken);
+                    break;
             }
-            else
-                throw UserFriendlyException.SameMessage("知识删除失败");
         }
 
         /// <summary>
-        /// 审批操作
+        /// 交换数据、为了保持浏览记录等数据的存在
         /// </summary>
-        /// <param name="Ids">需要审批的数据ID</param>
-        /// <param name="ApprovalStatus">审核状态：0：通过；1：不通过</param>
-        /// <param name="HandleOpinions">办理意见</param>
+        /// <param name="knowledge"></param>
         /// <returns></returns>
-        public async Task ApprovalHandle(List<string> Ids, string ApprovalStatus, string HandleOpinions, CancellationToken cancellationToken)
+        private async Task KnowledgeUpdate(Knowledge knowledge)
         {
-            //审批操作
-            foreach (var item in Ids)
+            var Version = 1;
+            //处理知识版本号
+            //根据Code查询目前使用的版本号，版本号+1
+            var oldKnowledge = await _knowledgeRepository
+                .Queryable()
+                .Where(p => p.Code == knowledge.Code && p.Status != EKnowledgeStatus.Auditing && p.Status != EKnowledgeStatus.Failed && p.IsDeleted == false)
+                .OrderByDescending(p => p.Version)
+                .Take(1)
+                .FirstAsync();
+            //如果没查到历史版本，直接改当前的数据
+            if (oldKnowledge != null)
             {
-                var know = await _knowledgeRepository.GetAsync(item, cancellationToken);
-                if (know != null)
-                {
-                    var strWorkflowId = "";
-                    //调用流程审批接口
-                    //流程调用成功以后在处理以下业务
-                    //需要区分新增、修改、删除业务
-                    //处理数据
-                    if (ApprovalStatus == "0")
-                    {
-                        know.Status = EKnowledgeStatus.OnShelf;
-                        know.OnShelfTime = DateTime.Now;
-                        know.OffShelfTime = null;
-                    }
-                    else
-                        know.Status = EKnowledgeStatus.Failed;
-
-                    if (!string.IsNullOrEmpty(strWorkflowId))
-                    {
-                        know.WorkflowId = strWorkflowId;
-                        await _knowledgeRepository.UpdateAsync(know, cancellationToken);
-                    }
-                }
+                Version = oldKnowledge.Version + 1;   //已经查询到版本
+
+                //交换数据、为了保持浏览记录等数据的存在
+                var tempId = knowledge.Id;//最新审批通过的ID
+                var tempOldId = oldKnowledge.Id;//原始数据ID
+                var temp = oldKnowledge;//保存原始数据
+
+                _mapper.Map(knowledge, oldKnowledge);//最新数据赋值给原始数据
+                oldKnowledge.Id = tempOldId;//ID不变
+                oldKnowledge.Status = EKnowledgeStatus.OnShelf;//改变知识状态
+                oldKnowledge.OnShelfTime = System.DateTime.Now;//自动上架时间
+                oldKnowledge.OffShelfTime = null;
+                oldKnowledge.Version = Version;
+
+                _mapper.Map(temp, knowledge);
+                knowledge.Id = tempId;
+                await _knowledgeRepository.UpdateAsync(knowledge);
+                await _knowledgeRepository.UpdateAsync(oldKnowledge);
             }
+            else
+            {
+                knowledge.Status = EKnowledgeStatus.OnShelf;
+                knowledge.OnShelfTime = System.DateTime.Now;
+                knowledge.OffShelfTime = null;
+                knowledge.Version = Version;
+                await _knowledgeRepository.UpdateAsync(knowledge);
+            }
+
         }
-    }
-}
 
+    }
+}