修改查询，优化部分功能

src/Hotline.Api/Controllers/KnowledgeApplyController.cs

@@ -1,4 +1,5 @@
-using Hotline.KnowledgeBase;
+using Hotline.Application.Knowledge;
+using Hotline.KnowledgeBase;
 using Hotline.Permissions;
 using Hotline.Repository.SqlSugar.Extensions;
 using Hotline.Share.Dtos;
@@ -21,6 +22,7 @@ namespace Hotline.Api.Controllers
         private readonly IKnowledgeApplyRepository _knowledgeApplyRepository;
         private readonly ISessionContext _sessionContext;
         private readonly IMapper _mapper;
+        private readonly IKnowApplication _knowApplication;
 
         /// <summary>
         /// 
@@ -29,12 +31,15 @@ namespace Hotline.Api.Controllers
         /// <param name="knowledgeApplyRepository"></param>
         /// <param name="sessionContext"></param>
         /// <param name="mapper"></param>
-        public KnowledgeApplyController(IKnowledgeRepository knowledgeRepository, IKnowledgeApplyRepository knowledgeApplyRepository, ISessionContext sessionContext, IMapper mapper)
+        /// <param name="knowApplication"></param>
+        public KnowledgeApplyController(IKnowledgeRepository knowledgeRepository, IKnowledgeApplyRepository knowledgeApplyRepository, ISessionContext sessionContext
+            , IMapper mapper, IKnowApplication knowApplication)
         {
             _knowledgeRepository = knowledgeRepository;
             _knowledgeApplyRepository = knowledgeApplyRepository;
             _sessionContext = sessionContext;
             _mapper = mapper;
+            _knowApplication = knowApplication;
         }
 
         /// <summary>
@@ -57,7 +62,7 @@ namespace Hotline.Api.Controllers
         /// <param name="dto"></param>
         /// <returns></returns>
         [Permission(EPermission.KnowledgeUpdateAdd)]
