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

using Hotline.KnowledgeBase;
using Hotline.Permissions;
using Hotline.Share.Dtos.Knowledge;
using MapsterMapper;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using XF.Domain.Exceptions;

namespace Hotline.Api.Controllers
{
    /// <summary>
    /// 
    /// </summary>
    public class KnowledgeCommonController : BaseController
    {
        private readonly IKnowledgeTypeRepository _knowledgeTypeRepository;
        private readonly IKnowledgeRepository _knowledgeRepository;
        private readonly IKnowledgeTypeService _knowledgeTypeService;
        private readonly IKnowledgeStandardRepository _knowledgeStandardRepository;
        private readonly IMapper _mapper;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="knowledgeRepository"></param>
        /// <param name="knowledgeTypeRepository"></param>
        /// <param name="knowledgeTypeService"></param>
        /// <param name="knowledgeStandardRepository"></param>
        /// <param name="mapper"></param>
        public KnowledgeCommonController(IKnowledgeRepository knowledgeRepository, IKnowledgeTypeRepository knowledgeTypeRepository, IKnowledgeTypeService knowledgeTypeService,
            IKnowledgeStandardRepository knowledgeStandardRepository,
            IMapper mapper)
        {
            _knowledgeRepository = knowledgeRepository;
            _knowledgeTypeRepository = knowledgeTypeRepository;
            _knowledgeTypeService = knowledgeTypeService;
            _knowledgeStandardRepository = knowledgeStandardRepository;
            _mapper = mapper;
        }

        #region 知识分类

        /// <summary>
        ///知识分类- 新增
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.AddKnowledgeType)]
        [HttpPost("type-add")]
        public async Task<string> TypeAdd([FromBody] AddKnowledgeTypeDto dto)
        {
            return await _knowledgeTypeService.TypeAdd(dto, HttpContext.RequestAborted);
        }

        /// <summary>
        ///知识分类- 编辑
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.UpdateKnowledgeType)]
        [HttpPost("type-update")]
        public async Task TypeUpdate([FromBody] UpdateKnowledgeTypeDto dto)
        {
            await _knowledgeTypeService.TypeUpdate(dto, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 知识分类-新增、编辑初始化
        /// </summary>
        /// <param name="Id"></param>
        /// <param name="ParentId"></param>
        /// <returns></returns>
        [HttpGet("type-init")]
        public async Task<KnowledgeTypeDto> TypeInit(string Id, string ParentId)
        {
            return await _knowledgeTypeService.TypeInit(Id, ParentId, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 知识分类-查询详情
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        [HttpGet("type-info")]
        public async Task<KnowledgeType> TypeInfo(string Id)
        {
            var types = await _knowledgeTypeRepository.GetAsync(Id, HttpContext.RequestAborted);
            if (types is null)
                throw UserFriendlyException.SameMessage("查询失败！");
            return types;
        }

        /// <summary>
        /// 知识分类-删除
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        [Permission(EPermission.RemoveKnowledgeType)]
        [HttpDelete("type-delete")]
        public async Task TypeDelete(string Id)
        {
            await _knowledgeTypeService.TypeDelete(Id, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 知识分类-启用、禁用切换
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        [Permission(EPermission.KnowledgeTypeChangeState)]
        [HttpGet("type-changestate")]
        public async Task TypeChangeState(string Id)
        {
            await _knowledgeTypeService.TypeChangeState(Id, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 知识分类-禁用，并且下架知识
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        [Permission(EPermission.KnowledgeTypeChangeStateAndOffShelf)]
        [HttpGet("type-changestateandoffshelf")]
        public async Task TypeChangeStateAndOffShelf(string Id)
        {
            await _knowledgeTypeService.TypeChangeStateAndOffShelf(Id, HttpContext.RequestAborted);
        }

        /// <summary>
        ///知识分类- 获取层级分类
        /// </summary>
        /// <returns></returns>
        [Permission(EPermission.KnowledgeTypeMange)]
        [HttpPost("type-treelist")]
        public async Task<List<KnowledgeType>> GetTreeList(string id)
        {
            return await _knowledgeTypeRepository.GetTree(Guid.Empty.ToString());
        }

        #endregion

        #region 编写规范
        /// <summary>
        /// 编写规范-查询详情
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        [HttpGet("standard-info")]
        public async Task<KnowledgeStandard> StandardInfo(string Id)
        {
            if (string.IsNullOrEmpty(Id))
                throw UserFriendlyException.SameMessage("ID不能为空！");

            var sandard = await _knowledgeStandardRepository.GetAsync(Id, HttpContext.RequestAborted);
            if (sandard is null)
                throw UserFriendlyException.SameMessage("编写规范查询失败！");
            return sandard;
        }

        /// <summary>
        /// 编写规范-删除
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        [Permission(EPermission.RemoveKnowledgeStandard)]
        [HttpDelete("standard-delete")]
        public async Task StandardDelete(string Id)
        {
            if (string.IsNullOrEmpty(Id))
                throw UserFriendlyException.SameMessage("ID不能为空！");
            //删除操作
            await _knowledgeStandardRepository.RemoveAsync(Id, false, HttpContext.RequestAborted);

        }

        /// <summary>
        /// 编写规范-新增
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.KnowledgeStandardAdd)]
        [HttpPost("standard-add")]
        public async Task StandardAdd([FromBody] AddKnowledgeStandardDto dto)
        {
            var sandard = _mapper.Map<KnowledgeStandard>(dto);
            sandard.CreationTime = DateTime.Now;
            await _knowledgeStandardRepository.AddAsync(sandard, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 编写规范-修改
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.KnowledgeStandardUpdate)]
        [HttpPost("standard-update")]
        public async Task StandardUpdate([FromBody] UpdateKnowledgeStandardDto dto)
        {
            var sandard = _mapper.Map<KnowledgeStandard>(dto);
            await _knowledgeStandardRepository.UpdateAsync(sandard, HttpContext.RequestAborted);
        }
        #endregion

    }
}