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

using Hotline.Caching.Interfaces;
using Hotline.FlowEngine;
using Hotline.Repository.SqlSugar.Extensions;
using Hotline.Settings;
using Hotline.Settings.Hotspots;
using Hotline.Settings.TimeLimits;
using Hotline.Share.Dtos;
using Hotline.Share.Dtos.Settings;
using Hotline.Share.Enums.Order;
using Hotline.Share.Enums.Settings;
using MapsterMapper;
using Microsoft.AspNetCore.Mvc;
using StackExchange.Redis;
using XF.Domain.Exceptions;
using XF.Domain.Repository;
using XF.Utility.EnumExtensions;

namespace Hotline.Api.Controllers
{
    /// <summary>
    /// 热点
    /// </summary>
    public class HotspotController : BaseController
    {
        private readonly IRepository<Hotspot> _hotspotTypeRepository;
        private readonly IMapper _mapper;
        private readonly ITimeLimitDomainService _timeLimitDomainService;
        private readonly ITimeLimitRepository _timeLimitRepository;
        private readonly ISystemDicDataCacheManager _sysDicDataCacheManager;

        public HotspotController(IRepository<Hotspot> hotspotTypeRepository,
            IMapper mapper, ITimeLimitDomainService timeLimitDomainService, ITimeLimitRepository timeLimitRepository, ISystemDicDataCacheManager sysDicDataCacheManager)
        {
            _hotspotTypeRepository = hotspotTypeRepository;
            _mapper = mapper;
            _timeLimitDomainService = timeLimitDomainService;
            _timeLimitRepository = timeLimitRepository;
            _sysDicDataCacheManager = sysDicDataCacheManager;
        }

        #region 热点
        /// <summary>
        /// 查询子项
        /// </summary>
        [HttpGet("children")]
        public async Task<IReadOnlyList<Hotspot>> GetChildren([FromQuery] string? id)
        {
            return await _hotspotTypeRepository.Queryable()
                .Where(x => x.ParentId == id)
                .OrderBy(d => d.HotSpotName)
                .ToListAsync();
        }

        /// <summary>
        /// 查询热点数据（包含所有根目录及所查热点的所有上级对象）
        /// <remarks>
        /// 编辑页面使用
        /// </remarks>
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("{id}/with-parents")]
        public async Task<IReadOnlyList<Hotspot>> GetWithParents(string id)
        {
            var targetList = await _hotspotTypeRepository.Queryable()
                .ToTreeAsync(d => d.Children, d => d.ParentId, null, new[] { id });
            var topIds = targetList.Select(d => d.Id);
            var hotspots = await _hotspotTypeRepository.Queryable()
                .Where(d => string.IsNullOrEmpty(d.ParentId) && !topIds.Contains(d.Id))
                .ToListAsync();
            hotspots.AddRange(targetList);
            return hotspots.OrderBy(d => d.HotSpotName).ToList();
        }

        #endregion


        #region 时限管理