-        [HttpPost("apply-update")]
+        [HttpPut("apply-update")]
         public async Task UpdateAdd([FromBody] UpdateKnowledgeApplyDto dto)
         {
             var ka = _mapper.Map<KnowledgeApply>(dto);
@@ -70,7 +75,7 @@ namespace Hotline.Api.Controllers
         /// <param name="Id"></param>
         /// <returns></returns>
         [Permission(EPermission.KnowApplyHandle)]
-        [HttpPost("apply-handle")]
+        [HttpPut("apply-handle")]
         public async Task ApplyHandle(string Id)
         {
             //查询申请信息
@@ -89,7 +94,7 @@ namespace Hotline.Api.Controllers
         /// <param name="Id"></param>
         /// <returns></returns>
         [Permission(EPermission.KnowledgeApplyRevoke)]
-        [HttpPost("apply-handle/{Id}")]
+        [HttpPut("apply-handle/{Id}")]
         public async Task ApplyRevoke(string Id)
         {
             var handle = await _knowledgeApplyRepository.GetAsync(Id, HttpContext.RequestAborted);
@@ -105,7 +110,7 @@ namespace Hotline.Api.Controllers
         /// <param name="Id"></param>
         /// <returns></returns>
         [Permission(EPermission.KnowledgeApplyReturn)]
-        [HttpPost("apply-return")]
+        [HttpPut("return")]
         public async Task ApplyReturn(string Id)
         {
             //查询申请信息
@@ -116,12 +121,27 @@ namespace Hotline.Api.Controllers
             await _knowledgeApplyRepository.UpdateAsync(handle, HttpContext.RequestAborted);
         }
 
+        /// <summary>
+        /// 删除申请
+        /// </summary>
+        /// <param name="Id"></param>
+        /// <returns></returns>
+        [Permission(EPermission.KnowledgeApplyDelete)]
+        [HttpDelete("delete")]
+        public async Task ApplyDelete(string Id)
+        {
+            var handle = await _knowledgeApplyRepository.GetAsync(Id, HttpContext.RequestAborted);
+            if (handle is null)
+                throw UserFriendlyException.SameMessage("申请不存在");
+            await _knowledgeApplyRepository.RemoveAsync(handle, false, HttpContext.RequestAborted);
+        }
+
         /// <summary>
         /// 知识申请-查询详情
         /// </summary>
         /// <param name="Id"></param>
         /// <returns></returns>
-        [HttpGet("apply-info")]
+        [HttpGet("info/{Id}")]
         public async Task<DataKnowledgeApplyDto> ApplyInfo(string Id)
         {
             var handle = await _knowledgeApplyRepository.GetAsync(Id, HttpContext.RequestAborted);
@@ -146,236 +166,25 @@ namespace Hotline.Api.Controllers
         /// </summary>
         /// <returns></returns>
         [Permission(EPermission.KnowledgeAllApply)]
-        [HttpPost("apply-allapply")]
-        public async Task<PagedDto<KnowledgeApply>> AllApply([FromQuery] KnowledgeApplyPagedDto dto)
-        {
-            var (total, items) = await _knowledgeApplyRepository
-                  .Queryable()
-                  .Includes(it => it.User)
-                  .Includes(it => it.SystemOrganize)
-                  .Where(d => d.CreatorId == _sessionContext.RequiredUserId)
-                  .WhereIF(!string.IsNullOrEmpty(dto.ApplyType), d => d.KnowledgeApplyType.ToString() == dto.ApplyType)
-                  .WhereIF(!string.IsNullOrEmpty(dto.IsOvertime) && dto.IsOvertime == "0", d => d.ExpiredTime < DateTime.Now)
-                  .WhereIF(!string.IsNullOrEmpty(dto.IsOvertime) && dto.IsOvertime == "1", d => d.ExpiredTime >= DateTime.Now)
-                  .WhereIF(dto.StartTime != null, d => d.CreationTime >= dto.StartTime)
-                  .WhereIF(dto.EndTime != null, d => d.CreationTime <= dto.EndTime)
-                  .OrderByDescending(p => p.CreationTime)
-                  .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
-
-            return new PagedDto<KnowledgeApply>(total, _mapper.Map<IReadOnlyList<KnowledgeApply>>(items));
-        }
-
-        /// <summary>
-        /// 我的知识申请--处理中
-        /// </summary>
-        /// <param name="dto"></param>
-        /// <returns></returns>
-        [Permission(EPermission.KnowledgeProcessingApply)]
-        [HttpPost("apply-processingapply")]
-        public async Task<PagedDto<KnowledgeApply>> ProcessingApply([FromQuery] KnowledgeApplyPagedDto dto)
-        {
-            var (total, items) = await _knowledgeApplyRepository
-               .Queryable()
-               .Includes(it => it.User)
-               .Includes(it => it.SystemOrganize)
-               .Where(d => d.CreatorId == _sessionContext.RequiredUserId && d.Status == EKnowledgeApplyStatus.Handling)
-               .WhereIF(!string.IsNullOrEmpty(dto.ApplyType), d => d.KnowledgeApplyType.ToString() == dto.ApplyType)
-               .WhereIF(!string.IsNullOrEmpty(dto.IsOvertime) && dto.IsOvertime == "0", d => d.ExpiredTime < DateTime.Now)
-               .WhereIF(!string.IsNullOrEmpty(dto.IsOvertime) && dto.IsOvertime == "1", d => d.ExpiredTime >= DateTime.Now)
-               .WhereIF(dto.StartTime != null, d => d.CreationTime >= dto.StartTime)
-               .WhereIF(dto.EndTime != null, d => d.CreationTime <= dto.EndTime)
-               .OrderByDescending(p => p.CreationTime)
-               .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
-
-            return new PagedDto<KnowledgeApply>(total, _mapper.Map<IReadOnlyList<KnowledgeApply>>(items));
-        }
-
-        /// <summary>
-        /// 我的知识申请--已完成
-        /// </summary>
-        /// <param name="dto"></param>
-        /// <returns></returns>
-        [Permission(EPermission.KnowledgeEndApply)]
-        [HttpPost("apply-endapply")]
-        public async Task<PagedDto<KnowledgeApply>> EndApply([FromQuery] KnowledgeApplyPagedDto dto)
-        {
-            var (total, items) = await _knowledgeApplyRepository
-              .Queryable()
-              .Includes(it => it.User)
-              .Includes(it => it.SystemOrganize)
-              .Where(d => d.CreatorId == _sessionContext.RequiredUserId && d.Status == EKnowledgeApplyStatus.Succeed)
-              .WhereIF(!string.IsNullOrEmpty(dto.ApplyType), d => d.KnowledgeApplyType.ToString() == dto.ApplyType)
-              .WhereIF(!string.IsNullOrEmpty(dto.IsOvertime) && dto.IsOvertime == "0", d => d.ExpiredTime < DateTime.Now)
-              .WhereIF(!string.IsNullOrEmpty(dto.IsOvertime) && dto.IsOvertime == "1", d => d.ExpiredTime >= DateTime.Now)
-              .WhereIF(dto.StartTime != null, d => d.CreationTime >= dto.StartTime)
-              .WhereIF(dto.EndTime != null, d => d.CreationTime <= dto.EndTime)
-              .OrderByDescending(p => p.CreationTime)
-              .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
-
-            return new PagedDto<KnowledgeApply>(total, _mapper.Map<IReadOnlyList<KnowledgeApply>>(items));
-        }
-
-        /// <summary>
-        /// 我的知识申请--退回
-        /// </summary>
-        /// <param name="dto"></param>
-        /// <returns></returns>
-        [Permission(EPermission.KnowledgeReturnApply)]
-        [HttpPost("apply-returnapply")]
-        public async Task<PagedDto<KnowledgeApply>> ReturnApply([FromQuery] KnowledgeApplyPagedDto dto)
+        [HttpGet()]
+        public async Task<PagedDto<KnowledgeApply>> GetApplyList([FromQuery] KnowledgeApplyPagedDto dto)
         {
-            var (total, items) = await _knowledgeApplyRepository
-              .Queryable()
-              .Includes(it => it.User)
-              .Includes(it => it.SystemOrganize)
-              .Where(d => d.CreatorId == _sessionContext.RequiredUserId && d.Status == EKnowledgeApplyStatus.Failed)
-              .WhereIF(!string.IsNullOrEmpty(dto.ApplyType), d => d.KnowledgeApplyType.ToString() == dto.ApplyType)
-              .WhereIF(!string.IsNullOrEmpty(dto.IsOvertime) && dto.IsOvertime == "0", d => d.ExpiredTime < DateTime.Now)
-              .WhereIF(!string.IsNullOrEmpty(dto.IsOvertime) && dto.IsOvertime == "1", d => d.ExpiredTime >= DateTime.Now)
-              .WhereIF(dto.StartTime != null, d => d.CreationTime >= dto.StartTime)
-              .WhereIF(dto.EndTime != null, d => d.CreationTime <= dto.EndTime)
-              .OrderByDescending(p => p.CreationTime)
-              .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
-
-            return new PagedDto<KnowledgeApply>(total, _mapper.Map<IReadOnlyList<KnowledgeApply>>(items));
+            return await _knowApplication.GetApplyList(dto, HttpContext.RequestAborted);
         }
 
-        /// <summary>
-        /// 我的知识申请--已撤销
-        /// </summary>
-        /// <param name="dto"></param>
-        /// <returns></returns>
-        [Permission(EPermission.KnowledgeRevokeApply)]
-        [HttpPost("apply-revokeapply")]
-        public async Task<PagedDto<KnowledgeApply>> RevokeApply([FromQuery] KnowledgeApplyPagedDto dto)
-        {
-            var (total, items) = await _knowledgeApplyRepository
-              .Queryable()
-              .Includes(it => it.User)
-              .Includes(it => it.SystemOrganize)
-              .Where(d => d.CreatorId == _sessionContext.RequiredUserId && d.Status == EKnowledgeApplyStatus.Revert)
-              .WhereIF(!string.IsNullOrEmpty(dto.ApplyType), d => d.KnowledgeApplyType.ToString() == dto.ApplyType)
-              .WhereIF(!string.IsNullOrEmpty(dto.IsOvertime) && dto.IsOvertime == "0", d => d.ExpiredTime < DateTime.Now)
-              .WhereIF(!string.IsNullOrEmpty(dto.IsOvertime) && dto.IsOvertime == "1", d => d.ExpiredTime >= DateTime.Now)
-              .WhereIF(dto.StartTime != null, d => d.CreationTime >= dto.StartTime)
-              .WhereIF(dto.EndTime != null, d => d.CreationTime <= dto.EndTime)
-              .OrderByDescending(p => p.CreationTime)
-              .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
-
-            return new PagedDto<KnowledgeApply>(total, _mapper.Map<IReadOnlyList<KnowledgeApply>>(items));
-        }
         #endregion
 
         #region 知识申请处理查询
         /// <summary>
-        /// 申请处理--全部
+        /// 申请处理查询
         /// </summary>
         /// <returns></returns>
-        [HttpPost("apply-allhandle")]
+        [HttpGet("handlelist")]
         public async Task<PagedDto<KnowledgeApplyPageDto>> AllHandle([FromQuery] KnowledgeHandlePagedDto dto)
         {
-            var (total, items) = await _knowledgeApplyRepository
-                 .Queryable()
-                 .Includes(it => it.User)
-                 .Includes(it => it.SystemOrganize)
-                 .Where(p => p.DepartmentCode == _sessionContext.RequiredOrgCode)
-                 .WhereIF(!string.IsNullOrEmpty(dto.CreateUserName), d => d.User.Name.Contains(dto.CreateUserName!))
-                 .WhereIF(!string.IsNullOrEmpty(dto.CreateBMName), d => d.SystemOrganize.OrgName.Contains(dto.CreateBMName!))
-                 .WhereIF(!string.IsNullOrEmpty(dto.ApplyType), d => d.KnowledgeApplyType.ToString() == dto.ApplyType)
-                 .WhereIF(!string.IsNullOrEmpty(dto.IsOvertime) && dto.IsOvertime == "0", d => d.ExpiredTime < DateTime.Now)
-                 .WhereIF(!string.IsNullOrEmpty(dto.IsOvertime) && dto.IsOvertime == "1", d => d.ExpiredTime >= DateTime.Now)
-                 .WhereIF(dto.StartTime != null, d => d.CreationTime >= dto.StartTime)
-                 .WhereIF(dto.EndTime != null, d => d.CreationTime <= dto.EndTime)
-                 .OrderByDescending(p => p.CreationTime)
-                 .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
-
-            return new PagedDto<KnowledgeApplyPageDto>(total, _mapper.Map<IReadOnlyList<KnowledgeApplyPageDto>>(items));
-        }
-
-        /// <summary>
-        /// 申请处理--处理中
-        /// </summary>
-        /// <param name="dto"></param>
-        /// <returns></returns>
-        [Permission(EPermission.KnowledgeProcessingHandle)]
-        [HttpPost("apply-processinghandle")]
-        public async Task<PagedDto<KnowledgeApplyPageDto>> ProcessingHandle([FromQuery] KnowledgeHandlePagedDto dto)
-        {
-            var (total, items) = await _knowledgeApplyRepository
-                .Queryable(false)
-                .Includes(it => it.User)
-                .Includes(it => it.SystemOrganize)
-                .Where(p => p.DepartmentCode == _sessionContext.RequiredOrgCode)
-                .Where(p => p.Status == EKnowledgeApplyStatus.Handling)
-                .WhereIF(!string.IsNullOrEmpty(dto.CreateUserName), d => d.User.Name.Contains(dto.CreateUserName!))
-                .WhereIF(!string.IsNullOrEmpty(dto.CreateBMName), d => d.SystemOrganize.OrgName.Contains(dto.CreateBMName!))
-                .WhereIF(!string.IsNullOrEmpty(dto.ApplyType), d => d.KnowledgeApplyType.ToString() == dto.ApplyType)
-                .WhereIF(!string.IsNullOrEmpty(dto.IsOvertime) && dto.IsOvertime == "0", d => d.ExpiredTime < DateTime.Now)
-                .WhereIF(!string.IsNullOrEmpty(dto.IsOvertime) && dto.IsOvertime == "1", d => d.ExpiredTime >= DateTime.Now)
-                .WhereIF(dto.StartTime != null, d => d.CreationTime >= dto.StartTime)
-                .WhereIF(dto.EndTime != null, d => d.CreationTime <= dto.EndTime)
-                .OrderByDescending(p => p.CreationTime)
-                .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
-
-            return new PagedDto<KnowledgeApplyPageDto>(total, _mapper.Map<IReadOnlyList<KnowledgeApplyPageDto>>(items));
+            return await _knowApplication.GetApplyHandleList(dto, HttpContext.RequestAborted);
         }
 
-        /// <summary>
-        /// 申请处理--已完成
-        /// </summary>
-        /// <param name="dto"></param>
-        /// <returns></returns>
-        [Permission(EPermission.KnowledgeEndHandle)]
-        [HttpPost("apply-endhandle")]
-        public async Task<PagedDto<KnowledgeApplyPageDto>> EndHandle([FromQuery] KnowledgeHandlePagedDto dto)
-        {
-            var (total, items) = await _knowledgeApplyRepository
-               .Queryable(false)
-               .Includes(it => it.User)
-               .Includes(it => it.SystemOrganize)
-               .Where(p => p.DepartmentCode == _sessionContext.RequiredOrgCode)
-               .Where(p => p.Status == EKnowledgeApplyStatus.Succeed)
-               .WhereIF(!string.IsNullOrEmpty(dto.CreateUserName), d => d.User.Name.Contains(dto.CreateUserName!))
-               .WhereIF(!string.IsNullOrEmpty(dto.CreateBMName), d => d.SystemOrganize.OrgName.Contains(dto.CreateBMName!))
-               .WhereIF(!string.IsNullOrEmpty(dto.ApplyType), d => d.KnowledgeApplyType.ToString() == dto.ApplyType)
-               .WhereIF(!string.IsNullOrEmpty(dto.IsOvertime) && dto.IsOvertime == "0", d => d.ExpiredTime < DateTime.Now)
-               .WhereIF(!string.IsNullOrEmpty(dto.IsOvertime) && dto.IsOvertime == "1", d => d.ExpiredTime >= DateTime.Now)
-               .WhereIF(dto.StartTime != null, d => d.CreationTime >= dto.StartTime)
-               .WhereIF(dto.EndTime != null, d => d.CreationTime <= dto.EndTime)
-               .OrderByDescending(p => p.CreationTime)
-               .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
-
-            return new PagedDto<KnowledgeApplyPageDto>(total, _mapper.Map<IReadOnlyList<KnowledgeApplyPageDto>>(items));
-        }
-
-        /// <summary>
-        /// 申请处理--退回
-        /// </summary>
-        /// <param name="dto"></param>
-        /// <returns></returns>
-        [Permission(EPermission.KnowledgeReturnHandle)]
-        [HttpPost("apply-returnhandle")]
-        public async Task<PagedDto<KnowledgeApplyPageDto>> ReturnHandle([FromQuery] KnowledgeHandlePagedDto dto)
-        {
-            var (total, items) = await _knowledgeApplyRepository
-               .Queryable(false)
-               .Includes(it => it.User)
-               .Includes(it => it.SystemOrganize)
-               .Where(p => p.DepartmentCode == _sessionContext.RequiredOrgCode)
-               .Where(p => p.Status == EKnowledgeApplyStatus.Failed)
-               .WhereIF(!string.IsNullOrEmpty(dto.CreateUserName), d => d.User.Name.Contains(dto.CreateUserName!))
-               .WhereIF(!string.IsNullOrEmpty(dto.CreateBMName), d => d.SystemOrganize.OrgName.Contains(dto.CreateBMName!))
-               .WhereIF(!string.IsNullOrEmpty(dto.ApplyType), d => d.KnowledgeApplyType.ToString() == dto.ApplyType)
-               .WhereIF(!string.IsNullOrEmpty(dto.IsOvertime) && dto.IsOvertime == "0", d => d.ExpiredTime < DateTime.Now)
-               .WhereIF(!string.IsNullOrEmpty(dto.IsOvertime) && dto.IsOvertime == "1", d => d.ExpiredTime >= DateTime.Now)
-               .WhereIF(dto.StartTime != null, d => d.CreationTime >= dto.StartTime)
-               .WhereIF(dto.EndTime != null, d => d.CreationTime <= dto.EndTime)
-               .OrderByDescending(p => p.CreationTime)
-               .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
-
-            return new PagedDto<KnowledgeApplyPageDto>(total, _mapper.Map<IReadOnlyList<KnowledgeApplyPageDto>>(items));
-
-        }
         #endregion
     }
 }

src/Hotline.Api/Controllers/KnowledgeCommonController.cs

@@ -15,7 +15,7 @@ namespace Hotline.Api.Controllers
     {
         private readonly IKnowledgeTypeRepository _knowledgeTypeRepository;
         private readonly IKnowledgeRepository _knowledgeRepository;
-        private readonly IKnowledgeTypeService _knowledgeTypeService;
+        private readonly IKnowledgeTypeDomainService _knowledgeTypeDomainService;
         private readonly IKnowledgeStandardRepository _knowledgeStandardRepository;
         private readonly IMapper _mapper;
 
@@ -24,16 +24,16 @@ namespace Hotline.Api.Controllers
         /// </summary>
         /// <param name="knowledgeRepository"></param>
         /// <param name="knowledgeTypeRepository"></param>
-        /// <param name="knowledgeTypeService"></param>
+        /// <param name="knowledgeTypeDomainService"></param>
         /// <param name="knowledgeStandardRepository"></param>
         /// <param name="mapper"></param>
-        public KnowledgeCommonController(IKnowledgeRepository knowledgeRepository, IKnowledgeTypeRepository knowledgeTypeRepository, IKnowledgeTypeService knowledgeTypeService,
+        public KnowledgeCommonController(IKnowledgeRepository knowledgeRepository, IKnowledgeTypeRepository knowledgeTypeRepository, IKnowledgeTypeDomainService knowledgeTypeDomainService,
             IKnowledgeStandardRepository knowledgeStandardRepository,
             IMapper mapper)
         {
             _knowledgeRepository = knowledgeRepository;
             _knowledgeTypeRepository = knowledgeTypeRepository;
-            _knowledgeTypeService = knowledgeTypeService;
+            _knowledgeTypeDomainService = knowledgeTypeDomainService;
             _knowledgeStandardRepository = knowledgeStandardRepository;
             _mapper = mapper;
         }
@@ -46,10 +46,10 @@ namespace Hotline.Api.Controllers
         /// <param name="dto"></param>
         /// <returns></returns>
         [Permission(EPermission.AddKnowledgeType)]
-        [HttpPost("type-add")]
+        [HttpPost("add")]
         public async Task<string> TypeAdd([FromBody] AddKnowledgeTypeDto dto)
         {
-            return await _knowledgeTypeService.TypeAdd(dto, HttpContext.RequestAborted);
+            return await _knowledgeTypeDomainService.TypeAdd(dto, HttpContext.RequestAborted);
         }
 
         /// <summary>
@@ -58,10 +58,10 @@ namespace Hotline.Api.Controllers
         /// <param name="dto"></param>
         /// <returns></returns>
         [Permission(EPermission.UpdateKnowledgeType)]
-        [HttpPost("type-update")]
+        [HttpPut("update")]
         public async Task TypeUpdate([FromBody] UpdateKnowledgeTypeDto dto)
         {
-            await _knowledgeTypeService.TypeUpdate(dto, HttpContext.RequestAborted);
+            await _knowledgeTypeDomainService.TypeUpdate(dto, HttpContext.RequestAborted);
         }
 
         /// <summary>
@@ -70,10 +70,10 @@ namespace Hotline.Api.Controllers
         /// <param name="Id"></param>
         /// <param name="ParentId"></param>
         /// <returns></returns>
-        [HttpGet("type-init")]
+        [HttpGet("init")]
         public async Task<KnowledgeTypeDto> TypeInit(string Id, string ParentId)
         {
-            return await _knowledgeTypeService.TypeInit(Id, ParentId, HttpContext.RequestAborted);
+            return await _knowledgeTypeDomainService.TypeInit(Id, ParentId, HttpContext.RequestAborted);
         }
 
         /// <summary>
@@ -81,7 +81,7 @@ namespace Hotline.Api.Controllers
         /// </summary>
         /// <param name="Id"></param>
         /// <returns></returns>
-        [HttpGet("type-info")]
+        [HttpGet("info")]
         public async Task<KnowledgeType> TypeInfo(string Id)
         {
             var types = await _knowledgeTypeRepository.GetAsync(Id, HttpContext.RequestAborted);
@@ -96,10 +96,10 @@ namespace Hotline.Api.Controllers
         /// <param name="Id"></param>
         /// <returns></returns>
         [Permission(EPermission.RemoveKnowledgeType)]
-        [HttpDelete("type-delete")]
+        [HttpDelete("delete")]
         public async Task TypeDelete(string Id)
         {
-            await _knowledgeTypeService.TypeDelete(Id, HttpContext.RequestAborted);
+            await _knowledgeTypeDomainService.TypeDelete(Id, HttpContext.RequestAborted);
         }
 
         /// <summary>
@@ -108,10 +108,10 @@ namespace Hotline.Api.Controllers
         /// <param name="Id"></param>
         /// <returns></returns>
         [Permission(EPermission.KnowledgeTypeChangeState)]
-        [HttpGet("type-changestate")]
+        [HttpPut("changestate")]
         public async Task TypeChangeState(string Id)
         {
-            await _knowledgeTypeService.TypeChangeState(Id, HttpContext.RequestAborted);
+            await _knowledgeTypeDomainService.TypeChangeState(Id, HttpContext.RequestAborted);
         }
 
         /// <summary>
@@ -120,10 +120,10 @@ namespace Hotline.Api.Controllers
         /// <param name="Id"></param>
         /// <returns></returns>
         [Permission(EPermission.KnowledgeTypeChangeStateAndOffShelf)]
-        [HttpGet("type-changestateandoffshelf")]
+        [HttpPut("changestateandoffshelf")]
         public async Task TypeChangeStateAndOffShelf(string Id)
         {
-            await _knowledgeTypeService.TypeChangeStateAndOffShelf(Id, HttpContext.RequestAborted);
+            await _knowledgeTypeDomainService.TypeChangeStateAndOffShelf(Id, HttpContext.RequestAborted);
         }
 
         /// <summary>
@@ -131,8 +131,8 @@ namespace Hotline.Api.Controllers
         /// </summary>
         /// <returns></returns>
         [Permission(EPermission.KnowledgeTypeMange)]
-        [HttpPost("type-treelist")]
-        public async Task<List<KnowledgeType>> GetTreeList(string id)
+        [HttpGet("treelist")]
+        public async Task<List<KnowledgeType>> GetTreeList()
         {
             return await _knowledgeTypeRepository.GetTree(Guid.Empty.ToString());
         }
@@ -145,7 +145,7 @@ namespace Hotline.Api.Controllers
         /// </summary>
         /// <param name="Id"></param>
         /// <returns></returns>
-        [HttpGet("standard-info")]
+        [HttpGet("standard-info/{Id}")]
         public async Task<KnowledgeStandard> StandardInfo(string Id)
         {
             if (string.IsNullOrEmpty(Id))
@@ -183,7 +183,6 @@ namespace Hotline.Api.Controllers
         public async Task StandardAdd([FromBody] AddKnowledgeStandardDto dto)
         {
             var sandard = _mapper.Map<KnowledgeStandard>(dto);
-            sandard.CreationTime = DateTime.Now;
             await _knowledgeStandardRepository.AddAsync(sandard, HttpContext.RequestAborted);
         }
 
@@ -193,7 +192,7 @@ namespace Hotline.Api.Controllers
         /// <param name="dto"></param>
         /// <returns></returns>
         [Permission(EPermission.KnowledgeStandardUpdate)]
-        [HttpPost("standard-update")]
+        [HttpPut("standard-update")]
         public async Task StandardUpdate([FromBody] UpdateKnowledgeStandardDto dto)
         {
             var sandard = _mapper.Map<KnowledgeStandard>(dto);

src/Hotline.Api/Controllers/KnowledgeController.cs

@@ -1,4 +1,5 @@
-using Hotline.KnowledgeBase;
+using Hotline.Application.Knowledge;
+using Hotline.KnowledgeBase;
 using Hotline.Permissions;
 using Hotline.Repository.SqlSugar.Extensions;
 using Hotline.Settings;
@@ -10,6 +11,7 @@ using MapsterMapper;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using SqlSugar;
+using System.Threading;
 using XF.Domain.Authentications;
 using XF.Domain.Exceptions;
 
@@ -23,8 +25,9 @@ namespace Hotline.Api.Controllers
         private readonly IKnowledgeRepository _knowledgeRepository;
         private readonly IKnowledgeTempRepository _knowledgeTempRepository;
         private readonly ISessionContext _sessionContext;
-        private readonly IKnowledgeDomainService _knowledgeService;
+        private readonly IKnowledgeDomainService _knowledgeDomainService;
         private readonly IMapper _mapper;
+        private readonly IKnowApplication _knowApplication;
 
         /// <summary>
         /// 
@@ -34,14 +37,16 @@ namespace Hotline.Api.Controllers
         /// <param name="sessionContext"></param>
         /// <param name="knowledgeDomainService"></param>
         /// <param name="mapper"></param>
+        /// <param name="knowApplication"></param>
         public KnowledgeController(IKnowledgeRepository knowledgeRepository, IKnowledgeTempRepository knowledgeTempRepository,
-           ISessionContext sessionContext, IKnowledgeDomainService knowledgeService, IMapper mapper)
+           ISessionContext sessionContext, IKnowledgeDomainService knowledgeDomainService, IMapper mapper, IKnowApplication knowApplication)
         {
             _knowledgeRepository = knowledgeRepository;
             _knowledgeTempRepository = knowledgeTempRepository;
             _sessionContext = sessionContext;
-            _knowledgeService = knowledgeService;
+            _knowledgeDomainService = knowledgeDomainService;
             _mapper = mapper;
+            _knowApplication = knowApplication;
         }
         #region 草稿箱
         /// <summary>
@@ -49,14 +54,14 @@ namespace Hotline.Api.Controllers
         /// </summary>
         /// <param name="dto"></param>
         /// <returns></returns>
-        [Permission(EPermission.KnowledgeTempAdd)]
-        [HttpPost("knowledgetemp-add")]
-        public async Task<string> KnowledgeTempAdd([FromBody] AddKnowledgeDto dto)
+        [Permission(EPermission.KnowledgeDraftsAdd)]
+        [HttpPost("draftsadd")]
+        public async Task<string> KnowledgeDraftsAdd([FromBody] AddKnowledgeDto dto)
         {
             var kn = _mapper.Map<KnowledgeTemp>(dto);
             if (string.IsNullOrEmpty(dto.Code))
                 kn.Code = Convert.ToInt64((DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds).ToString();
-            kn.PageView = 0;
+
             return await _knowledgeTempRepository.AddAsync(kn, HttpContext.RequestAborted);
         }
 
@@ -65,9 +70,9 @@ namespace Hotline.Api.Controllers
         /// </summary>
         /// <param name="dto"></param>
         /// <returns></returns>
-        [Permission(EPermission.KnowledgeTempUpdate)]
-        [HttpPost("knowledgetemp-update")]
-        public async Task KnowledgeTempUpdate([FromBody] UpdateKnowledgeDto dto)
+        [Permission(EPermission.KnowledgeDraftsUpdate)]
+        [HttpPut("draftsupdate")]
+        public async Task KnowledgeDraftsUpdate([FromBody] UpdateKnowledgeDto dto)
         {
             var kn = _mapper.Map<KnowledgeTemp>(dto);
             await _knowledgeTempRepository.UpdateAsync(kn, HttpContext.RequestAborted);
@@ -78,8 +83,8 @@ namespace Hotline.Api.Controllers
         /// </summary>
         /// <param name="Id"></param>
         /// <returns></returns>
-        [HttpGet("knowledgetemp-info")]
-        public async Task<KnowledgeTemp> KnowledgeTempInfo(string Id)
+        [HttpGet("draftsinfo/{id}")]
+        public async Task<KnowledgeTemp> KnowledgeDraftsInfo(string Id)
         {
             var temp = await _knowledgeTempRepository.GetAsync(Id, HttpContext.RequestAborted);
             if (temp is null)
@@ -92,15 +97,38 @@ namespace Hotline.Api.Controllers
         /// </summary>
         /// <param name="Id"></param>
         /// <returns></returns>
-        [Permission(EPermission.KnowledgeTempDelete)]
-        [HttpGet("knowledgetemp-delete")]
-        public async Task KnowledgeTempDelete(string Id)
+        [Permission(EPermission.KnowledgeDraftsDelete)]
+        [HttpDelete("draftsdelete")]
+        public async Task KnowledgeDraftsDelete(string Id)
         {
             if (string.IsNullOrEmpty(Id))
                 throw UserFriendlyException.SameMessage("Id不能为空！");
             await _knowledgeTempRepository.RemoveAsync(p => p.Id == Id, false, HttpContext.RequestAborted);
         }
 
+        /// <summary>
+        /// 我的草稿箱
+        /// </summary>
+        /// <param name="pagedDto"></param>
+        /// <returns></returns>
+        [Permission(EPermission.KnowledgeMyDraftsList)]
+        [HttpPost("mydraftslist")]
+        public async Task<PagedDto<KnowledgeDataDto>> MyDraftsList([FromBody] MyDraftsListPagedDto pagedDto)
+        {
+            var (total, items) = await _knowledgeTempRepository
+             .Queryable()
+             .Includes(it => it.User)
+             .Includes(it => it.KnowledgeType)
+             .Where(p => p.CreatorId == _sessionContext.RequiredUserId)
+             .WhereIF(!string.IsNullOrEmpty(pagedDto.Keyword), d => d.Title.Contains(pagedDto.Keyword!))
+             .WhereIF(!string.IsNullOrEmpty(pagedDto.KnowledgeTypeId), d => d.KnowledgeTypeId == pagedDto.KnowledgeTypeId)
+             .WhereIF(pagedDto.StartTime != null, d => d.CreationTime >= pagedDto.StartTime)
+             .WhereIF(pagedDto.EndTime != null, d => d.CreationTime <= pagedDto.EndTime)
+             .OrderByDescending(p => p.CreationTime)
+             .ToPagedListAsync(pagedDto.PageIndex, pagedDto.PageSize, HttpContext.RequestAborted);
+
+            return new PagedDto<KnowledgeDataDto>(total, _mapper.Map<IReadOnlyList<KnowledgeDataDto>>(items));
+        }
         #endregion
 
         #region 知识管理
@@ -109,10 +137,10 @@ namespace Hotline.Api.Controllers
         /// </summary>
         /// <param name="Id"></param>
         /// <returns></returns>
-        [HttpGet("knowledge-updateinfo")]
+        [HttpGet("updateinfo/{Id}")]
         public async Task<Knowledge> KnowledgeUpdateInfo(string Id)
         {
-            var know = await _knowledgeService.KnowledgeUpdateInfo(Id, HttpContext.RequestAborted);
+            var know = await _knowledgeRepository.GetAsync(Id, HttpContext.RequestAborted);
             if (know is null)
                 throw UserFriendlyException.SameMessage("知识查询失败！");
             return know;
@@ -123,10 +151,10 @@ namespace Hotline.Api.Controllers
         /// </summary>
         /// <param name="Id"></param>
         /// <returns></returns>
-        [HttpGet("knowledge-info")]
+        [HttpGet("info/{Id}")]
         public async Task<Knowledge> KnowledgeInfo(string Id)
         {
-            return await _knowledgeService.KnowledgeInfo(Id, HttpContext.RequestAborted);
+            return await _knowledgeDomainService.KnowledgeInfo(Id, HttpContext.RequestAborted);
         }
 
         /// <summary>
@@ -135,10 +163,10 @@ namespace Hotline.Api.Controllers
         /// <param name="dto"></param>
         /// <returns></returns>
         [Permission(EPermission.AddKnowledge)]
-        [HttpPost("knowledge-add")]
+        [HttpPost("knowadd")]
         public async Task<string> KnowledgeAdd([FromBody] AddKnowledgeDto dto)
         {
-            return await _knowledgeService.KnowledgeAdd(dto, HttpContext.RequestAborted);
+            return await _knowledgeDomainService.KnowledgeAdd(dto, HttpContext.RequestAborted);
         }
 
         /// <summary>
@@ -147,11 +175,11 @@ namespace Hotline.Api.Controllers
         /// <param name="dto"></param>
         /// <returns></returns>
         [Permission(EPermission.KnowledgeUpdate)]
-        [HttpPost("knowledge-update")]
+        [HttpPut("knowupdate")]
         public async Task KnowledgeUpdate([FromBody] UpdateKnowledgeDto dto)
         {
             //新增一条数据
-            await _knowledgeService.KnowledgeUpdate(dto, HttpContext.RequestAborted);
+            await _knowledgeDomainService.KnowledgeUpdate(dto, HttpContext.RequestAborted);
         }
 
         /// <summary>
@@ -160,7 +188,7 @@ namespace Hotline.Api.Controllers
         /// <param name="Id"></param>
         /// <returns></returns>
         [Permission(EPermission.KnowledgeDelete)]
-        [HttpGet("knowledge-delete")]
+        [HttpDelete("knowdelete")]
         public async Task KnowledgeDelete(string Id)
         {
             var know = await _knowledgeRepository.GetAsync(Id, HttpContext.RequestAborted);
@@ -180,7 +208,7 @@ namespace Hotline.Api.Controllers
         /// <param name="ApprovalStatus">审核状态：0：通过；1：不通过</param>
         /// <param name="HandleOpinions">办理意见</param>
         /// <returns></returns>
-        [HttpPost("knowledge-approvalhandle")]
+        [HttpPut("approvalhandle")]
         public async Task ApprovalHandle(List<string> Ids, string ApprovalStatus, string? HandleOpinions)
         {
             if (Ids is null || Ids.Count == 0)
@@ -188,7 +216,7 @@ namespace Hotline.Api.Controllers
             if (ApprovalStatus == "1" && string.IsNullOrEmpty(HandleOpinions))
                 throw UserFriendlyException.SameMessage("办理意见不能为空");
             //审批操作
-            await _knowledgeService.ApprovalHandle(Ids, ApprovalStatus, HandleOpinions, HttpContext.RequestAborted);
+            await _knowledgeDomainService.ApprovalHandle(Ids, ApprovalStatus, HandleOpinions, HttpContext.RequestAborted);
         }
 
         /// <summary>
@@ -197,13 +225,13 @@ namespace Hotline.Api.Controllers
         /// <param name="Id"></param>
         /// <returns></returns>
         [Permission(EPermission.KnowledgeOffShelf)]
-        [HttpGet("knowledge-offshelf")]
+        [HttpPut("offshelf")]
         public async Task KnowledgeOffShelf(string Id)
         {
             var know = await _knowledgeRepository.GetAsync(Id, HttpContext.RequestAborted);
-            if (know != null && know.IsOnShelf == true)
+            if (know != null && know.Status == EKnowledgeStatus.OnShelf)
             {
-                know.IsOnShelf = false;
+                know.Status = EKnowledgeStatus.OffShelf;
                 know.OnShelfTime = null;
                 know.OffShelfTime = DateTime.Now;
                 await _knowledgeRepository.UpdateAsync(know, HttpContext.RequestAborted);
@@ -219,13 +247,13 @@ namespace Hotline.Api.Controllers
         /// <param name="Id"></param>
         /// <returns></returns>
         [Permission(EPermission.KnowledgeOnTheShelf)]
-        [HttpGet("knowledge-ontheshelf")]
+        [HttpPut("ontheshelf")]
         public async Task KnowledgeOnTheShelf(string Id)
         {
             var know = await _knowledgeRepository.GetAsync(Id, HttpContext.RequestAborted);
-            if (know != null && know.IsOnShelf == false)
+            if (know != null && know.Status == EKnowledgeStatus.OffShelf)
             {
-                know.IsOnShelf = true;
+                know.Status = EKnowledgeStatus.OnShelf;
                 know.OnShelfTime = DateTime.Now;
                 know.OffShelfTime = null;
                 await _knowledgeRepository.UpdateAsync(know, HttpContext.RequestAborted);
@@ -238,354 +266,15 @@ namespace Hotline.Api.Controllers
 
         #region 知识列表
         /// <summary>
-        /// 我的草稿箱
-        /// </summary>
-        /// <param name="pagedDto"></param>
-        /// <returns></returns>
-        [Permission(EPermission.KnowledgeMyDraftsList)]
-        [HttpPost("knowledge-mydraftslist")]
-        public async Task<PagedDto<KnowledgeDataDto>> MyDraftsList([FromBody] MyDraftsListPagedDto pagedDto)
-        {
-            var (total, items) = await _knowledgeTempRepository
-             .Queryable()
-             .Includes(it => it.User)
-             .Includes(it => it.KnowledgeType)
-             .Where(p => p.CreatorId == _sessionContext.RequiredUserId)
-             .WhereIF(!string.IsNullOrEmpty(pagedDto.Title), d => d.Title.Contains(pagedDto.Title!))
-             .WhereIF(!string.IsNullOrEmpty(pagedDto.KnowledgeTypeId), d => d.KnowledgeTypeId == pagedDto.KnowledgeTypeId)
-             .WhereIF(pagedDto.StartTime != null, d => d.CreationTime >= pagedDto.StartTime)
-             .WhereIF(pagedDto.EndTime != null, d => d.CreationTime <= pagedDto.EndTime)
-             .OrderByDescending(p => p.CreationTime)
-             .ToPagedListAsync(pagedDto.PageIndex, pagedDto.PageSize, HttpContext.RequestAborted);
-
-            return new PagedDto<KnowledgeDataDto>(total, _mapper.Map<IReadOnlyList<KnowledgeDataDto>>(items));
-        }
-
-        /// <summary>
-        /// 测试列表查询数据
-        /// </summary>
-        /// <returns></returns>
-        [HttpPost("knowledge-testlist")]
-        [AllowAnonymous]
-        public async Task<PagedDto<KnowledgeDataDto>> testlist([FromBody] KnowledgePagedListDto pagedDto)
-        {
-            RefAsync<int> total = 0;
-            var temp = await _knowledgeRepository
-               .Queryable()
-               .LeftJoin<User>((o, cus) => o.CreatorId == cus.Id)
-               .LeftJoin<SystemOrganize>((o, cus, sys) => o.CreatorOrgId == sys.Id)
-               .LeftJoin<KnowledgeType>((o, cus, sys, kn) => o.KnowledgeTypeId == kn.Id)
-
-               .Where(o => o.IsDeleted == false)
-               .WhereIF(!string.IsNullOrEmpty(pagedDto.Title), (o, cus, sys, kn) => o.Title.Contains(pagedDto.Title!))
-               .WhereIF(!string.IsNullOrEmpty(pagedDto.KnowledgeTypeId), (o, cus, sys, kn) => o.KnowledgeTypeId == pagedDto.KnowledgeTypeId)
-               .WhereIF(!string.IsNullOrEmpty(pagedDto.HotspotId), (o, cus, sys, kn) => o.HotspotId == pagedDto.HotspotId)
-               .WhereIF(pagedDto.StartTime != null, (o, cus, sys, kn) => o.OnShelfTime >= pagedDto.StartTime)
-               .WhereIF(pagedDto.EndTime != null, (o, cus, sys, kn) => o.OnShelfTime <= pagedDto.EndTime)
-                .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateUserName), (o, cus, sys, kn) => cus.Name.Contains(pagedDto.CreateUserName!))
-                .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateBMName), (o, cus, sys, kn) => sys.OrgName.Contains(pagedDto.CreateBMName!))
-
-               .Select((o, cus, sys, kn) => new
-               {
-                   index = SqlFunc.RowNumber($"{o.Version} desc ", $"{o.Code}"),
-                   CreationName = cus.Name,
-                   CreationBMName = sys.OrgName,
-                   KnowledgeTypeName = kn.SpliceName,
-                   o.Id,
-                   o.Code,
-                   o.Title,
-                   o.Version,
-                   o.KnowledgeTypeId,
-                   o.IsDeleted,
-                   o.HotspotId,
-                   o.OnShelfTime,
-                   o.CreationTime,
-                   o.PageView,
-                   o.Status,
-                   o.OffShelfTime,
-                   o.LastModificationTime
-               })
-           .MergeTable()//将结果合并成一个表
-           .Where(d => d.index == 1)
-         // .ToSql();
-         .ToPageListAsync(pagedDto.PageIndex, pagedDto.PageSize, total);
-            return new PagedDto<KnowledgeDataDto>(total.Value, _mapper.Map<IReadOnlyList<KnowledgeDataDto>>(temp));
-        }
-
-        /// <summary>
-        /// 全部知识
+        /// 知识查询
         /// </summary>
         /// <param name="pagedDto"></param>
         /// <returns></returns>
         [Permission(EPermission.KnowledgeAllList)]
-        [HttpPost("knowledge-alllist")]
-        public async Task<PagedDto<KnowledgeDataDto>> AllList([FromBody] AllKnowledgePagedListDto pagedDto)
+        [HttpGet()]
+        public async Task<PagedDto<KnowledgeDataDto>> GetKnowList([FromBody] KnowPagedListDto pagedDto)
         {
-            var bmList = await _knowledgeService.GetChildBMId(_sessionContext.RequiredOrgId);
-            if (bmList == null || bmList.Count == 0)
-                return new PagedDto<KnowledgeDataDto>(0, _mapper.Map<IReadOnlyList<KnowledgeDataDto>>(new List<Knowledge>()));
-
-            RefAsync<int> total = 0;
-            var temp = await _knowledgeRepository
-               .Queryable()
-               .LeftJoin<User>((o, cus) => o.CreatorId == cus.Id)
-               .LeftJoin<SystemOrganize>((o, cus, sys) => o.CreatorOrgId == sys.Id)
-               .LeftJoin<KnowledgeType>((o, cus, sys, kn) => o.KnowledgeTypeId == kn.Id)
-
-               .Where((o, cus, sys, kn) => o.IsDeleted == false)
-               .Where((o, cus, sys, kn) => bmList.Contains(o.CreatorOrgId!))
-               .WhereIF(!string.IsNullOrEmpty(pagedDto.Title), (o, cus, sys, kn) => o.Title.Contains(pagedDto.Title!))
-               .WhereIF(!string.IsNullOrEmpty(pagedDto.KnowledgeTypeId), (o, cus, sys, kn) => o.KnowledgeTypeId == pagedDto.KnowledgeTypeId)
-               .WhereIF(!string.IsNullOrEmpty(pagedDto.HotspotId), (o, cus, sys, kn) => o.HotspotId == pagedDto.HotspotId)
-                .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateUserName), (o, cus, sys, kn) => cus.Name.Contains(pagedDto.CreateUserName!))
-                .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateBMName), (o, cus, sys, kn) => sys.OrgName.Contains(pagedDto.CreateBMName!))
-
-              //创建时间
-              .WhereIF(pagedDto.StartTime != null, (o, cus, sys, kn) => o.CreationTime >= pagedDto.StartTime)
-              .WhereIF(pagedDto.EndTime != null, (o, cus, sys, kn) => o.CreationTime <= pagedDto.EndTime)
-               //上架时间
-               .WhereIF(pagedDto.StartOnShelfTime != null, (o, cus, sys, kn) => o.OnShelfTime >= pagedDto.StartOnShelfTime)
-              .WhereIF(pagedDto.EndOnShelfTime != null, (o, cus, sys, kn) => o.OnShelfTime <= pagedDto.EndOnShelfTime)
-               //下架时间
-               .WhereIF(pagedDto.StartOffShelfTime != null, (o, cus, sys, kn) => o.OffShelfTime >= pagedDto.StartOffShelfTime)
-              .WhereIF(pagedDto.EndOffShelfTime != null, (o, cus, sys, kn) => o.OffShelfTime <= pagedDto.EndOffShelfTime)
-
-               .Select((o, cus, sys, kn) => new
-               {
-                   index = SqlFunc.RowNumber($"{o.Version} desc ", $"{o.Code}"),
-                   CreationName = cus.Name,
-                   CreationBMName = sys.OrgName,
-                   KnowledgeTypeName = kn.SpliceName,
-                   o.Id,
-                   o.Code,
-                   o.Title,
-                   o.Version,
-                   o.KnowledgeTypeId,
-                   o.IsDeleted,
-                   o.HotspotId,
-                   o.OnShelfTime,
-                   o.CreationTime,
-                   o.PageView,
-                   o.Status,
-                   o.OffShelfTime,
-                   o.LastModificationTime
-               })
-           .MergeTable()//将结果合并成一个表
-           .Where(d => d.index == 1)
-
-          .ToPageListAsync(pagedDto.PageIndex, pagedDto.PageSize, total);
-            return new PagedDto<KnowledgeDataDto>(total.Value, _mapper.Map<IReadOnlyList<KnowledgeDataDto>>(temp));
-        }
-
-        /// <summary>
-        /// 已上架
-        /// </summary>
-        /// <param name="pagedDto"></param>
-        /// <returns></returns>
-        [Permission(EPermission.OnTheShelfKnowledge)]
-        [HttpPost("knowledge-ontheshelf")]
-        public async Task<PagedDto<KnowledgeDataDto>> OnTheShelf([FromBody] KnowledgePagedListDto pagedDto)
-        {
-            var bmList = await _knowledgeService.GetChildBMId(_sessionContext.RequiredOrgId);
-            if (bmList == null || bmList.Count == 0)
-                return new PagedDto<KnowledgeDataDto>(0, _mapper.Map<IReadOnlyList<KnowledgeDataDto>>(new List<Knowledge>()));
-
-            RefAsync<int> total = 0;
-            var temp = await _knowledgeRepository
-               .Queryable()
-               .LeftJoin<User>((o, cus) => o.CreatorId == cus.Id)
-               .LeftJoin<SystemOrganize>((o, cus, sys) => o.CreatorOrgId == sys.Id)
-               .LeftJoin<KnowledgeType>((o, cus, sys, kn) => o.KnowledgeTypeId == kn.Id)
-
-               .Where((o, cus, sys, kn) => o.IsDeleted == false && o.IsOnShelf == true && o.Status == EKnowledgeStatus.Succeed)
-               .Where((o, cus, sys, kn) => bmList.Contains(o.CreatorOrgId!))
-               .WhereIF(!string.IsNullOrEmpty(pagedDto.Title), (o, cus, sys, kn) => o.Title.Contains(pagedDto.Title!))
-               .WhereIF(!string.IsNullOrEmpty(pagedDto.KnowledgeTypeId), (o, cus, sys, kn) => o.KnowledgeTypeId == pagedDto.KnowledgeTypeId)
-               .WhereIF(!string.IsNullOrEmpty(pagedDto.HotspotId), (o, cus, sys, kn) => o.HotspotId == pagedDto.HotspotId)
-               .WhereIF(pagedDto.StartTime != null, (o, cus, sys, kn) => o.OnShelfTime >= pagedDto.StartTime)
-               .WhereIF(pagedDto.EndTime != null, (o, cus, sys, kn) => o.OnShelfTime <= pagedDto.EndTime)
-                .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateUserName), (o, cus, sys, kn) => cus.Name.Contains(pagedDto.CreateUserName!))
-                .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateBMName), (o, cus, sys, kn) => sys.OrgName.Contains(pagedDto.CreateBMName!))
-
-               .Select((o, cus, sys, kn) => new
-               {
-                   index = SqlFunc.RowNumber($"{o.Version} desc ", $"{o.Code}"),
-                   CreationName = cus.Name,
-                   CreationBMName = sys.OrgName,
-                   KnowledgeTypeName = kn.SpliceName,
-                   o.Id,
-                   o.Code,
-                   o.Title,
-                   o.Version,
-                   o.KnowledgeTypeId,
-                   o.IsDeleted,
-                   o.HotspotId,
-                   o.OnShelfTime,
-                   o.CreationTime,
-                   o.PageView,
-                   o.Status,
-                   o.OffShelfTime,
-                   o.LastModificationTime
-               })
-           .MergeTable()//将结果合并成一个表
-           .Where(d => d.index == 1)
-            .OrderByDescending(p => p.CreationTime)
-          .ToPageListAsync(pagedDto.PageIndex, pagedDto.PageSize, total);
-            return new PagedDto<KnowledgeDataDto>(total.Value, _mapper.Map<IReadOnlyList<KnowledgeDataDto>>(temp));
-        }
-
-        /// <summary>
-        /// 已下架
-        /// </summary>
-        /// <param name="pagedDto"></param>
-        /// <returns></returns>
-        [Permission(EPermission.OffShelfKnowledge)]
-        [HttpPost("knowledge-offshelf")]
-        public async Task<PagedDto<KnowledgeDataDto>> OffShelf([FromBody] KnowledgePagedListDto pagedDto)
-        {
-            var bmList = await _knowledgeService.GetChildBMId(_sessionContext.RequiredOrgId);
-            if (bmList == null || bmList.Count == 0)
-                return new PagedDto<KnowledgeDataDto>(0, _mapper.Map<IReadOnlyList<KnowledgeDataDto>>(new List<Knowledge>()));
-
-            RefAsync<int> total = 0;
-            var temp = await _knowledgeRepository
-               .Queryable()
-               .LeftJoin<User>((o, cus) => o.CreatorId == cus.Id)
-               .LeftJoin<SystemOrganize>((o, cus, sys) => o.CreatorOrgId == sys.Id)
-               .LeftJoin<KnowledgeType>((o, cus, sys, kn) => o.KnowledgeTypeId == kn.Id)
-
-               .Where((o, cus, sys, kn) => o.IsDeleted == false && o.IsOnShelf == false && o.Status == EKnowledgeStatus.Succeed)//
-               .Where((o, cus, sys, kn) => bmList.Contains(o.CreatorOrgId!))
-               .WhereIF(!string.IsNullOrEmpty(pagedDto.Title), (o, cus, sys, kn) => o.Title.Contains(pagedDto.Title!))
-               .WhereIF(!string.IsNullOrEmpty(pagedDto.KnowledgeTypeId), (o, cus, sys, kn) => o.KnowledgeTypeId == pagedDto.KnowledgeTypeId)
-               .WhereIF(!string.IsNullOrEmpty(pagedDto.HotspotId), (o, cus, sys, kn) => o.HotspotId == pagedDto.HotspotId)
-               .WhereIF(pagedDto.StartTime != null, (o, cus, sys, kn) => o.OffShelfTime >= pagedDto.StartTime)
-               .WhereIF(pagedDto.EndTime != null, (o, cus, sys, kn) => o.OffShelfTime <= pagedDto.EndTime)
-                .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateUserName), (o, cus, sys, kn) => cus.Name.Contains(pagedDto.CreateUserName!))
-                .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateBMName), (o, cus, sys, kn) => sys.OrgName.Contains(pagedDto.CreateBMName!))
-
-               .Select((o, cus, sys, kn) => new
-               {
-                   index = SqlFunc.RowNumber($"{o.Version} desc ", $"{o.Code}"),
-                   CreationName = cus.Name,
-                   CreationBMName = sys.OrgName,
-                   KnowledgeTypeName = kn.SpliceName,
-                   o.Id,
-                   o.Code,
-                   o.Title,
-                   o.Version,
-                   o.KnowledgeTypeId,
-                   o.IsDeleted,
-                   o.HotspotId,
-                   o.OnShelfTime,
-                   o.CreationTime,
-                   o.PageView,
-                   o.Status,
-                   o.OffShelfTime,
-                   o.LastModificationTime
-               })
-           .MergeTable()//将结果合并成一个表
-           .Where(d => d.index == 1)
-            .OrderByDescending(p => p.CreationTime)
-          .ToPageListAsync(pagedDto.PageIndex, pagedDto.PageSize, total);
-            return new PagedDto<KnowledgeDataDto>(total.Value, _mapper.Map<IReadOnlyList<KnowledgeDataDto>>(temp));
-
-        }
-
-        /// <summary>
-        /// 审批中
-        /// </summary>
-        /// <param name="pagedDto"></param>
-        /// <returns></returns>
-        [Permission(EPermission.UnderApprovalKnowledge)]
-        [HttpPost("knowledge-underapproval")]
-        public async Task<PagedDto<KnowledgeDataDto>> UnderApproval([FromBody] KnowledgePagedListDto pagedDto)
-        {
-            var bmList = await _knowledgeService.GetChildBMId(_sessionContext.RequiredOrgId);
-            if (bmList == null || bmList.Count == 0)
-                return new PagedDto<KnowledgeDataDto>(0, _mapper.Map<IReadOnlyList<KnowledgeDataDto>>(new List<Knowledge>()));
-            var (total, items) = await _knowledgeRepository
-              .Queryable()
-              .Includes(it => it.User)
-              .Includes(it => it.SystemOrganize)
-              .Includes(it => it.KnowledgeType)
-              .Where(p => p.Status == EKnowledgeStatus.Auditing && p.IsDeleted == false)
-              .Where(p => bmList.Contains(p.CreatorOrgId!))
-              .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateUserName), d => d.User.Name.Contains(pagedDto.CreateUserName!))
-              .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateBMName), d => d.SystemOrganize.OrgName.Contains(pagedDto.CreateBMName!))
-              .WhereIF(!string.IsNullOrEmpty(pagedDto.Title), d => d.Title.Contains(pagedDto.Title!))
-              .WhereIF(!string.IsNullOrEmpty(pagedDto.KnowledgeTypeId), d => d.KnowledgeTypeId == pagedDto.KnowledgeTypeId)
-              .WhereIF(!string.IsNullOrEmpty(pagedDto.HotspotId), d => d.HotspotId == pagedDto.HotspotId)
-              .WhereIF(pagedDto.StartTime != null, d => d.CreationTime >= pagedDto.StartTime)
-              .WhereIF(pagedDto.EndTime != null, d => d.CreationTime <= pagedDto.EndTime)
-              .OrderByDescending(p => p.CreationTime)
-              .ToPagedListAsync(pagedDto.PageIndex, pagedDto.PageSize, HttpContext.RequestAborted);
-
-            return new PagedDto<KnowledgeDataDto>(total, _mapper.Map<IReadOnlyList<KnowledgeDataDto>>(items));
-        }
-
-        /// <summary>
-        /// 审批完成
-        /// </summary>
-        /// <param name="pagedDto"></param>
-        /// <returns></returns>
-        [Permission(EPermission.ApprovedKnowledge)]
-        [HttpPost("knowledge-approved")]
-        public async Task<PagedDto<KnowledgeDataDto>> Approved([FromBody] KnowledgePagedListDto pagedDto)
-        {
-            var bmList = await _knowledgeService.GetChildBMId(_sessionContext.RequiredOrgId);
-            if (bmList == null || bmList.Count == 0)
-                return new PagedDto<KnowledgeDataDto>(0, _mapper.Map<IReadOnlyList<KnowledgeDataDto>>(new List<Knowledge>()));
-            var (total, items) = await _knowledgeRepository
-              .Queryable()
-              .Includes(it => it.User)
-              .Includes(it => it.SystemOrganize)
-              .Includes(it => it.KnowledgeType)
-              .Where(p => p.Status == EKnowledgeStatus.Succeed && p.IsDeleted == false)
-              .Where(p => bmList.Contains(p.CreatorOrgId!))
-              .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateUserName), d => d.User.Name.Contains(pagedDto.CreateUserName!))
-              .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateBMName), d => d.SystemOrganize.OrgName.Contains(pagedDto.CreateBMName!))
-              .WhereIF(!string.IsNullOrEmpty(pagedDto.Title), d => d.Title.Contains(pagedDto.Title!))
-              .WhereIF(!string.IsNullOrEmpty(pagedDto.KnowledgeTypeId), d => d.KnowledgeTypeId == pagedDto.KnowledgeTypeId)
-              .WhereIF(!string.IsNullOrEmpty(pagedDto.HotspotId), d => d.HotspotId == pagedDto.HotspotId)
-              .WhereIF(pagedDto.StartTime != null, d => d.CreationTime >= pagedDto.StartTime)
-              .WhereIF(pagedDto.EndTime != null, d => d.CreationTime <= pagedDto.EndTime)
-              .OrderByDescending(p => p.CreationTime)
-              .ToPagedListAsync(pagedDto.PageIndex, pagedDto.PageSize, HttpContext.RequestAborted);
-
-            return new PagedDto<KnowledgeDataDto>(total, _mapper.Map<IReadOnlyList<KnowledgeDataDto>>(items));
-        }
-
-        /// <summary>
-        /// 审批不通过
-        /// </summary>
-        /// <param name="pagedDto"></param>
-        /// <returns></returns>
-        [Permission(EPermission.ApprovalFailedKnowledge)]
-        [HttpPost("knowledge-approvalfailed")]
-        public async Task<PagedDto<KnowledgeDataDto>> ApprovalFailed([FromBody] KnowledgePagedListDto pagedDto)
-        {
-            var bmList = await _knowledgeService.GetChildBMId(_sessionContext.UserId);
-            if (bmList == null || bmList.Count == 0)
-                return new PagedDto<KnowledgeDataDto>(0, _mapper.Map<IReadOnlyList<KnowledgeDataDto>>(new List<Knowledge>()));
-            var (total, items) = await _knowledgeRepository
-              .Queryable()
-              .Includes(it => it.User)
-              .Includes(it => it.SystemOrganize)
-              .Includes(it => it.KnowledgeType)
-              .Where(p => p.Status == EKnowledgeStatus.Failed && p.IsDeleted == false)
-              .Where(p => bmList.Contains(p.CreatorOrgId!))
-              .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateUserName), d => d.User.Name.Contains(pagedDto.CreateUserName!))
-              .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateBMName), d => d.SystemOrganize.OrgName.Contains(pagedDto.CreateBMName!))
-              .WhereIF(!string.IsNullOrEmpty(pagedDto.Title), d => d.Title.Contains(pagedDto.Title!))
-              .WhereIF(!string.IsNullOrEmpty(pagedDto.KnowledgeTypeId), d => d.KnowledgeTypeId == pagedDto.KnowledgeTypeId)
-              .WhereIF(!string.IsNullOrEmpty(pagedDto.HotspotId), d => d.HotspotId == pagedDto.HotspotId)
-              .WhereIF(pagedDto.StartTime != null, d => d.CreationTime >= pagedDto.StartTime)
-              .WhereIF(pagedDto.EndTime != null, d => d.CreationTime <= pagedDto.EndTime)
-              .OrderByDescending(p => p.CreationTime)
-              .ToPagedListAsync(pagedDto.PageIndex, pagedDto.PageSize, HttpContext.RequestAborted);
-
-            return new PagedDto<KnowledgeDataDto>(total, _mapper.Map<IReadOnlyList<KnowledgeDataDto>>(items));
+            return await _knowApplication.GetKnowList(pagedDto);
         }
 
         #endregion
