新增知识撤销

src/Hotline.Api/Controllers/KnowledgeController.cs

@@ -13,6 +13,7 @@ using Hotline.Share.Enums.KnowledgeBase;
 using MapsterMapper;
 using MediatR;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.IdentityModel.Tokens;
 using SqlSugar;
 using XF.Domain.Authentications;
 using XF.Domain.Exceptions;
@@ -185,28 +186,21 @@ namespace Hotline.Api.Controllers
         public async Task<string> KnowledgeAdd([FromBody] AddKnowledgeDto dto)
         {
             //知识处理逻辑
-            var knowId = await _knowledgeDomainService.KnowledgeAdd(dto, HttpContext.RequestAborted);
+            var knowledgeId = await _knowledgeDomainService.KnowledgeAdd(dto, HttpContext.RequestAborted);
             //处理流程
-            if (!string.IsNullOrEmpty(knowId))
+            if (!string.IsNullOrEmpty(knowledgeId))
             {
-                KnowledgeWorkFlow workFlow = new()
-                {
-                    KnowledgeId = knowId,
-                    WorkflowModuleStatus = EKnowledgeApplyType.Add,
-                    WorkFlowApplyStatus = EKnowledgeWorkFlowStatus.Auditing
-                };
-                var workId = await _knowledgeWorkFlowRepository.AddAsync(workFlow);
-
                 //调用流程创建
-                var workFlowId = await _workflowApplication.StartWorkflowAsync(dto.StartWorkflowDto, workId, HttpContext.RequestAborted);
-                if (string.IsNullOrEmpty(workFlowId))
-                {
-                    //创建流程失败
-                    await _knowledgeRepository.RemoveAsync(p => p.Id == knowId, false, HttpContext.RequestAborted);
-                    await _knowledgeWorkFlowRepository.RemoveAsync(p => p.Id == workFlow.Id, false, HttpContext.RequestAborted);
-                }
+                var workFlowId = await _workflowApplication.StartWorkflowAsync(dto.StartWorkflowDto, HttpContext.RequestAborted);
+
+                //知识审批主表
+                await _knowledgeDomainService.AddWorkFlow(knowledgeId, workFlowId, EKnowledgeApplyType.Add, HttpContext.RequestAborted);
+
+                //修改流程ID
+                await _knowledgeDomainService.UpdateWorkFlowId(knowledgeId, workFlowId, HttpContext.RequestAborted);
+
             }
-            return knowId;
+            return knowledgeId;
         }
 
         /// <summary>
@@ -222,21 +216,15 @@ namespace Hotline.Api.Controllers
             var knowId = await _knowledgeDomainService.KnowledgeUpdate(dto, HttpContext.RequestAborted);
             if (!string.IsNullOrEmpty(knowId))
             {
-                KnowledgeWorkFlow workFlow = new()
-                {
-                    KnowledgeId = knowId,
-                    WorkflowModuleStatus = EKnowledgeApplyType.Update,
-                    WorkFlowApplyStatus = EKnowledgeWorkFlowStatus.Auditing
-                };
-                var workId = await _knowledgeWorkFlowRepository.AddAsync(workFlow);
-                //知识更新流程创建
-                var workFlowId = await _workflowApplication.StartWorkflowAsync(dto.StartWorkflowDto, workId, HttpContext.RequestAborted);
-                if (string.IsNullOrEmpty(workFlowId))
-                {
-                    //创建流程失败
-                    await _knowledgeRepository.RemoveAsync(p => p.Id == knowId, false, HttpContext.RequestAborted);
-                    await _knowledgeWorkFlowRepository.RemoveAsync(p => p.Id == workFlow.Id, false, HttpContext.RequestAborted);
-                }
+                //调用流程创建
+                var workFlowId = await _workflowApplication.StartWorkflowAsync(dto.StartWorkflowDto, HttpContext.RequestAborted);
+
+                //知识审批主表
+                await _knowledgeDomainService.AddWorkFlow(knowId, workFlowId, EKnowledgeApplyType.Update, HttpContext.RequestAborted);
+
+                //修改流程ID
+                await _knowledgeDomainService.UpdateWorkFlowId(knowId, workFlowId, HttpContext.RequestAborted);
+
             }
         }
 
