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

using Hotline.KnowledgeBase;
using Hotline.Share.Dtos.Knowledge;
using MapsterMapper;
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>
        [HttpPost("type-add")]
        public async Task<string> TypeAdd([FromBody] AddKnowledgeTypeDto dto)
        {
            var type = _mapper.Map<KnowledgeType>(dto);
            type.CreationTime = DateTime.Now;
            type.IsEnable = true;
            string FullName = await _knowledgeTypeService.GetFullName(type.ParentId);
            type.SpliceName = string.IsNullOrEmpty(FullName) ? dto.Name : FullName + "-" + dto.Name;
            return await _knowledgeTypeRepository.AddAsync(type);
        }

        /// <summary>
        ///知识分类- 编辑
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost("type-update")]
        public async Task TypeUpdate([FromBody] UpdateKnowledgeTypeDto dto)
        {
            //查询原有数据
            var type = await _knowledgeTypeRepository.GetAsync(dto.Id);
            if (type is null)
                throw UserFriendlyException.SameMessage("编辑失败！");

            bool result = false;
            //是否更改分类名称
            if (type.Name != dto.Name)
                result = true;
            //转换
            _mapper.Map(dto, type);
            //如果更改了名称，则修改全程，为更改不修改
            if (result)
            {
                string FullName = await _knowledgeTypeService.GetFullName(type.ParentId);
                type.SpliceName = string.IsNullOrEmpty(FullName) ? dto.Name : FullName + "-" + dto.Name;
            }
            //修改数据
            await _knowledgeTypeRepository.UpdateAsync(type);
            //如果修改了名称，对应修改子分类全称
            if (result)
                await _knowledgeTypeService.UpdateChildNode(type.Id);
        }

        /// <summary>
        /// 知识分类-新增、编辑初始化
        /// </summary>
        /// <param name="Id"></param>
        /// <param name="ParentId"></param>
        /// <returns></returns>
        [HttpGet("type-init")]
        public async Task<KnowledgeTypeDto> TypeInit(string Id, string ParentId)
        {
            KnowledgeTypeDto knowledgeTypeDto = new();
            if (!string.IsNullOrEmpty(Id))
            {
                var type = await _knowledgeTypeRepository.GetAsync(p => p.Id == Id);
                _mapper.Map(type, knowledgeTypeDto);
            }
            var list = await _knowledgeTypeRepository.QueryAsync(p => p.IsEnable == true);
            if (!string.IsNullOrEmpty(ParentId) && ParentId != Guid.Empty.ToString())
            {
                knowledgeTypeDto.TreeLists = _knowledgeTypeService.GetChildren(list, Guid.Empty.ToString(), ParentId);
            }
            else
            {
                knowledgeTypeDto.TreeLists = _knowledgeTypeService.GetChildren(list, Guid.Empty.ToString(), "");
            }
            return knowledgeTypeDto;
        }

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

        /// <summary>
        /// 知识分类-删除
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        [HttpDelete("type-delete")]
        public async Task TypeDelete(string Id)
        {
            //查询数据是否存在
            var sandard = await _knowledgeTypeRepository.GetAsync(Id);
            if (sandard is null)
                throw UserFriendlyException.SameMessage("分类不存在！");

            //查询是否有子级分类

            var checkChild = await _knowledgeTypeRepository.CountAsync(p => p.ParentId == Id);
            if (checkChild > 0)
                throw UserFriendlyException.SameMessage("存在子级分类！");

            //查询是否有知识分类
            var checkKnowledge = await _knowledgeRepository.CountAsync(p => p.KnowledgeTypeId == Id);
            if (checkKnowledge > 0)
                throw UserFriendlyException.SameMessage("分类存在知识！");

            //删除操作
            await _knowledgeTypeRepository.RemoveAsync(sandard, true);

        }

        /// <summary>
        /// 知识分类-启用、禁用切换
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        [HttpGet("type-changestate")]
        public async Task TypeChangeState(string Id)
        {
            //查询数据是否存在
            var type = await _knowledgeTypeRepository.GetAsync(Id);
            if (type is null)
                throw UserFriendlyException.SameMessage("分类不存在！");
            if (type.IsEnable)//禁用
            {
                //查询是否有子级，如果有子级启用，则不能禁用
                var checkChild = await _knowledgeTypeRepository.CountAsync(p => p.ParentId == Id && p.IsEnable == true);
                if (checkChild > 0)
                    throw UserFriendlyException.SameMessage("请先禁用子级分类！");
                type.IsEnable = false;
            }
            else //启用
            {
                //查询上级是否是启用状态，如果是禁用状态不能修改
                var CheckParent = await _knowledgeTypeRepository.GetAsync(type.ParentId);
                if (CheckParent is null)
                    throw UserFriendlyException.SameMessage("分类启用失败！");
                if (!CheckParent.IsEnable)
                    throw UserFriendlyException.SameMessage("请先启用父级分类！");

                //将状态修改为启用
                type.IsEnable = true;
            }
            await _knowledgeTypeRepository.UpdateAsync(type);
        }

        /// <summary>
        ///知识分类- 获取层级分类
        /// </summary>
        /// <param name="IsAll">如果为true查询全部分类，包括禁用的；如果false查询启用的分类</param>
        /// <returns></returns>
        [HttpPost("type-treelist")]
        public async Task<List<TreeListDto>> GetTreeList(bool IsAll)
        {
            List<KnowledgeType> typeList;
            if (IsAll)//查询全部
            {
                typeList = await _knowledgeTypeRepository.QueryAsync();
            }
            else//查询启用的
            {
                typeList = await _knowledgeTypeRepository.QueryAsync(p => p.IsEnable == true);
            }

            return _knowledgeTypeService.GetChildren(typeList, 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);
            if (sandard is null)
                throw UserFriendlyException.SameMessage("编写规范查询失败！");
            return sandard;
        }

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

        }

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

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

    }
}