@@ -597,23 +286,16 @@ namespace Hotline.Api.Controllers
         /// <param name="pagedDto"></param>
         /// <returns></returns>
         [Permission(EPermission.KnowledgeRetrieval)]
-        [HttpPost("knowledge-knowretrieval")]
+        [HttpGet("knowretrieval")]
         public async Task<PagedDto<KnowledgeRetrievalDataDto>> KnowRetrieval([FromBody] KnowledgeRetrievalPagedListDto pagedDto)
         {
             if (string.IsNullOrEmpty(pagedDto.Keyword))
                 throw UserFriendlyException.SameMessage("请输入关键字");
 
-            //是否需要验证本部门以及下级部门的数据，不要注释下面这3行
-            var bmList = await _knowledgeService.GetChildBMId(_sessionContext.RequiredOrgId);
-            if (bmList == null || bmList.Count == 0)
-                return new PagedDto<KnowledgeRetrievalDataDto>(0, _mapper.Map<IReadOnlyList<KnowledgeRetrievalDataDto>>(new List<Knowledge>()));
-
-            string a = EKnowledgeRetrievalType.All.ToString();
             RefAsync<int> total = 0;
             var temp = await _knowledgeRepository
-              .Queryable()
-              .Where(p => p.IsDeleted == false && p.Status == EKnowledgeStatus.Succeed)
-              .Where(p => bmList.Contains(p.CreatorOrgId!)) //是否需要验证本部门以及下级部门的数据，不要注释此行
+              .Queryable(true)
+              .Where(p => p.Status == EKnowledgeStatus.OnShelf)
               .WhereIF(!string.IsNullOrEmpty(pagedDto.RetrievalType) || pagedDto.RetrievalType == EKnowledgeRetrievalType.All.ToString(),
                         d => d.Title.Contains(pagedDto.Keyword) || d.Content.Contains(pagedDto.Keyword) || d.Additions.Contains(pagedDto.Keyword))
               .WhereIF(pagedDto.RetrievalType == EKnowledgeRetrievalType.Title.ToString(), d => d.Title.Contains(pagedDto.Keyword))
@@ -645,17 +327,16 @@ namespace Hotline.Api.Controllers
         /// <param name="pagedDto"></param>
         /// <returns></returns>
         [Permission(EPermission.KnowledgeApprovedAllList)]
-        [HttpPost("knowledge-approvedalllist")]
+        [HttpGet("approvedalllist")]
         public async Task<PagedDto<KnowledgeApprovalDataDto>> ApprovedAllList([FromBody] KnowledgeApprovalPagedListDto pagedDto)
         {
             var (total, items) = await _knowledgeRepository
-              .Queryable()
+              .Queryable(true)
               .Includes(it => it.User)
               .Includes(it => it.SystemOrganize)
               .Includes(it => it.KnowledgeType)
-              .Where(p => p.IsDeleted == false)//&& p.AssignUserIds.Contains(_sessionContext.UserId!)
               .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateUserName), d => d.User.Name.Contains(pagedDto.CreateUserName!))