@@ -253,19 +241,21 @@ namespace Hotline.Api.Controllers
             var know = await _knowledgeRepository.GetAsync(Id, HttpContext.RequestAborted);
             if (know != null && know.IsDeleted == false)
             {
-                KnowledgeWorkFlow workFlow = new()
-                {
-                    KnowledgeId = know.Id,
-                    WorkflowModuleStatus = EKnowledgeApplyType.Delete,
-                    WorkFlowApplyStatus = EKnowledgeWorkFlowStatus.Auditing
-                };
-                var workId = await _knowledgeWorkFlowRepository.AddAsync(workFlow);
                 //验证是否已经发起过知识删除流程
-                var exists = _knowledgeWorkFlowRepository.GetAsync(p => p.KnowledgeId == know.Id && p.WorkflowModuleStatus == EKnowledgeApplyType.Delete);//await _workflowDomainService.ExsitsAsync(WorkflowModuleConsts.KnowledgeDelete, Id, HttpContext.RequestAborted);
+                var exists = _knowledgeWorkFlowRepository.GetAsync(p => p.KnowledgeId == know.Id && p.WorkflowModuleStatus == EKnowledgeApplyType.Delete
+                && (p.WorkFlowApplyStatus != EKnowledgeWorkFlowStatus.Success || p.WorkFlowApplyStatus != EKnowledgeWorkFlowStatus.Failed));
                 if (exists != null)
                     throw UserFriendlyException.SameMessage($"该知识已发起过{WorkflowModule.Modules[WorkflowModuleConsts.KnowledgeDelete]}流程");
+
                 //调用流程创建
-                await _workflowApplication.StartWorkflowAsync(workDto, workId, HttpContext.RequestAborted);
+                var workFlowId = await _workflowApplication.StartWorkflowAsync(workDto, HttpContext.RequestAborted);
+
+                //知识审批主表
+                await _knowledgeDomainService.AddWorkFlow(know.Id, workFlowId, EKnowledgeApplyType.Delete, HttpContext.RequestAborted);
+
+                ////修改知识对应流程
+                //know.WorkflowId = workFlowId;
+                //await _knowledgeRepository.UpdateAsync(know, HttpContext.RequestAborted);
             }
             else
                 throw UserFriendlyException.SameMessage("知识删除失败");
@@ -314,7 +304,16 @@ namespace Hotline.Api.Controllers
                 throw UserFriendlyException.SameMessage("知识上架失败");
         }
 
-
+        /// <summary>
+        /// 撤销
+        /// </summary>
+        /// <param name="workFlowId"></param>
+        /// <returns></returns>
+        [HttpPut("revoke")]
+        public async Task KnowledgeRevoke(string workFlowId)
+        {
+            await _knowledgeDomainService.KnowledgeRevoke(workFlowId, HttpContext.RequestAborted);
+        }
         #endregion
 
         #region 知识列表
@@ -419,10 +418,10 @@ namespace Hotline.Api.Controllers
                 .Includes(it => it.Knowledge.User)
                 .Includes(it => it.Knowledge.SystemOrganize)
                 .Includes(it => it.Knowledge.KnowledgeType)
-                .Includes(it=>it.Workflow)
+                .Includes(it => it.Workflow)
 
-                .WhereIF(pagedDto.EKnowledgeApplyType.HasValue, d => d.WorkflowModuleStatus== pagedDto.EKnowledgeApplyType)
-                .WhereIF(pagedDto.EKnowledgeWorkFlowStatus.HasValue, d=>d.WorkFlowApplyStatus == pagedDto.EKnowledgeWorkFlowStatus)
+                .WhereIF(pagedDto.EKnowledgeApplyType.HasValue, d => d.WorkflowModuleStatus == pagedDto.EKnowledgeApplyType)
+                .WhereIF(pagedDto.EKnowledgeWorkFlowStatus.HasValue, d => d.WorkFlowApplyStatus == pagedDto.EKnowledgeWorkFlowStatus)
                 .WhereIF(!string.IsNullOrEmpty(pagedDto.Keyword), d => d.Knowledge.User.Name.Contains(pagedDto.Keyword!)
                 || d.Knowledge.SystemOrganize.OrgName.Contains(pagedDto.Keyword!)
                 || d.Knowledge.Title.Contains(pagedDto.Keyword!))

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

@@ -38,6 +38,11 @@ namespace Hotline.Share.Dtos.Knowledge
         /// 文档状态
         /// </summary>
         public EKnowledgeStatus Status { get; set; }
+
+        /// <summary>
+        /// 流程ID
+        /// </summary>
+        public string WorkflowId { get; set; }
     }
 
     /// <summary>

src/Hotline/KnowledgeBase/IKnowledgeDomainService.cs

@@ -1,5 +1,6 @@
 using Hotline.FlowEngine.Workflows;
 using Hotline.Share.Dtos.Knowledge;
