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

using Hotline.Permissions;
using Hotline.Repository.SqlSugar.System;
using Hotline.Settings;
using Hotline.Share.Dtos;
using Hotline.Share.Dtos.Dic;
using Hotline.Share.Dtos.Menu;
using Hotline.Share.Dtos.Trunk;
using Hotline.Share.Requests;
using MapsterMapper;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using System.Diagnostics.CodeAnalysis;
using XF.Domain.Exceptions;
using XF.Utility.UnifyResponse;

namespace Hotline.Api.Controllers
{
    /// <summary>
    ///  系统管理相关接口
    /// </summary>
    public class SysController : BaseController
    {
        private readonly IMapper _mapper;
        private readonly ISystemSettingRepository _systemSettingsRepository;
        private readonly ISystemSettingGroupRepository _systemSettingGroupRepository;
        private readonly ISystemMenuRepository _systemMenuRepository;
        private readonly ISystemButtonRepository _systemButtonRepository;
        private readonly ISysDicTypeRepository _sysDicTypeRepository;
        private readonly ISysDicDataRepository _sysDicDataRepository;
        

        /// <summary>
        /// 系统管理相关接口
        /// </summary>
        /// <param name="mapper"></param>
        /// <param name="systemSettingsRepository"></param>
        /// <param name="systemSettingGroupRepository"></param>
        /// <param name="systemMenuRepository"></param>
        /// <param name="systemButtonRepository"></param>
        /// <param name="sysDicDataRepository"></param>
        /// <param name="sysDicTypeRepository"></param>
        public SysController(
            IMapper mapper,
            ISystemSettingRepository systemSettingsRepository,
            ISystemSettingGroupRepository systemSettingGroupRepository,
            ISystemMenuRepository systemMenuRepository,
            ISystemButtonRepository systemButtonRepository,
            ISysDicTypeRepository sysDicTypeRepository,
            ISysDicDataRepository sysDicDataRepository)
        {
            _mapper = mapper;
            _systemSettingsRepository = systemSettingsRepository;
            _systemSettingGroupRepository = systemSettingGroupRepository;
            _systemMenuRepository = systemMenuRepository;
            _systemButtonRepository = systemButtonRepository;
            _sysDicTypeRepository = sysDicTypeRepository;
            _sysDicDataRepository = sysDicDataRepository;
        }

        #region 系统参数

        /// <summary>
        /// 获取系统参数列表
        /// </summary>
        /// <returns></returns>
        [Permission(EPermission.GetSysSettingsAsync)]
        [HttpGet("getsyssettings")]
        public async Task<List<SystemSettingGroup>> GetSysSettingsAsync()
        {
            return await _systemSettingGroupRepository.QueryExtAsync(x => true, x => x.Includes(d => d.SystemSettings));
        }

        /// <summary>
        /// 更新配置
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        [Permission(EPermission.ModifySettings)]
        [HttpPost("modifysettings")]
        public async Task ModifySettings([FromBody] ModifySettingsRequest request)
        {
            for (int i = 0; i < request.list.Count; i++)
            {
                var model = await _systemSettingsRepository.GetAsync(x => x.Id == request.list[i].id, HttpContext.RequestAborted);
                if (model != null)
                {
                    model.SettingValue = request.list[i].value;
                    await _systemSettingsRepository.UpdateAsync(model, HttpContext.RequestAborted);
                }
            }
        }


        #endregion

        #region 菜单管理
        /// <summary>
        /// 获取菜单
        /// </summary>
        /// <returns></returns>
        //[Permission(EPermission.GetMenuJson)]
        [AllowAnonymous]
        [HttpGet("getmenujson")]
        public async Task<IReadOnlyList<SystemMenu>> GetMenuJson()
        {
            //获取菜单树形
            return await _systemMenuRepository.GetSystemMenus();
        }