-              .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateBMName), d => d.SystemOrganize.OrgName.Contains(pagedDto.CreateBMName!))
+              .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateOrgName), d => d.SystemOrganize.OrgName.Contains(pagedDto.CreateOrgName!))
               .WhereIF(!string.IsNullOrEmpty(pagedDto.Title), d => d.Title.Contains(pagedDto.Title!))
 
               .OrderByDescending(p => p.CreationTime)
@@ -670,7 +351,7 @@ namespace Hotline.Api.Controllers
         /// <param name="pagedDto"></param>
         /// <returns></returns>
         [Permission(EPermission.KnowledgeToBeReviewed)]
-        [HttpPost("knowledge-tobereviewed")]
+        [HttpGet("tobereviewed")]
         public async Task<PagedDto<KnowledgeApprovalDataDto>> ToBeReviewed([FromBody] KnowledgeApprovalPagedListDto pagedDto)
         {
             //审核类型字段加在哪里
@@ -678,13 +359,13 @@ namespace Hotline.Api.Controllers
             //
             //还需要增加审核类型查询条件
             var (total, items) = await _knowledgeRepository
-              .Queryable()
+              .Queryable(true)
               .Includes(it => it.User)
               .Includes(it => it.SystemOrganize)
               .Includes(it => it.KnowledgeType)
-              .Where(p => p.IsDeleted == false && p.Status == EKnowledgeStatus.Auditing && p.AssignUserIds.Contains(_sessionContext.UserId!))
+              .Where(p => p.Status == EKnowledgeStatus.Auditing && p.AssignUserIds.Contains(_sessionContext.UserId!))
               .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateUserName), d => d.User.Name.Contains(pagedDto.CreateUserName!))