+using Hotline.Share.Enums.KnowledgeBase;
 
 namespace Hotline.KnowledgeBase
 {
@@ -34,6 +35,33 @@ namespace Hotline.KnowledgeBase
         /// <returns></returns>
         Task KnowledgePvIncreaseAsync(Knowledge know, CancellationToken cancellationToken);
 
+        /// <summary>
+        /// 知识审批主表
+        /// </summary>
+        /// <param name="knowId">知识Id</param>
+        /// <param name="workFlowId">流程ID</param>
+        /// <param name="eKnowledgeApplyType">申请类型</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        Task<string> AddWorkFlow(string knowId, string workFlowId, EKnowledgeApplyType eKnowledgeApplyType, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// 修改流程ID
+        /// </summary>
+        /// <param name="knowledgeId"></param>
+        /// <param name="workFlowId"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        Task UpdateWorkFlowId(string knowledgeId, string workFlowId, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// 撤销
+        /// </summary>
+        /// <param name="workFlowId"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        Task KnowledgeRevoke(string workFlowId, CancellationToken cancellationToken);
+
         /// <summary>
         /// 流程审批完成，处理知识状态
         /// </summary>

src/Hotline/KnowledgeBase/KnowledgeDomainService.cs

@@ -3,6 +3,7 @@ using Hotline.Settings;
 using Hotline.Share.Dtos.Knowledge;
 using Hotline.Share.Enums.KnowledgeBase;
 using MapsterMapper;
+using System.Threading;
 using XF.Domain.Dependency;
 using XF.Domain.Exceptions;
 
@@ -14,6 +15,8 @@ namespace Hotline.KnowledgeBase
         private readonly IKnowledgeTempRepository _knowledgeTempRepository;
         private readonly IMapper _mapper;
         private readonly IKnowledgePVRepository _knowledgePVRepository;
+        private readonly IKnowledgeWorkFlowRepository _knowledgeWorkFlowRepository;
+        private readonly IWorkflowDomainService _workflowDomainService;
 
         /// <summary>
         /// 
@@ -22,12 +25,17 @@ namespace Hotline.KnowledgeBase
         /// <param name="knowledgeTempRepository"></param>
         /// <param name="mapper"></param>
         /// <param name="knowledgePVRepository"></param>
-        public KnowledgeDomainService(IKnowledgeRepository knowledgeRepository, IKnowledgeTempRepository knowledgeTempRepository, IMapper mapper, IKnowledgePVRepository knowledgePVRepository)
+        /// <param name="knowledgeWorkFlowRepository"></param>
+        /// <param name="workflowDomainService"></param>
+        public KnowledgeDomainService(IKnowledgeRepository knowledgeRepository, IKnowledgeTempRepository knowledgeTempRepository, IMapper mapper, IKnowledgePVRepository knowledgePVRepository, IKnowledgeWorkFlowRepository knowledgeWorkFlowRepository
+            IWorkflowDomainService workflowDomainService)
         {
             _knowledgeRepository = knowledgeRepository;
             _mapper = mapper;
             _knowledgeTempRepository = knowledgeTempRepository;
             _knowledgePVRepository = knowledgePVRepository;
+            _knowledgeWorkFlowRepository = knowledgeWorkFlowRepository;
+            _workflowDomainService = workflowDomainService;
         }
 
         /// <summary>
@@ -66,6 +74,40 @@ namespace Hotline.KnowledgeBase
             await _knowledgeRepository.UpdateAsync(know, cancellationToken);
         }
 
+        /// <summary>
+        /// 知识审批主表
+        /// </summary>
+        /// <param name="knowId">知识Id</param>
+        /// <param name="workFlowId">流程ID</param>
+        /// <param name="eKnowledgeApplyType">申请类型</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public async Task<string> AddWorkFlow(string knowId, string workFlowId, EKnowledgeApplyType eKnowledgeApplyType, CancellationToken cancellationToken)
+        {
+            KnowledgeWorkFlow workFlow = new()
+            {
+                KnowledgeId = knowId,
+                WorkflowModuleStatus = eKnowledgeApplyType,
+                WorkFlowApplyStatus = EKnowledgeWorkFlowStatus.Auditing,
+                WorkflowId = workFlowId
+            };
+            return await _knowledgeWorkFlowRepository.AddAsync(workFlow, cancellationToken);
+        }
+
+        /// <summary>
+        /// 修改流程ID
+        /// </summary>
+        /// <param name="knowledgeId"></param>
+        /// <param name="workFlowId"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public async Task UpdateWorkFlowId(string knowledgeId, string workFlowId, CancellationToken cancellationToken)
+        {
+            var knowledge = await _knowledgeRepository.GetAsync(knowledgeId, cancellationToken);
+            knowledge.WorkflowId = workFlowId;
+            await _knowledgeRepository.UpdateAsync(knowledge, cancellationToken);
+        }
+
         /// <summary>
         /// 知识库-新增
         /// </summary>