        /// <summary>
        /// 获取时限配置页面基础数据
        /// </summary>
        /// <returns></returns>
        [HttpGet("timelimit-basedata")]
        public async Task<object> GetTimeLimitBaseData()
        {
            return new
            {
                //ModuleOptions = WorkflowModule.Modules.ToList(),//todo
                TimeType = EnumExts.GetDescriptions<ETimeType>(),
                BaseData = TimeLimitBaseData.GetBaseData(),

                //AcceptType = EnumExts.GetDescriptions<EAcceptType>(),
                AcceptType = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.AcceptType),
                //PushType = _sysDicDataCacheManager.GetSysDicDataCache(TimeLimitBaseDataConsts.PushType),
                SourceChannel = _sysDicDataCacheManager.GetSysDicDataCache(TimeLimitBaseDataConsts.SourceChannel),
                IdentityType = EnumExts.GetDescriptions<EIdentityType>(),
                OrderType = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.OrderType),
                CertType = _sysDicDataCacheManager.GetSysDicDataCache(TimeLimitBaseDataConsts.LicenceType),
                EmergencyLevel = EnumExts.GetDescriptions<EEmergencyLevel>()
            };
        }

        /// <summary>
        /// 新增时限管理
        /// </summary>
        /// <param name="dto"></param>
        /// <returns>数据主键</returns>
        [HttpPost("add-timelimit")]
        public async Task<string> AddTimeLimit([FromBody] AddTimeLimitDto dto)
        {
            var model = _mapper.Map<TimeLimit>(dto);
            model.TimeLimitState = ETimeLimitState.Draft;
            return await _timeLimitDomainService.AddAsync(model, HttpContext.RequestAborted);
        }


        /// <summary>
        /// 修改时限管理
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost("update-timelimit")]
        public async Task UpdateTimeLimit([FromBody] UpdateTimeLimitDto dto)
        {
            var model = _mapper.Map<TimeLimit>(dto);
            await _timeLimitDomainService.UpdateAsync(model, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 获取对象
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("timelimit/{id}")]
        public async Task<TimeLimit?> GetTimeLimit(string id)
        {
            return await _timeLimitRepository.GetAsync(id, HttpContext.RequestAborted);
        }


        /// <summary>
        /// 获取时限管理列表
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpGet("paged-timelimit")]
        public async Task<PagedDto<TimeLimit>> QueryPagedTimeLimit([FromQuery] QueryPagedTimeLimitPagedDto dto)
        {
            var (total, items) = await _timeLimitRepository.Queryable()
                .WhereIF(!string.IsNullOrEmpty(dto.Keyword), d => d.TimeLimitName.Contains(dto.Keyword!))
                .OrderByDescending(d => d.CreationTime)
                .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
            return new PagedDto<TimeLimit>(total, _mapper.Map<IReadOnlyList<TimeLimit>>(items));
        }

        /// <summary>
        /// 删除时限（草稿）
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpDelete("deltimelimit")]
        public async Task DelTimeLimit(string id)
        {
            var model = await _timeLimitRepository.GetAsync(id, HttpContext.RequestAborted);
            if (model == null)
            {
                throw UserFriendlyException.SameMessage("无效数据");
            }
            if (model.TimeLimitState != ETimeLimitState.Draft)
            {
                throw UserFriendlyException.SameMessage("无法删除，请刷新页面");
            }
            await _timeLimitRepository.RemoveAsync(id, true, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 启用时限
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("enable-timelimit/{id}")]
        public async Task EnableTimeLimit(string id)
        {
            var model = await _timeLimitRepository.GetAsync(id, HttpContext.RequestAborted);
            if (model == null)
            {
                throw UserFriendlyException.SameMessage("无效数据");
            }
            if (model.TimeLimitState == ETimeLimitState.Enable)
            {
                throw UserFriendlyException.SameMessage("该配置已生效");
            }
            var list = await _timeLimitRepository.QueryAsync(x => x.WorkflowCode == model.WorkflowCode && x.TimeLimitState == ETimeLimitState.Enable);
            list.ForEach(x => x.TimeLimitState = ETimeLimitState.Disable);
            model.TimeLimitState = ETimeLimitState.Enable;
            list.Add(model);
            await _timeLimitRepository.UpdateRangeAsync(list, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 禁用时限
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("disable-timelimit/{id}")]
        public async Task DisableTimeLimit(string id)
        {
            var model = await _timeLimitRepository.GetAsync(id, HttpContext.RequestAborted);
            if (model == null)
            {
                throw UserFriendlyException.SameMessage("无效数据");
            }
            if (model.TimeLimitState == ETimeLimitState.Draft)
            {
                throw UserFriendlyException.SameMessage("该配置未生效，无法禁用");
            }
            if (model.TimeLimitState == ETimeLimitState.Disable)
            {
                throw UserFriendlyException.SameMessage("该配置已禁用");
            }
            model.TimeLimitState = ETimeLimitState.Disable;
            await _timeLimitRepository.UpdateAsync(model, HttpContext.RequestAborted);
        }
        #endregion


        #region 工作日设定





        #endregion
    }
}