-              .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateBMName), d => d.SystemOrganize.OrgName.Contains(pagedDto.CreateBMName!))
+              .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateOrgName), d => d.SystemOrganize.OrgName.Contains(pagedDto.CreateOrgName!))
               .WhereIF(!string.IsNullOrEmpty(pagedDto.Title), d => d.Title.Contains(pagedDto.Title!))
 
               .OrderByDescending(p => p.CreationTime)
@@ -699,19 +380,19 @@ namespace Hotline.Api.Controllers
         /// <param name="pagedDto"></param>
         /// <returns></returns>
         [Permission(EPermission.KnowledgeApprovedList)]
-        [HttpPost("knowledge-approvedlist")]
+        [HttpGet("approvedlist")]
         public async Task<PagedDto<KnowledgeApprovalDataDto>> ApprovedList([FromBody] KnowledgeApprovalPagedListDto pagedDto)
         {
             //自己审批了哪些数据，通过什么方式去查询这个数据是属于自己的
 
             var (total, items) = await _knowledgeRepository
-              .Queryable()
+              .Queryable(true)
               .Includes(it => it.User)
               .Includes(it => it.SystemOrganize)
               .Includes(it => it.KnowledgeType)
-              .Where(p => p.IsDeleted == false && p.Status == EKnowledgeStatus.Succeed)//&& p.AssignUserIds.Contains(pagedDto.UserId!)
+              .Where(p => p.Status == EKnowledgeStatus.OnShelf || p.Status == EKnowledgeStatus.OffShelf)
               .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateUserName), d => d.User.Name.Contains(pagedDto.CreateUserName!))
