hotline/src/Hotline.Api/Controllers/KnowledgeApplyController.cs

using Hotline.Application.Knowledge;
using Hotline.KnowledgeBase;
using Hotline.Permissions;
using Hotline.Repository.SqlSugar.Extensions;
using Hotline.Share.Dtos;
using Hotline.Share.Dtos.Knowledge;
using Hotline.Share.Enums.KnowledgeBase;
using Hotline.Share.Requests;
using MapsterMapper;
using Microsoft.AspNetCore.Mvc;
using XF.Domain.Authentications;
using XF.Domain.Exceptions;

namespace Hotline.Api.Controllers
{
    /// <summary>
    /// 
    /// </summary>
    public class KnowledgeApplyController : BaseController
    {
        private readonly IKnowledgeRepository _knowledgeRepository;
        private readonly IKnowledgeApplyRepository _knowledgeApplyRepository;
        private readonly ISessionContext _sessionContext;
        private readonly IMapper _mapper;
        private readonly IKnowApplication _knowApplication;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="knowledgeRepository"></param>
        /// <param name="knowledgeApplyRepository"></param>
        /// <param name="sessionContext"></param>
        /// <param name="mapper"></param>
        /// <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>
        /// 知识申请-发起申请
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.KnowledgeApplyAdd)]
        [HttpPost("add")]
        public async Task<string> AddApply([FromBody] KnowledgeApplyDto dto)
        {
            var ka = _mapper.Map<KnowledgeApply>(dto);
            ka.Status = EKnowledgeApplyStatus.Handling;
            return await _knowledgeApplyRepository.AddAsync(ka, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 知识申请-修改申请
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.KnowledgeUpdateAdd)]
        [HttpPut("update")]
        public async Task UpdateApply([FromBody] UpdateKnowledgeApplyDto dto)
        {
            var ka = _mapper.Map<KnowledgeApply>(dto);
            await _knowledgeApplyRepository.UpdateAsync(ka, HttpContext.RequestAborted);
        }

        /// <summary>
        ///知识申请-信息办理
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.KnowApplyHandle)]
        [HttpPut("handle")]
        public async Task HandleApply([FromBody] KnowledgeApplyHandleDto dto)
        {
            //查询申请信息
            var handle = await _knowledgeApplyRepository.GetAsync(dto.Id, HttpContext.RequestAborted);

            if (handle is null || handle.Status != EKnowledgeApplyStatus.Handling)
                throw UserFriendlyException.SameMessage("办理失败");
            handle.Status = EKnowledgeApplyStatus.Succeed;
            handle.HandleTime = DateTime.Now;
            handle.KnowledgeId = dto.KnowledgeId;
            handle.Opinion = dto.Opinion;
            //修改办理信息
            await _knowledgeApplyRepository.UpdateAsync(handle, HttpContext.RequestAborted);
        }

        /// <summary>
        ///知识申请- 撤销操作
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        [Permission(EPermission.KnowledgeApplyRevoke)]
        [HttpPut("apply-handle/{Id}")]
        public async Task RevokeApply(string Id)
        {
            var handle = await _knowledgeApplyRepository.GetAsync(Id, HttpContext.RequestAborted);
            if (handle is null)
                throw UserFriendlyException.SameMessage("申请信息撤销失败");
            if (handle.Status != EKnowledgeApplyStatus.Handling)
                throw UserFriendlyException.SameMessage("只能撤销办理中的申请");
            handle.Status = EKnowledgeApplyStatus.Revert;
            await _knowledgeApplyRepository.UpdateAsync(handle, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 知识申请-退回操作
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.KnowledgeApplyReturn)]
        [HttpPut("return")]
        public async Task ReturnApply([FromBody] KnowledgeApplyReturnDto dto)
        {
            //查询申请信息
            var handle = await _knowledgeApplyRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
            if (handle is null)
                throw UserFriendlyException.SameMessage("退回失败");
            if (handle.Status != EKnowledgeApplyStatus.Handling)
                throw UserFriendlyException.SameMessage("只能退回办理中的申请");
            if (string.IsNullOrEmpty(dto.Opinion))
                throw UserFriendlyException.SameMessage("退回原因不能为空");
            handle.Status = EKnowledgeApplyStatus.Failed;
            handle.ReturnTime = DateTime.Now;
            handle.Opinion = dto.Opinion;
            await _knowledgeApplyRepository.UpdateAsync(handle, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 删除申请
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        [Permission(EPermission.KnowledgeApplyDelete)]
        [HttpDelete("remove")]
        public async Task RemoveApply(string Id)
        {
            var handle = await _knowledgeApplyRepository.GetAsync(Id, HttpContext.RequestAborted);
            if (handle is null)
                throw UserFriendlyException.SameMessage("申请不存在");
            if (handle.Status != EKnowledgeApplyStatus.Revert || handle.Status != EKnowledgeApplyStatus.Failed)
                throw UserFriendlyException.SameMessage("只能删除已退回或者撤回的知识申请");
            await _knowledgeApplyRepository.RemoveAsync(handle, false, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 知识申请-查询详情
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        [HttpGet("info/{Id}")]
        public async Task<DataKnowledgeApplyDto> GetApply(string Id)
        {
            var handle = await _knowledgeApplyRepository.GetAsync(Id, HttpContext.RequestAborted);
            if (handle is null)
                throw UserFriendlyException.SameMessage("申请信息查询失败");
            DataKnowledgeApplyDto dataKnowledgeApplyDto = new();
            _mapper.Map(handle, dataKnowledgeApplyDto);

            var knowledge = await _knowledgeRepository.GetAsync(p => p.Id == handle.KnowledgeId, HttpContext.RequestAborted);
            if (knowledge != null)
            {
                dataKnowledgeApplyDto.KBID = knowledge.Id;
                dataKnowledgeApplyDto.KBTitle = knowledge.Title;
            }

            return dataKnowledgeApplyDto;
        }

        /// <summary>
        /// 查询-新增知识申请
        /// </summary>
        /// <param name="pagedDto"></param>
        /// <returns></returns>
        [HttpGet("addapply")]
        public async Task<PagedDto<DataAddApplyDto>> GetAddApply([FromQuery] PagedRequest pagedDto)
        {
            var (total, items) = await _knowledgeApplyRepository
               .Queryable()
               .Where(d => d.CreatorId == _sessionContext.RequiredUserId && d.KnowledgeApplyType == EKnowledgeApplyType.Add && d.Status == EKnowledgeApplyStatus.Handling)
               .OrderByDescending(p => p.CreationTime)
               .ToPagedListAsync(pagedDto.PageIndex, pagedDto.PageSize, HttpContext.RequestAborted);

            return new PagedDto<DataAddApplyDto>(total, _mapper.Map<IReadOnlyList<DataAddApplyDto>>(items));
        }

        #region 我的知识申请
        /// <summary>
        /// 我的知识申请--全部
        /// </summary>
        /// <returns></returns>
        [Permission(EPermission.KnowledgeAllApply)]
        [HttpGet()]
        public async Task<PagedDto<KnowledgeApply>> GetApplyList([FromQuery] KnowledgeApplyPagedDto dto)
        {
            return await _knowApplication.GetApplyList(dto, HttpContext.RequestAborted);
        }

        #endregion

        #region 知识申请处理查询
        /// <summary>
        /// 申请处理查询
        /// </summary>
        /// <returns></returns>
        [HttpGet("handlelist")]
        public async Task<PagedDto<KnowledgeApplyPageDto>> AllHandle([FromQuery] KnowledgeHandlePagedDto dto)
        {
            return await _knowApplication.GetApplyHandleList(dto, HttpContext.RequestAborted);
        }

        #endregion
    }
}