@@ -116,6 +158,43 @@ namespace Hotline.KnowledgeBase
 
         }
 
+        /// <summary>
+        /// 撤销
+        /// </summary>
+        /// <param name="workFlowId"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public async Task KnowledgeRevoke(string workFlowId, CancellationToken cancellationToken)
+        {
+            var knowWorkFlow = await _knowledgeWorkFlowRepository.GetAsync(p => p.WorkflowId == workFlowId, cancellationToken);
+            if (knowWorkFlow is null)
+                throw UserFriendlyException.SameMessage("无效知识审批");
+            if(knowWorkFlow.WorkFlowApplyStatus!= EKnowledgeWorkFlowStatus.Auditing)
+                throw UserFriendlyException.SameMessage("只有审批中的知识才能撤回！");
+
+            knowWorkFlow.WorkFlowApplyStatus = EKnowledgeWorkFlowStatus.Revoke;
+            await _knowledgeWorkFlowRepository.UpdateAsync(knowWorkFlow);
+
+            switch (knowWorkFlow.WorkflowModuleStatus)
+            {
+                case EKnowledgeApplyType.Add:
+                case EKnowledgeApplyType.Update:
+                    //查询知识
+                    var knowledge = await _knowledgeRepository.GetAsync(p => p.WorkflowId == workFlowId, cancellationToken);
+                    if (knowledge != null)
+                    {
+                        //将知识保存到草稿箱
+                        var tempKnow = _mapper.Map<KnowledgeTemp>(knowledge);
+                        await _knowledgeTempRepository.AddAsync(tempKnow, cancellationToken);
+                        //删除现有知识
+                        await _knowledgeRepository.RemoveAsync(knowledge, true, cancellationToken);
+                    }
+                    break;
+            }
+            //调用终止流程
+            await _workflowDomainService.TerminateAsync(workFlowId, cancellationToken);
+        }
+
         /// <summary>
         /// 流程审批完成，处理知识状态
         /// </summary>
@@ -125,9 +204,17 @@ namespace Hotline.KnowledgeBase
         /// <exception cref="UserFriendlyException"></exception>
         public async Task EndWorkKnowledge(Workflow workflow, CancellationToken cancellationToken)
         {
-            var knowledge = await _knowledgeRepository.GetAsync(workflow.ExternalId, cancellationToken);
+            var knowledge = await _knowledgeRepository.GetAsync(p => p.WorkflowId == workflow.Id, cancellationToken);
             if (knowledge == null)
                 throw new UserFriendlyException($"知识查询失败, workflowId: {workflow.Id}", "无效流程编号");
+
+            //修改主表审批状态
+            var workFlow = await _knowledgeWorkFlowRepository.GetAsync(p => p.WorkflowId == workflow.Id, cancellationToken);
+            if (workFlow != null)
+            {
+                workFlow.WorkFlowApplyStatus = EKnowledgeWorkFlowStatus.Success;
+                await _knowledgeWorkFlowRepository.UpdateAsync(workFlow, cancellationToken);
+            }
             switch (workflow.ModuleCode)
             {
                 case WorkflowModuleConsts.KnowledgeAdd://新增
@@ -153,69 +240,19 @@ namespace Hotline.KnowledgeBase
                     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);
+                    //知识先下架，在删除                                       
+                    knowledge.Status = EKnowledgeStatus.OffShelf;
+                    knowledge.OffShelfTime = System.DateTime.Now;
+                    knowledge.WorkflowId = workflow.Id;
+                    await _knowledgeRepository.UpdateAsync(knowledge);
                     //删除知识
                     await _knowledgeRepository.RemoveAsync(p => p.Code == knowledge.Code, true, cancellationToken);
                     break;
             }
         }
 
-        /// <summary>
-        /// 交换数据、为了保持浏览记录等数据的存在
-        /// </summary>
-        /// <param name="knowledge"></param>
-        /// <returns></returns>
-        private async Task KnowledgeUpdate(Knowledge knowledge)
-        {
-            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)
-            {
-                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);
-            }
-        }
-
     }
 }