-              .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateBMName), d => d.SystemOrganize.OrgName.Contains(pagedDto.CreateBMName!))
+              .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateOrgName), d => d.SystemOrganize.OrgName.Contains(pagedDto.CreateOrgName!))
               .WhereIF(!string.IsNullOrEmpty(pagedDto.Title), d => d.Title.Contains(pagedDto.Title!))
 
               .OrderByDescending(p => p.CreationTime)
@@ -726,17 +407,17 @@ namespace Hotline.Api.Controllers
         /// <param name="pagedDto"></param>
         /// <returns></returns>
         [Permission(EPermission.KnowledgeApprovedFailedList)]
-        [HttpPost("knowledge-approvedfailedlist")]
+        [HttpGet("approvedfailedlist")]
         public async Task<PagedDto<KnowledgeApprovalDataDto>> ApprovedFailedList([FromBody] KnowledgeApprovalPagedListDto pagedDto)
         {
             var (total, items) = await _knowledgeRepository
-              .Queryable()
+              .Queryable(true)
               .Includes(it => it.User)
               .Includes(it => it.SystemOrganize)
               .Includes(it => it.KnowledgeType)
-              .Where(p => p.IsDeleted == false && p.Status == EKnowledgeStatus.Failed)//&& p.AssignUserIds.Contains(pagedDto.UserId!)
+              .Where(p => p.Status == EKnowledgeStatus.Failed)
               .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateUserName), d => d.User.Name.Contains(pagedDto.CreateUserName!))
-              .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateBMName), d => d.SystemOrganize.OrgName.Contains(pagedDto.CreateBMName!))
+              .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateOrgName), d => d.SystemOrganize.OrgName.Contains(pagedDto.CreateOrgName!))
               .WhereIF(!string.IsNullOrEmpty(pagedDto.Title), d => d.Title.Contains(pagedDto.Title!))
 
               .OrderByDescending(p => p.CreationTime)

src/Hotline.Api/Permissions/EPermission.cs

@@ -543,17 +543,17 @@ namespace Hotline.Permissions
         /// 新增草稿
         /// </summary>
         [Display(GroupName = "我的草稿箱", Name = "新增草稿", Description = "新增草稿")]
-        KnowledgeTempAdd = 400181,
+        KnowledgeDraftsAdd = 400181,
         /// <summary>
         /// 修改草稿
         /// </summary>
         [Display(GroupName = "我的草稿箱", Name = "修改草稿", Description = "修改草稿")]
-        KnowledgeTempUpdate = 400182,
+        KnowledgeDraftsUpdate = 400182,
         /// <summary>
         /// 删除草稿
         /// </summary>
         [Display(GroupName = "我的草稿箱", Name = "删除草稿", Description = "删除草稿")]
-        KnowledgeTempDelete = 400183,
+        KnowledgeDraftsDelete = 400183,
 
         /// <summary>
         /// 我的知识删除申请
@@ -748,7 +748,11 @@ namespace Hotline.Permissions
         /// </summary>
         [Display(GroupName = "知识申请处理", Name = "知识申请退回按钮", Description = "知识申请退回按钮")]
         KnowledgeApplyReturn = 400425,
-
+        /// <summary>
+        ///知识申请删除按钮
+        /// </summary>
+        [Display(GroupName = "知识申请处理", Name = "知识申请删除", Description = "知识申请删除")]
+        KnowledgeApplyDelete = 400426,
 
         #endregion
 

src/Hotline.Application/Knowledge/IKnowApplication.cs

