LMS.service/LMS.service/Service/OptionsService.cs

using AutoMapper;
using LMS.Common.Dictionary;
using LMS.DAO;
using LMS.Repository.DB;
using LMS.Repository.DTO;
using LMS.Repository.DTO.UserDto;
using LMS.Repository.Models.DB;
using LMS.Repository.Options;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using static LMS.Common.Enums.ResponseCodeEnum;

namespace LMS.service.Service
{
    public class OptionsService(ApplicationDbContext context, UserManager<User> userManager, IMapper mapper)
    {
        private readonly ApplicationDbContext _context = context;
        private readonly UserManager<User> _userManager = userManager;
        private readonly IMapper _mapper = mapper;

        #region 获取简单的配置项，无需权限

        /// <summary>
        /// 获取简单的配置项，无需权限
        /// </summary>
        /// <param name="optionsKey">配置项键</param>
        /// <returns>API响应模型</returns>
        internal async Task<ActionResult<APIResponseModel<List<OptionsDto>>>> GetSimpleOptions(string optionsKey)
        {
            try
            {
                if (!SimpleOptions.SimpleOptionsRequestQuery.TryGetValue(optionsKey, out List<string>? value))
                {
                    return APIResponseModel<List<OptionsDto>>.CreateErrorResponseModel(ResponseCode.ParameterError);
                }

                // 从数据库中获取配置项
                List<Options> options = await _context.Options.Where(x => value.Contains(x.Key)).ToListAsync();
                if (options == null || options.Count <= 0)
                {
                    return APIResponseModel<List<OptionsDto>>.CreateErrorResponseModel(ResponseCode.FindOptionsFail);
                }
                else
                {
                    List<OptionsDto> optionsDto = options.Select(x => _mapper.Map<OptionsDto>(x)).ToList();

                    return APIResponseModel<List<OptionsDto>>.CreateSuccessResponseModel(optionsDto);
                }
            }
            catch (Exception ex)
            {
                return APIResponseModel<List<OptionsDto>>.CreateErrorResponseModel(ResponseCode.SystemError, ex.Message);
            }
        }
        #endregion

        #region 获取所有的配置项，需要管理员权限

        /// <summary>
        /// 获取所有的配置项，需要管理员权限
        /// </summary>
        /// <param name="requestUserId">请求用户ID</param>
        /// <returns>API响应模型</returns>
        internal async Task<ActionResult<APIResponseModel<List<OptionsDto>>>> GetAllOptions(string optionsKey, long requestUserId)
        {
            try
            {
                User? user = await _userManager.FindByIdAsync(requestUserId.ToString());
                if (user == null)
                {
                    return APIResponseModel<List<OptionsDto>>.CreateErrorResponseModel(ResponseCode.FindUserByIdFail);
                }

                bool isAdminOrSuperAdmin = await _userManager.IsInRoleAsync(user, "Admin") || await _userManager.IsInRoleAsync(user, "Super Admin");
                // 判断用户是不是管理员
                if (!isAdminOrSuperAdmin)
                {
                    return APIResponseModel<List<OptionsDto>>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
                }


                IQueryable<Options> query = _context.Options;
                if (optionsKey != "all")
                {
                    List<string> optionsKeyName = [];
                    if (AllOptions.AllOptionsRequestQuery.TryGetValue(optionsKey, out List<string>? value))
                    {
                        optionsKeyName = value;
                    }
                    else
                    {
                        return APIResponseModel<List<OptionsDto>>.CreateErrorResponseModel(ResponseCode.ParameterError);
                    }
                    query = query.Where(x => optionsKeyName.Contains(x.Key));
                }

                List<Options> options = await query.ToListAsync();
                List<OptionsDto> optionsDto = options.Select(x => new OptionsDto
                {
                    Key = x.Key,
                    Value = x.Value,
                    Type = x.Type,
                }).ToList();
                return APIResponseModel<List<OptionsDto>>.CreateSuccessResponseModel(optionsDto);
            }
            catch (Exception ex)
            {
                return APIResponseModel<List<OptionsDto>>.CreateErrorResponseModel(ResponseCode.SystemError, ex.Message);
            }
        }

        #endregion

        #region 修改配置项

        /// <summary>
        /// 修改配置项
        /// </summary>
        /// <param name="models">要修改的配置项模型列表</param>
        /// <param name="userId">用户ID</param>
        /// <returns>API响应模型</returns>
        internal async Task<ActionResult<APIResponseModel<string>>> ModifyOptions(List<ModofyOptionsModel> models, long userId)
        {
            using var transaction = await _context.Database.BeginTransactionAsync();
            try
            {
                User? user = await _userManager.FindByIdAsync(userId.ToString());
                if (user == null)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindUserByIdFail);
                }
                bool isAdminOrSuperAdmin = await _userManager.IsInRoleAsync(user, "Admin") || await _userManager.IsInRoleAsync(user, "Super Admin");
                // 判断用户是不是管理员
                if (!isAdminOrSuperAdmin)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
                }
                // 开始修改配置项
                for (int i = 0; i < models.Count; i++)
                {
                    ModofyOptionsModel model = models[i];
                    Options? options = await _context.Options.FirstOrDefaultAsync(x => x.Key == model.Key);
                    if (options == null)
                    {
                        return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindOptionsFail);
                    }
                    options.Value = model.Value;
                    _context.Options.Update(options);
                }
                await _context.SaveChangesAsync();
                await transaction.CommitAsync();
                return APIResponseModel<string>.CreateSuccessResponseModel("修改成功");
            }
            catch (Exception ex)
            {
                await transaction.RollbackAsync();
                return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, ex.Message);
            }
        }
        #endregion
    }
}