        /// <summary>
        /// 新增菜单
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.AddMenu)]
        [HttpPost("add-menu")]
        public async Task AddMenu([FromBody] AddMenuDto dto)
        {
            var menu = _mapper.Map<SystemMenu>(dto);
            await _systemMenuRepository.AddAsync(menu,HttpContext.RequestAborted);
        }

        /// <summary>
        /// 修改菜单
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.UpdateMenu)]
        [HttpPost("update-menu")]
        public async Task UpdateMenu([FromBody] UpdateMenuDto dto)
        {
            var menu = await _systemMenuRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
            if (menu is null)
                throw UserFriendlyException.SameMessage("无效菜单");

            _mapper.Map(dto, menu);
            await _systemMenuRepository.UpdateAsync(menu, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 删除菜单
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [Permission(EPermission.RemoveMenu)]
        [HttpDelete("removemenu/{id}")]
        public async Task RemoveMenu(string id)
        {
            var menu = await _systemMenuRepository.GetAsync(id, HttpContext.RequestAborted);
            if (menu is null)
                throw UserFriendlyException.SameMessage("无效菜单");
            //检查是否存在下级菜单
            var ishavemenu = await _systemMenuRepository.AnyAsync(x => x.ParentId == id);
            if (ishavemenu)
                throw UserFriendlyException.SameMessage("存在下级菜单，暂时不能删除");
            //检查是否存在按钮
            var ishavebutton = await _systemButtonRepository.AnyAsync(x => x.MenuId == id);
            if (ishavebutton)
                throw UserFriendlyException.SameMessage("存在按钮权限，暂时不能删除");

            await _systemMenuRepository.RemoveAsync(id, false, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 获取菜单对象
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [Permission(EPermission.GetMenu)]
        [HttpGet("menu/{id}")]
        public async Task<SystemMenu> GetMenu(string id)
        {
            var menu = await _systemMenuRepository.GetAsync(id, HttpContext.RequestAborted);
            if (menu is null)
                throw UserFriendlyException.SameMessage("无效菜单");
            return menu;
        }

        #region 按钮管理

        /// <summary>
        /// 通过菜单ID获取按钮列表
        /// </summary>
        /// <param name="menuid"></param>
        /// <returns></returns>
        [Permission(EPermission.GetButtonByMenu)]
        [HttpGet("getbuttonmenu")]
        public async Task<IReadOnlyList<SystemButton>> GetButtonByMenu(string menuid)
        {
            return await _systemButtonRepository.QueryAsync(x => x.MenuId == menuid);
        }

        /// <summary>
        /// 新增按钮
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.AddButton)]
        [HttpPost("add-button")]
        public async Task AddButton([FromBody] AddButtonDto dto)
        {
            var button = _mapper.Map<SystemButton>(dto);
            await _systemButtonRepository.AddAsync(button);
        }

        /// <summary>
        /// 编辑按钮
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.UpdateButton)]
        [HttpPost("update-button")]
        public async Task UpdateButton([FromBody] UpdateButtonDto dto)
        {
            var button = await _systemButtonRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
            if (button is null)
                throw UserFriendlyException.SameMessage("无效按钮");
            _mapper.Map(dto, button);
            await _systemButtonRepository.UpdateAsync(button);
        }

        /// <summary>
        /// 删除按钮
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [Permission(EPermission.RemoveButton)]
        [HttpDelete("removebutton/{id}")]
        public async Task RemoveButton(string id)
        {
            var button = await _systemButtonRepository.GetAsync(id, HttpContext.RequestAborted);
            if (button is null)
                throw UserFriendlyException.SameMessage("无效按钮");
            await _systemButtonRepository.RemoveAsync(id, false, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 获取按钮对象
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [Permission(EPermission.GetButton)]
        [HttpGet("button/{id}")]
        public async Task<SystemButton> GetButton(string id)
        {
            var button = await _systemButtonRepository.GetAsync(id, HttpContext.RequestAborted);
            if (button is null)
                throw UserFriendlyException.SameMessage("无效按钮");
            return button;
        }


        #endregion
        #endregion

        #region 字典管理

        /// <summary>
        /// 获取字典类型列表
        /// </summary>
        /// <returns></returns>
        [Permission(EPermission.GetSysDicType)]
        [HttpPost("dictype-list")]
        public async Task<List<SysDicType>> GetSysDicType()
        {
            return await _sysDicTypeRepository.Queryable().ToListAsync();
        }

        /// <summary>
        /// 根据字典类型ID获取字典列表
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.GetSysDicData)]
        [HttpGet("dictdata-type")]
        public async Task<List<SysDicData>> GetSysDicData([FromQuery] GetSysDicDataDto dto)
        {
            return await _sysDicDataRepository.Queryable().Where(x => x.DicTypeId == dto.typeid).WhereIF(!string.IsNullOrEmpty(dto.datavalue),x=>x.DicDataValue.Contains(dto.datavalue)).ToTreeAsync(x=>x.Children,x=>x.ParentId,"");
        }

        /// <summary>
        /// 根据字典类型Code获取字典列表
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        [HttpGet("dictdata-code/{code}")]
        public async Task<List<SysDicData>> GetSysDicDataByCode(string code)
        {
            return await _sysDicDataRepository.Queryable().Where(x => x.DicTypeCode == code).ToListAsync();
        }
         
        /// <summary>
        /// 获取字典对象
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [Permission(EPermission.SysDicDataModel)]
        [HttpGet("dicdata/{id}")]
        public async Task<SysDicData> SysDicDataModel(string id)
        {
            var dicData = await _sysDicDataRepository.GetAsync(id, HttpContext.RequestAborted);
            if (dicData is null)
                throw UserFriendlyException.SameMessage("无效数据");
            return dicData;
        }

        /// <summary>
        /// 新增字典数据
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.AddDicData)]
        [HttpPost("add-dicdata")]
        public async Task AddDicData([FromBody] AddDicDataDto dto)
        {
            var dicType = await _sysDicTypeRepository.GetAsync(dto.DicTypeId, HttpContext.RequestAborted);
            if (dicType is null)
                throw UserFriendlyException.SameMessage("无效字典类型");
            var dicData = _mapper.Map<SysDicData>(dto);
            dicData.DicTypeCode = dicType.DicTypeCode;
            await _sysDicDataRepository.AddAsync(dicData);
        }

        /// <summary>
        /// 修改字典数据
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [Permission(EPermission.UpdateDicData)]
        [HttpPost("update-dicdata")]
        public async Task UpdateDicData([FromBody]UpdateDicDataDto dto)
        {
            var dicData = await _sysDicDataRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
            if (dicData is null)
                throw UserFriendlyException.SameMessage("无效字典数据");
            var dicType = await _sysDicTypeRepository.GetAsync(dto.DicTypeId, HttpContext.RequestAborted);
            if (dicType is null)
                throw UserFriendlyException.SameMessage("无效字典类型");
            _mapper.Map(dto, dicData);
            dicData.DicTypeCode = dicType.DicTypeCode;
            await _sysDicDataRepository.UpdateAsync(dicData,HttpContext.RequestAborted);
        }

        #endregion


       
    }
}