@@ -0,0 +1,32 @@
+using Hotline.KnowledgeBase;
+using Hotline.Share.Dtos;
+using Hotline.Share.Dtos.Knowledge;
+
+namespace Hotline.Application.Knowledge
+{
+    public interface IKnowApplication
+    {
+        /// <summary>
+        /// 知识库查询
+        /// </summary>
+        /// <param name="pagedDto"></param>
+        /// <returns></returns>
+        Task<PagedDto<KnowledgeDataDto>> GetKnowList(KnowPagedListDto pagedDto);
+
+        /// <summary>
+        /// 知识申请查询
+        /// </summary>
+        /// <param name="pagedDto"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        Task<PagedDto<KnowledgeApply>> GetApplyList(KnowledgeApplyPagedDto pagedDto, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// 申请处理查询
+        /// </summary>
+        /// <param name="pagedDto"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        Task<PagedDto<KnowledgeApplyPageDto>> GetApplyHandleList(KnowledgeHandlePagedDto pagedDto, CancellationToken cancellationToken);
+    }
+}

src/Hotline.Application/Knowledge/KnowApplication.cs

@@ -0,0 +1,154 @@
+using Hotline.KnowledgeBase;
+using Hotline.Repository.SqlSugar.Extensions;
+using Hotline.Settings;
+using Hotline.Share.Dtos;
+using Hotline.Share.Dtos.Knowledge;
+using Hotline.Share.Enums.KnowledgeBase;
+using Hotline.Users;
+using MapsterMapper;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using SqlSugar;
+using XF.Domain.Authentications;
+using XF.Domain.Dependency;
+
+namespace Hotline.Application.Knowledge
+{
+    public class KnowApplication : IKnowApplication, IScopeDependency
+    {
+        private readonly IKnowledgeRepository _knowledgeRepository;
+        private readonly IKnowledgeApplyRepository _knowledgeApplyRepository;
+        private readonly ISessionContext _sessionContext;
+        private readonly IMapper _mapper;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="knowledgeRepository"></param>
+        /// <param name="knowledgeApplyRepository"></param>
+        /// <param name="sessionContext"></param>
+        /// <param name="knowledgeDomainService"></param>
+        /// <param name="mapper"></param>
+        public KnowApplication(IKnowledgeRepository knowledgeRepository, IKnowledgeApplyRepository knowledgeApplyRepository, ISessionContext sessionContext, IMapper mapper)
+        {
+            _knowledgeRepository = knowledgeRepository;
+            _knowledgeApplyRepository = knowledgeApplyRepository;
+            _sessionContext = sessionContext;
+            _mapper = mapper;
+        }
+
+        /// <summary>
+        /// 知识库查询
+        /// </summary>
+        /// <param name="pagedDto"></param>
+        /// <returns></returns>
+        public async Task<PagedDto<KnowledgeDataDto>> GetKnowList(KnowPagedListDto pagedDto)
+        {
+            RefAsync<int> total = 0;
+            var temp = await _knowledgeRepository
+               .Queryable(true)
+               .LeftJoin<User>((o, cus) => o.CreatorId == cus.Id)
+               .LeftJoin<SystemOrganize>((o, cus, sys) => o.CreatorOrgId == sys.Id)
+               .LeftJoin<KnowledgeType>((o, cus, sys, kn) => o.KnowledgeTypeId == kn.Id)
+               //关键词查询标题、创建人、创建部门
+               .WhereIF(!string.IsNullOrEmpty(pagedDto.Keyword), (o, cus, sys, kn) => o.Title.Contains(pagedDto.Keyword!) || cus.Name.Contains(pagedDto.Keyword!) || sys.OrgName.Contains(pagedDto.Keyword!))
+               //分类
+               .WhereIF(!string.IsNullOrEmpty(pagedDto.KnowledgeTypeId), (o, cus, sys, kn) => o.KnowledgeTypeId == pagedDto.KnowledgeTypeId)
+               //热点
+               .WhereIF(!string.IsNullOrEmpty(pagedDto.HotspotId), (o, cus, sys, kn) => o.HotspotId == pagedDto.HotspotId)
+               //部门
+               .WhereIF(!string.IsNullOrEmpty(pagedDto.CreateOrgId), (o, cus, sys, kn) => o.CreatorOrgId == pagedDto.CreateOrgId)
+              //状态
+              .WhereIF(pagedDto.Status != null, (o, cus, sys, kn) => o.Status == pagedDto.Status)
+              //创建时间
+              .WhereIF(pagedDto.CreationStartTime != null, (o, cus, sys, kn) => o.CreationTime >= pagedDto.CreationStartTime)
+              .WhereIF(pagedDto.CreationEndTime != null, (o, cus, sys, kn) => o.CreationTime <= pagedDto.CreationEndTime)
+               //上架时间
+               .WhereIF(pagedDto.StartOnShelfTime != null, (o, cus, sys, kn) => o.OnShelfTime >= pagedDto.StartOnShelfTime)
+              .WhereIF(pagedDto.EndOnShelfTime != null, (o, cus, sys, kn) => o.OnShelfTime <= pagedDto.EndOnShelfTime)
+               //下架时间
+               .WhereIF(pagedDto.StartOffShelfTime != null, (o, cus, sys, kn) => o.OffShelfTime >= pagedDto.StartOffShelfTime)
+              .WhereIF(pagedDto.EndOffShelfTime != null, (o, cus, sys, kn) => o.OffShelfTime <= pagedDto.EndOffShelfTime)
+               //重新构建数据
+               .Select((o, cus, sys, kn) => new
+               {
+                   index = SqlFunc.RowNumber($"{o.Version} desc ", $"{o.Code}"),
+                   CreationName = cus.Name,
+                   CreationBMName = sys.OrgName,
+                   KnowledgeTypeName = kn.SpliceName,
+                   o.Id,
+                   o.Code,
+                   o.Title,
+                   o.Version,
+                   o.KnowledgeTypeId,
+                   o.IsDeleted,
+                   o.HotspotId,
+                   o.OnShelfTime,
+                   o.CreationTime,
+                   o.PageView,
+                   o.Status,
+                   o.OffShelfTime,
+                   o.LastModificationTime
+               })
+           //将结果合并成一个表
+           .MergeTable()
+           //取第一条数据
+           .Where(d => d.index == 1)
+          //转分页数据
+          .ToPageListAsync(pagedDto.PageIndex, pagedDto.PageSize, total);
+            //返回数据
+            return new PagedDto<KnowledgeDataDto>(total.Value, _mapper.Map<IReadOnlyList<KnowledgeDataDto>>(temp));
+        }
+
+        /// <summary>
+        /// 知识申请查询
+        /// </summary>
+        /// <param name="pagedDto"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public async Task<PagedDto<KnowledgeApply>> GetApplyList(KnowledgeApplyPagedDto pagedDto, CancellationToken cancellationToken)
+        {
+            var (total, items) = await _knowledgeApplyRepository
+               .Queryable()
+               .Includes(it => it.User)
+               .Includes(it => it.SystemOrganize)
+               .Where(d => d.CreatorId == _sessionContext.RequiredUserId)
+               .WhereIF(pagedDto.Status != null, d => d.Status == pagedDto.Status)
+               .WhereIF(pagedDto.ApplyType != null, d => d.KnowledgeApplyType == pagedDto.ApplyType)
+               .WhereIF(!string.IsNullOrEmpty(pagedDto.IsOvertime) && pagedDto.IsOvertime == "0", d => d.ExpiredTime < DateTime.Now)
+               .WhereIF(!string.IsNullOrEmpty(pagedDto.IsOvertime) && pagedDto.IsOvertime == "1", d => d.ExpiredTime >= DateTime.Now)
+               .WhereIF(pagedDto.StartTime != null, d => d.CreationTime >= pagedDto.StartTime)
+               .WhereIF(pagedDto.EndTime != null, d => d.CreationTime <= pagedDto.EndTime)
+               .OrderByDescending(p => p.CreationTime)
+               .ToPagedListAsync(pagedDto.PageIndex, pagedDto.PageSize, cancellationToken);
+
+            return new PagedDto<KnowledgeApply>(total, _mapper.Map<IReadOnlyList<KnowledgeApply>>(items));
+        }
+
+        /// <summary>
+        /// 申请处理查询
+        /// </summary>
+        /// <param name="pagedDto"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public async Task<PagedDto<KnowledgeApplyPageDto>> GetApplyHandleList(KnowledgeHandlePagedDto pagedDto, CancellationToken cancellationToken)
+        {
+            var (total, items) = await _knowledgeApplyRepository
+                 .Queryable()
+                 .Includes(it => it.User)
+                 .Includes(it => it.SystemOrganize)
+                 .Where(p => p.DepartmentCode == _sessionContext.RequiredOrgCode)
+                 .WhereIF(pagedDto.Status != null, d => d.Status == pagedDto.Status)
+                 .WhereIF(!string.IsNullOrEmpty(pagedDto.Keyword), d => d.User.Name.Contains(pagedDto.Keyword!) || d.SystemOrganize.OrgName.Contains(pagedDto.Keyword!))
+                 .WhereIF(pagedDto.ApplyType != null, d => d.KnowledgeApplyType == pagedDto.ApplyType)
+                 .WhereIF(!string.IsNullOrEmpty(pagedDto.IsOvertime) && pagedDto.IsOvertime == "0", d => d.ExpiredTime < DateTime.Now)
+                 .WhereIF(!string.IsNullOrEmpty(pagedDto.IsOvertime) && pagedDto.IsOvertime == "1", d => d.ExpiredTime >= DateTime.Now)
+                 .WhereIF(pagedDto.StartTime != null, d => d.CreationTime >= pagedDto.StartTime)
+                 .WhereIF(pagedDto.EndTime != null, d => d.CreationTime <= pagedDto.EndTime)
+                 .OrderByDescending(p => p.CreationTime)
+                 .ToPagedListAsync(pagedDto.PageIndex, pagedDto.PageSize, cancellationToken);
+
+            return new PagedDto<KnowledgeApplyPageDto>(total, _mapper.Map<IReadOnlyList<KnowledgeApplyPageDto>>(items));
+        }
+    }
+}

src/Hotline.Application/Mappers/MapperConfigs.cs

@@ -42,11 +42,11 @@ namespace Hotline.Application.Mappers
               .Map(d => d.CreationName, x => x.User.Name)
                 .Map(d => d.CreationOrgName, x => x.SystemOrganize.OrgName);
 
-            config.NewConfig<Knowledge, KnowledgeDataDto>()
+            config.NewConfig<Hotline.KnowledgeBase.Knowledge, KnowledgeDataDto>()
               .Map(d => d.CreationName, x => x.User.Name)
                 .Map(d => d.KnowledgeTypeName, x => x.KnowledgeType.SpliceName);
 
-            config.NewConfig<Knowledge, KnowledgeApprovalDataDto>()
+            config.NewConfig<Hotline.KnowledgeBase.Knowledge, KnowledgeApprovalDataDto>()
             .Map(d => d.CreationName, x => x.User.Name)
               .Map(d => d.KnowledgeTypeName, x => x.KnowledgeType.SpliceName)
                  .Map(d => d.CreateBMName, x => x.SystemOrganize.OrgName);

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

@@ -1,24 +1,26 @@
-using Hotline.Share.Requests;
+using Hotline.Share.Enums.KnowledgeBase;
+using Hotline.Share.Requests;
 
 namespace Hotline.Share.Dtos.Knowledge
 {
     /// <summary>
     /// 
     /// </summary>
+    ///  <param name="Status"></param>
     /// <param name="ApplyType"></param>
     /// <param name="IsOvertime"></param>
     /// <param name="StartTime"></param>
     /// <param name="EndTime"></param>
-    public record KnowledgeApplyPagedDto(string? ApplyType, string? IsOvertime, DateTime? StartTime, DateTime? EndTime) : PagedRequest;
+    public record KnowledgeApplyPagedDto(EKnowledgeApplyStatus? Status, EKnowledgeApplyType? ApplyType, string? IsOvertime, DateTime? StartTime, DateTime? EndTime) : PagedRequest;
 
     /// <summary>
     /// 
     /// </summary>
+    /// <param name="Status"></param>
     /// <param name="ApplyType"></param>
     /// <param name="IsOvertime"></param>
     /// <param name="StartTime"></param>
     /// <param name="EndTime"></param>
-    /// <param name="CreateUserName"></param>
-    /// <param name="CreateBMName"></param>
-    public record KnowledgeHandlePagedDto(string? ApplyType, string? IsOvertime, DateTime? StartTime, DateTime? EndTime, string? CreateUserName, string? CreateBMName) : PagedRequest;
+    public record KnowledgeHandlePagedDto(EKnowledgeApplyStatus? Status, EKnowledgeApplyType? ApplyType, string? IsOvertime, DateTime? StartTime, DateTime? EndTime) : PagedKeywordRequest;
+
 }

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

@@ -1,60 +1,12 @@
-using Hotline.Share.Requests;
+using Hotline.Share.Enums.KnowledgeBase;
+using Hotline.Share.Requests;
 
 namespace Hotline.Share.Dtos.Knowledge
 {
-    /// <summary>
-    /// 知识库基础
-    /// </summary>
-    public record KnowledgeBasePagedDto : PagedRequest
-    {
-        /// <summary>
-        /// 知识类型
-        /// </summary>
-        public string? KnowledgeTypeId { get; set; }
-
-        /// <summary>
-        /// 知识标题
-        /// </summary>
-        public string? Title { get; set; }
-
-        /// <summary>
-        /// 创建时间-开始
-        /// </summary>
-        public DateTime? StartTime { get; set; }
-
-        /// <summary>
-        /// 创建时间-结束
-        /// </summary>
-        public DateTime? EndTime { get; set; }
-    }
-
     /// <summary>
     /// 草稿箱
     /// </summary>
-    public record MyDraftsListPagedDto() : KnowledgeBasePagedDto;
-
-    /// <summary>
-    /// 知识库
-    /// </summary>
-    /// <param name="CreateUserName">创建人</param>
-    /// <param name="CreateBMName">创建部门</param>
-    /// <param name="CreateBMId">创建部门ID</param>
-    /// <param name="HotspotId">热点类型</param>
-    public record KnowledgePagedListDto(string? CreateUserName, string? CreateBMName, string? CreateBMId, string? HotspotId) : KnowledgeBasePagedDto;
-
-    /// <summary>
-    /// 全部知识查询条件
-    /// </summary>
-    /// <param name="CreateUserName">创建人</param>
-    /// <param name="CreateBMName">创建部门</param>
-    /// <param name="CreateBMId">创建部门ID</param>
-    /// <param name="HotspotId">热点类型</param>
-    /// <param name="StartOnShelfTime">上架时间-开始</param>
-    /// <param name="EndOnShelfTime">上架时间-结束</param>
-    /// <param name="StartOffShelfTime">下架时间-开始</param>
-    /// <param name="EndOffShelfTime">下架时间-结束</param>
-    public record AllKnowledgePagedListDto(string? CreateUserName, string? CreateBMName, string? CreateBMId, string? HotspotId,
-        DateTime? StartOnShelfTime, DateTime? EndOnShelfTime, DateTime? StartOffShelfTime, DateTime? EndOffShelfTime) : KnowledgeBasePagedDto;
+    public record MyDraftsListPagedDto(string? KnowledgeTypeId, DateTime? StartTime, DateTime? EndTime) : PagedKeywordRequest;
 
     /// <summary>
     /// 审核管理
@@ -62,12 +14,28 @@ namespace Hotline.Share.Dtos.Knowledge
     /// <param name="AuditType">审核类型</param>
     /// <param name="Title">标题</param>
     /// <param name="CreateUserName">创建人</param>
-    /// <param name="CreateBMName">创建部门</param>
-    public record KnowledgeApprovalPagedListDto(string? AuditType, string? Title, string? CreateUserName, string? CreateBMName) : PagedRequest;
+    /// <param name="CreateOrgName">创建部门</param>
+    public record KnowledgeApprovalPagedListDto(string? AuditType, string? Title, string? CreateUserName, string? CreateOrgName) : PagedRequest;
 
     /// <summary>
     /// 知识检索
     /// </summary>
     /// <param name="RetrievalType">检索类型</param>
     public record KnowledgeRetrievalPagedListDto(string? RetrievalType) : PagedKeywordRequest;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="CreateOrgId">部门</param>
+    /// <param name="HotspotId">热点</param>
+    /// <param name="KnowledgeTypeId">分类</param>
+    /// <param name="Status">状态</param>
+    /// <param name="CreationStartTime">创建开始</param>
+    /// <param name="CreationEndTime">创建结束</param>
+    /// <param name="StartOnShelfTime">上架时间-开始</param>
+    /// <param name="EndOnShelfTime">上架时间-结束</param>
+    /// <param name="StartOffShelfTime">下架时间-开始</param>
+    /// <param name="EndOffShelfTime">下架时间-结束</param>
+    public record KnowPagedListDto(string? CreateOrgId, string? HotspotId, string? KnowledgeTypeId, EKnowledgeStatus? Status, DateTime? CreationStartTime, DateTime? CreationEndTime,
+      DateTime? StartOnShelfTime, DateTime? EndOnShelfTime, DateTime? StartOffShelfTime, DateTime? EndOffShelfTime) : PagedKeywordRequest;
 }

src/Hotline/KnowledgeBase/IKnowledgeDomainService.cs

@@ -4,20 +4,6 @@ namespace Hotline.KnowledgeBase
 {
     public interface IKnowledgeDomainService
     {
-        /// <summary>
-        /// 根据用户部门ID获取当前用户所属部门及下级部门Id
-        /// </summary>
-        /// <param name="RequiredOrgId"></param>
-        /// <returns></returns>
-        Task<List<string>> GetChildBMId(string? RequiredOrgId);
-
-        /// <summary>
-        /// 知识库-知识修改-查询详情
-        /// </summary>
-        /// <param name="Id"></param>
-        /// <returns></returns>
-        Task<Knowledge> KnowledgeUpdateInfo(string Id, CancellationToken cancellationToken);
-
         /// <summary>
         /// 知识库-查询详情-增加浏览量
         /// </summary>

src/Hotline/KnowledgeBase/IKnowledgeTypeService.cs → src/Hotline/KnowledgeBase/IKnowledgeTypeDomainService.cs

@@ -2,7 +2,7 @@
 
 namespace Hotline.KnowledgeBase
 {
-    public interface IKnowledgeTypeService
+    public interface IKnowledgeTypeDomainService
     {
         /// <summary>
         /// 查询所有子级

src/Hotline/KnowledgeBase/Knowledge.cs

@@ -44,7 +44,7 @@ public class Knowledge : WorkflowEntity// FullStateEntity
     /// <summary>
     /// 浏览量
     /// </summary>
-    public int PageView { get; set; }
+    public int PageView { get; set; } = 0;
 
     /// <summary>
     /// 是否公开

src/Hotline/KnowledgeBase/KnowledgeDomainService.cs

@@ -9,7 +9,6 @@ namespace Hotline.KnowledgeBase
 {
     public class KnowledgeDomainService : IKnowledgeDomainService, IScopeDependency
     {
-        private readonly IUserRepository _userRepository;
         private readonly IKnowledgeRepository _knowledgeRepository;
         private readonly IKnowledgeTempRepository _knowledgeTempRepository;
         private readonly IMapper _mapper;
@@ -18,61 +17,18 @@ namespace Hotline.KnowledgeBase
         /// <summary>
         /// 
         /// </summary>
-        /// <param name="userRepository"></param>
         /// <param name="knowledgeRepository"></param>
         /// <param name="knowledgeTempRepository"></param>
         /// <param name="mapper"></param>
         /// <param name="knowledgePVRepository"></param>
-        public KnowledgeDomainService(IUserRepository userRepository, IKnowledgeRepository knowledgeRepository, IKnowledgeTempRepository knowledgeTempRepository, IMapper mapper, IKnowledgePVRepository knowledgePVRepository)
+        public KnowledgeDomainService( IKnowledgeRepository knowledgeRepository, IKnowledgeTempRepository knowledgeTempRepository, IMapper mapper, IKnowledgePVRepository knowledgePVRepository)
         {
-            _userRepository = userRepository;
             _knowledgeRepository = knowledgeRepository;
             _mapper = mapper;
             _knowledgeTempRepository = knowledgeTempRepository;
             _knowledgePVRepository = knowledgePVRepository;
         }
 
-        /// <summary>
-        /// 根据用户ID获取当前用户所属部门及下级部门Id
-        /// </summary>
-        /// <param name="RequiredOrgId"></param>
-        /// <returns></returns>
-        public async Task<List<string>> GetChildBMId(string? RequiredOrgId)
-        {
-            List<string> list = new();
-            if (!string.IsNullOrEmpty(RequiredOrgId))
-            {
-                //根据父级获取子级信息
-                var tempList = await _knowledgeRepository.GetChild(RequiredOrgId);
-                //获取子级ID
-                list = tempList.Select(it => it.Id).ToList();
-            }
-            return list;
-        }
-
-        /// <summary>
-        /// 知识库-知识修改-查询详情
-        /// </summary>
-        /// <param name="Id"></param>
-        /// <returns></returns>
-        public async Task<Knowledge> KnowledgeUpdateInfo(string Id, CancellationToken cancellationToken)
-        {
-            //先查询正式数据，如果正式数据不存在在查询草稿箱
-            var know = await _knowledgeRepository.GetAsync(Id, cancellationToken);
-            if (know is null)
-            {
-                //查询草稿箱数据
-                var tempKnow = await _knowledgeTempRepository.GetAsync(Id, cancellationToken);
-                if (tempKnow != null)
-                {
-                    //草稿数据处理成通用返回数据
-                    know = new Knowledge();
-                    _mapper.Map(tempKnow, know);
-                }
-            }
-            return know;
-        }
-
         /// <summary>
         /// 知识库-查询详情-增加浏览量
         /// </summary>
@@ -178,9 +134,7 @@ namespace Hotline.KnowledgeBase
                     //处理数据
                     if (ApprovalStatus == "0")
                     {
-                        know.Status = EKnowledgeStatus.Succeed;
-                        know.IsOnShelf = true;
-                        know.OnShelfTime = DateTime.Now;
+                      
                     }
                     else
                     {

src/Hotline/KnowledgeBase/KnowledgeTypeService.cs → src/Hotline/KnowledgeBase/KnowledgeTypeDomainService.cs

@@ -6,7 +6,7 @@ using XF.Domain.Exceptions;
 
 namespace Hotline.KnowledgeBase
 {
-    public class KnowledgeTypeService : IKnowledgeTypeService, IScopeDependency
+    public class KnowledgeTypeDomainService : IKnowledgeTypeDomainService, IScopeDependency
     {
         /// <summary>
         /// 
@@ -20,7 +20,7 @@ namespace Hotline.KnowledgeBase
         /// </summary>
         /// <param name="knowledgeTypeRepository"></param>
         /// <param name="mapper"></param>
-        public KnowledgeTypeService(IKnowledgeTypeRepository knowledgeTypeRepository, IMapper mapper, IKnowledgeRepository knowledgeRepository)
+        public KnowledgeTypeDomainService(IKnowledgeTypeRepository knowledgeTypeRepository, IMapper mapper, IKnowledgeRepository knowledgeRepository)
         {
             _knowledgeTypeRepository = knowledgeTypeRepository;
             _mapper = mapper;
@@ -238,13 +238,13 @@ namespace Hotline.KnowledgeBase
                         await _knowledgeTypeRepository.UpdateAsync(item, cancellationToken);
                         //下架知识
                         //查询当前分类下的知识(查询条件：此分类下/状态为成功/未删除/已上架)
-                        var knowList = _knowledgeRepository.Queryable().Where(p => p.KnowledgeTypeId == item.Id && p.Status == EKnowledgeStatus.Succeed && p.IsDeleted == false && p.IsOnShelf == true).ToList();
+                        var knowList = _knowledgeRepository.Queryable().Where(p => p.KnowledgeTypeId == item.Id && p.Status == EKnowledgeStatus.OnShelf ).ToList();
                         if (knowList != null && knowList.Count > 0)
                         {
                             //修改知识为下架状态
                             foreach (var itemKnow in knowList)
                             {
-                                itemKnow.IsOnShelf = false;
+                                itemKnow.Status = EKnowledgeStatus.OffShelf;
                                 itemKnow.OffShelfTime = DateTime.Now;
                                 itemKnow.OnShelfTime = null;
                                 await _knowledgeRepository.UpdateAsync(itemKnow, cancellationToken);