LMS.service/LMS.service/Service/MachineService.cs

using AutoMapper;
using LMS.DAO;
using LMS.Repository.DTO;
using LMS.Repository.DTO.UserDto;
using LMS.Repository.Models.DB;
using LMS.Repository.Models.Machine;
using LMS.Tools;
using LMS.Tools.Extensions;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using static LMS.Common.Enums.MachineEnum;
using static LMS.Common.Enums.ResponseCodeEnum;
using static LMS.Repository.DTO.MachineResponse.MachineDto;
using Machine = LMS.Repository.Models.DB.Machine;

namespace LMS.service.Service
{
    public class MachineService
    {
        private readonly ApplicationDbContext _context;
        private readonly UserManager<User> _userManager;
        private readonly IMapper _mapper;

        public MachineService(ApplicationDbContext context, IMapper mapper, UserManager<User> userManager)
        {
            _context = context;
            _mapper = mapper;
            _userManager = userManager;
        }

        #region Private Methods

        /// <summary>
        /// 判断当前机器码所属的用户是不是可以添加永久机器码
        /// 检查用户是不是VIP用户
        /// 检查当前用户是不是已经拥有了最大的数量的机器码
        /// 检查当前用户是不是还有免费更换次数
        /// </summary>
        /// <param name="ownerUser"></param>
        /// <param name="machine"></param>
        /// <returns></returns>
        private async Task<APIResponseModel<string>> CanAddPermanentMachine(User ownerUser, long userId, string? id, bool checkVip)
        {
            // 判断是不是VIP
            if (checkVip && !await _userManager.IsInRoleAsync(ownerUser, "Vip User"))
            {
                return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.UserNotVip);
            }

            // 判断是不是已经有正在使用的机器码
            List<Machine> usingMachine = await _context.Machine.Where(x => x.UserID == userId && x.Status == MachineStatus.Active && (x.DeactivationTime == null || x.DeactivationTime >= BeijingTimeExtension.GetBeijingTime()) && (id == null || x.Id != id)).ToListAsync();

            // 判断是不是超过了用户允许的最大机器码数量
            if ((usingMachine.Count + 1) > ownerUser.AllDeviceCount)
            {
                return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "当前用户正在绑定的机器码数量超过最大数量");
            }

            // 判断免费更换次数
            if (ownerUser.FreeCount <= 0)
            {
                return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "当前用户更换机器码的次数已用完");
            }
            return APIResponseModel<string>.CreateSuccessResponseModel(ResponseCode.Success);
        }

        #endregion

        #region 添加机器码
        /// <summary>
        /// 添加机器码
        /// </summary>
        /// <param name="request"></param>
        /// <param name="reqId"></param>
        /// <returns></returns>
        internal async Task<ActionResult<APIResponseModel<string>>> AddMachine(MachineModel request, long reqId)
        {
            using var transaction = _context.Database.BeginTransaction();
            try
            {
                // 新增
                // 判断当前用户是否有新增和管理机器码的权限
                //if (!await _context.Permission.AnyAsync(x => x.UserId == reqId && (x.PermissionCode == SubPermissionType.ManageMachine || x.PermissionCode == SubPermissionType.AddMachine)))
                //{
                //    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
                //}

                // 请求方法的用户
                User? user = await _userManager.FindByIdAsync(reqId.ToString());
                if (user == null)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindUserByIdFail);
                }

                // 判断当前机器码是否已经存在
                if (await _context.Machine.AnyAsync(x => x.MachineId == request.MachineId))
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.MachineAlreadyExist);
                }

                if (request.Status == MachineStatus.Frozen)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "新增机器码不能直接停用");
                }

                if (request.UserId == null)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError);
                }
                // 判断OwnerUserId是不是还能添加
                User? ownerUser = await _userManager.FindByIdAsync((request.UserId ?? reqId).ToString());
                if (ownerUser == null)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindUserByIdFail);
                }

                // 判断是不是管理员，不是管理员，只能添加自己的机器码
                bool isAdminOrSuperAdmin = await _userManager.IsInRoleAsync(user, "Admin") || await _userManager.IsInRoleAsync(user, "Super Admin");
                if (!isAdminOrSuperAdmin && ownerUser.Id != reqId)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
                }

                if (!EnumExtensions.IsValidPermissionType(typeof(MachineUseStatus), request.UseStatus))
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "机器码使用状态不正确");
                }
                if (!EnumExtensions.IsValidPermissionType(typeof(MachineStatus), request.Status))
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "机器码状态不正确");
                }

                // 判断是不是VIP，不是VIP的话，判断之不是已经存在机器码
                if (!await _userManager.IsInRoleAsync(ownerUser, "VIP User"))
                {
                    if (await _context.Machine.AnyAsync(x => x.UserID == ownerUser.Id))
                    {
                        return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "普通用户只能添加一个机器码");
                    }
                }

                if (request.UseStatus == MachineUseStatus.Trial)
                {
                    var checkRes = await CanAddPermanentMachine(ownerUser, (long)(request.UserId ?? reqId), null, false);
                    if (checkRes.Code != 1)
                    {
                        return checkRes;
                    }
                    // 必传停用时间
                    if (request.DeactivationTime == null)
                    {
                        return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "试用机器码必须传入停用时间");
                    }
                    request.DeactivationTime = request.DeactivationTime?.AddHours(8);

                    // 判断停用时间是不是少于当前的
                    if (request.DeactivationTime < BeijingTimeExtension.GetBeijingTime())
                    {
                        return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "到期时间不能小于当前时间");
                    }
                    Console.WriteLine(BeijingTimeExtension.GetBeijingTime().ToString());

                    int s = ((request.DeactivationTime ?? BeijingTimeExtension.GetBeijingTime().AddDays(1)) - BeijingTimeExtension.GetBeijingTime()).Days;

                    var LaiToolTrialDays = await _context.Options.FirstOrDefaultAsync(x => x.Key == "LaiToolTrialDays");
                    if (LaiToolTrialDays == null)
                    {
                        return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, "系统错误，未设置最大试用天数");
                    }
                    double maxTrialDays = LaiToolTrialDays.GetValueObject<double>();
                    // 判断当前时间和现在的时间差大于三天，报错
                    if (s >= maxTrialDays)
                    {
                        return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, $"到期时间不能超过 {maxTrialDays}天");
                    }
                    // 先修改用户的免费更换次数
                    ownerUser.FreeCount -= 1;
                    _context.Users.Update(ownerUser);
                }
                else
                {
                    var checkRes = await CanAddPermanentMachine(ownerUser, (long)(request.UserId ?? reqId), null, true);
                    if (checkRes.Code != 1)
                    {
                        return checkRes;
                    }
                    // 先修改用户的免费更换次数
                    ownerUser.FreeCount -= 1;
                    _context.Users.Update(ownerUser);
                    request.DeactivationTime = null;
                }

                //开始新增
                Machine machine = _mapper.Map<Machine>(request);
                machine.Id = Guid.NewGuid().ToString();
                machine.CreateId = reqId;
                machine.UpdateId = reqId;
                machine.CreateTime = BeijingTimeExtension.GetBeijingTime();
                machine.UpdateTime = BeijingTimeExtension.GetBeijingTime();

                await _context.Machine.AddAsync(machine);

                await _context.SaveChangesAsync();
                await transaction.CommitAsync();
                return APIResponseModel<string>.CreateSuccessResponseModel(ResponseCode.Success);
            }
            catch (Exception e)
            {
                await transaction.RollbackAsync();
                return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
            }
        }
        #endregion

        #region 删除机器码
        /// <summary>
        /// 删除机器码
        /// </summary>
        /// <param name="machineId"></param>
        /// <param name="userId"></param>
        /// <returns></returns>
        internal async Task<ActionResult<APIResponseModel<object>>> DeleteMachine(string id, long userId)
        {
            try
            {
                Machine? machine = await _context.Machine.FirstOrDefaultAsync(x => x.Id == id);
                if (machine == null)
                {
                    return APIResponseModel<object>.CreateErrorResponseModel(ResponseCode.FindMachineByIdFail);
                }

                // 开始删除
                _context.Machine.Remove(machine);
                await _context.SaveChangesAsync();
                return APIResponseModel<object>.CreateSuccessResponseModel(ResponseCode.Success);
            }
            catch (Exception e)
            {
                return APIResponseModel<object>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
            }
        }

        #endregion

        #region 获取机器码状态

        /// <summary>
        /// 获取机器状态（是否停用和截至时间）
        /// </summary>
        /// <param name="machineId"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        internal async Task<ActionResult<APIResponseModel<MachineStatusResponse>>> GetMachineStatus(string machineId)
        {
            try
            {
                // 获取对应的machine
                var machine = await _context.Machine.FirstOrDefaultAsync(x =>
                x.MachineId == machineId &&
                ((x.DeactivationTime == null && x.UseStatus == MachineUseStatus.Permanent && x.Status == MachineStatus.Active)
                || (x.DeactivationTime != null && x.UseStatus == MachineUseStatus.Trial && BeijingTimeExtension.GetBeijingTime() < x.DeactivationTime && x.Status == MachineStatus.Active)));

                if (machine == null)
                {
                    return APIResponseModel<MachineStatusResponse>.CreateErrorResponseModel(ResponseCode.MachineNotFound);
                }

                MachineStatusResponse machineStatus = _mapper.Map<MachineStatusResponse>(machine);

                return APIResponseModel<MachineStatusResponse>.CreateSuccessResponseModel(ResponseCode.Success, machineStatus);
            }
            catch (Exception e)
            {
                return APIResponseModel<MachineStatusResponse>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
            }
        }

        #endregion

        #region 修改机器码数据
        /// <summary>
        /// 新增/修改机器状态
        /// </summary>
        /// <param name="request">请求体</param>
        /// <param name="reqId">请求ID</param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        internal async Task<ActionResult<APIResponseModel<string>>> ModifyMachine(string machineId, MachineModel request, long reqId)
        {
            using var transaction = _context.Database.BeginTransaction();
            try
            {
                // 判断传入的userId是否存在
                User? user = await _userManager.FindByIdAsync(reqId.ToString());
                if (user == null)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindUserByIdFail);
                }

                // 判断当前ID是不是存在
                var machine = await _context.Machine.FirstOrDefaultAsync(x => x.Id == machineId);
                if (machine == null)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindMachineByIdFail);
                }

                bool isAdminOrSuperAdmin = await _userManager.IsInRoleAsync(user, "Admin") || await _userManager.IsInRoleAsync(user, "Super Admin");
                if (!isAdminOrSuperAdmin)
                {
                    if (reqId != machine.UserID || request.MachineId != machine.MachineId)
                    {
                        return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
                    }
                    if (machine.MachineId != request.MachineId)
                    {
                        return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "机器码不能修改");
                    }
                }

                // 判断当前修改后的机器码是否已经存在（不包含自己）
                if (await _context.Machine.AnyAsync(x => x.MachineId == request.MachineId && x.Id != machineId))
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.MachineAlreadyExist);
                }

                // 将标准时间转换为北京时间
                request.DeactivationTime = request.DeactivationTime?.AddHours(8);

                // 判断是不是永久改试用
                if (machine.UseStatus == MachineUseStatus.Permanent && request.UseStatus == MachineUseStatus.Trial)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "机器码不能永久改试用");
                }

                if (!isAdminOrSuperAdmin)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
                }

                // 试用，除了管理员之外不能修改
                if (request.UseStatus == MachineUseStatus.Trial)
                {
                    // 判断结束时间是不是少于当前的
                    if (request.DeactivationTime != null && request.DeactivationTime < BeijingTimeExtension.GetBeijingTime())
                    {
                        return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "到期时间不能小于当前时间");
                    }

                    // 判断当前时间和现在的时间差大于三天，报错
                    if (request.DeactivationTime != null && (request.DeactivationTime - BeijingTimeExtension.GetBeijingTime()).Value.Days > 3)
                    {
                        return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "到期时间不能超过三天");
                    }
                }
                else if (request.UseStatus == MachineUseStatus.Permanent)
                {
                    request.DeactivationTime = null;
                    User? ownerUser = await _userManager.FindByIdAsync(machine.UserID.ToString());
                    if (ownerUser == null)
                    {
                        return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindUserByIdFail);
                    }
                    // 判断是不是充试用升级到永久，这边要添加一些判断
                    if (machine.UseStatus == MachineUseStatus.Trial)
                    {
                        var checkRes = await CanAddPermanentMachine(ownerUser, machine.UserID, machine.Id, true);
                        if (checkRes.Code != 1)
                        {
                            return checkRes;
                        }
                        // 先修改用户的免费更换次数
                        ownerUser.FreeCount -= 1;
                        await _userManager.UpdateAsync(ownerUser);
                    }

                    // 判断是不是重新激活
                    if (request.Status == MachineStatus.Active && machine.Status == MachineStatus.Frozen)
                    {
                        var checkRes = await CanAddPermanentMachine(ownerUser, machine.UserID, machine.Id, true);
                        if (checkRes.Code != 1)
                        {
                            return checkRes;
                        }
                        // 先修改用户的免费更换次数
                        ownerUser.FreeCount -= 1;
                        await _userManager.UpdateAsync(ownerUser);
                    }
                }

                // 开始修改
                machine.UpdateId = reqId;
                machine.UpdateTime = BeijingTimeExtension.GetBeijingTime();
                if (request.DeactivationTime != null)
                {
                    machine.DeactivationTime = request.DeactivationTime;
                }
                if (request.Status == MachineStatus.Active && request.UseStatus == MachineUseStatus.Permanent)
                {
                    machine.DeactivationTime = null;
                }
                machine.UseStatus = request.UseStatus;
                if (isAdminOrSuperAdmin)
                {
                    machine.MachineId = request.MachineId;
                }
                machine.Status = request.Status;
                machine.Remark = request.Remark;
                _context.Machine.Update(machine);

                await _context.SaveChangesAsync();
                await transaction.CommitAsync();
                return APIResponseModel<string>.CreateSuccessResponseModel(ResponseCode.Success);
            }
            catch (Exception e)
            {
                await transaction.RollbackAsync();
                return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
            }
        }

        #endregion

        #region 查询机器码列表
        /// <summary>
        /// 查询机器码列表
        /// </summary>
        /// <param name="page"></param>
        /// <param name="pageSize"></param>
        /// <param name="machineId"></param>
        /// <param name="createdUserName"></param>
        /// <param name="status"></param>
        /// <param name="useStatus"></param>
        /// <param name="remark"></param>
        /// <param name="ownUserName"></param>
        /// <param name="requestUserId"></param>
        /// <returns></returns>
        internal async Task<ActionResult<APIResponseModel<CollectionResponse<Machine>>>> QueryMachineCollection(int page, int pageSize, string? machineId, string? createdUserName, MachineStatus? status, MachineUseStatus? useStatus, string? remark, string? ownUserName, long requestUserId)
        {
            try
            {
                User? user = await _userManager.FindByIdAsync(requestUserId.ToString());
                if (user == null)
                {
                    return APIResponseModel<CollectionResponse<Machine>>.CreateErrorResponseModel(ResponseCode.FindUserByIdFail);
                }
                bool isSuperAdmin = await _userManager.IsInRoleAsync(user, "Super Admin");
                bool isAdmin = await _userManager.IsInRoleAsync(user, "Admin");

                IQueryable<Machine> query = _context.Machine;

                if (isAdmin)
                {
                    List<long> superAdminUserIds = ((List<User>)await _userManager.GetUsersInRoleAsync("Super Admin")).Select(x => x.Id).ToList();

                    //.Result.Select(x => x.Id).ToList();
                    query = query.Where(x => !superAdminUserIds.Contains(x.UserID));
                }
                else if (!isSuperAdmin)
                {
                    query = query.Where(x => x.UserID == requestUserId);
                }
                // 添加其他的查询条件
                if (!string.IsNullOrWhiteSpace(machineId))
                {
                    query = query.Where(x => x.MachineId == machineId);
                }
                // 管理员和超级管理员可以使用该字段查询所有创建者的机器码
                if (!string.IsNullOrWhiteSpace(createdUserName) && (isAdmin || isSuperAdmin))
                {
                    List<long> queryUserId = (await _userManager.Users.Where(x => x.UserName.Contains(createdUserName)).ToListAsync()).Select(x => x.Id).ToList();
                    query = query.Where(x => queryUserId.Contains(x.CreateId));
                }
                // 普通用户只能查找自己创建的机器码
                else if (!string.IsNullOrWhiteSpace(createdUserName))
                {
                    query = query.Where(x => x.CreateId == user.Id);
                }

                if (status != null)
                {
                    query = query.Where(x => x.Status == status);
                }
                if (useStatus != null)
                {
                    query = query.Where(x => x.UseStatus == useStatus);
                }
                if (!string.IsNullOrWhiteSpace(remark))
                {
                    query = query.Where(x => x.Remark.Contains(remark));
                }

                // 管理员和超级管理员可以使用该字段查询所有的机器码的拥有者
                if (!string.IsNullOrWhiteSpace(ownUserName) && (isAdmin || isSuperAdmin))
                {
                    List<long> queryUserId = (await _userManager.Users.Where(x => x.UserName.Contains(ownUserName)).ToListAsync()).Select(x => x.Id).ToList();
                    query = query.Where(x => queryUserId.Contains(x.UserID));
                }
                // 普通用户只能查找自己拥有的机器码
                else if (!string.IsNullOrWhiteSpace(ownUserName))
                {
                    query = query.Where(x => x.UserID == user.Id);
                }

                int total = await query.CountAsync();

                // 降序，取指定的条数的数据
                List<Machine> machines = await query.OrderByDescending(x => x.CreateTime).Skip((page - 1) * pageSize).Take(pageSize).ToListAsync();

                return APIResponseModel<CollectionResponse<Machine>>.CreateSuccessResponseModel(ResponseCode.Success, new CollectionResponse<Machine>
                {
                    Total = total,
                    Collection = machines,
                    Current = page
                });
            }
            catch (Exception e)
            {
                return APIResponseModel<CollectionResponse<Machine>>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
            }
        }

        #endregion

        #region 将机器码升级为永久
        /// <summary>
        /// 将指定的机器码升级为永久使用
        /// </summary>
        /// <param name="id"></param>
        /// <param name="userId"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        internal async Task<ActionResult<APIResponseModel<string>>> UpgradeMachine(string id, long requestUserId)
        {
            using var transaction = await _context.Database.BeginTransactionAsync();
            try
            {
                User? requestUser = await _userManager.FindByIdAsync(requestUserId.ToString());
                if (requestUser == null)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindUserByIdFail);
                }

                Machine? machine = await _context.Machine.FirstOrDefaultAsync(x => x.Id == id);
                if (machine == null)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindMachineByIdFail);
                }

                bool isAdminOrSuperAdmin = await _userManager.IsInRoleAsync(requestUser, "Admin") || await _userManager.IsInRoleAsync(requestUser, "Super Admin");

                if (!isAdminOrSuperAdmin && machine.UserID != requestUserId)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
                }

                User? ownerUser = await _userManager.FindByIdAsync(machine.UserID.ToString());
                if (ownerUser == null)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindUserByIdFail);
                }

                // 判断当前用户是不是可以升级永久
                // 判断用户是不是VIP
                if (!await _userManager.IsInRoleAsync(ownerUser, "Vip User"))
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.UserNotVip);
                }

                // 判断是不是已经有正在使用的机器码
                List<Machine> usingMachine = await _context.Machine.Where(x => x.UserID == machine.UserID && x.Status == MachineStatus.Active && (x.DeactivationTime == null || x.DeactivationTime >= BeijingTimeExtension.GetBeijingTime()) && x.Id != machine.Id).ToListAsync();

                // 判断是不是超过了用户允许的最大机器码数量
                if ((usingMachine.Count + 1) > ownerUser.AllDeviceCount)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "当前用户正在绑定的机器码数量超过最大数量");
                }

                // 判断免费更换次数
                if (ownerUser.FreeCount <= 0)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "当前用户更换机器码的次数已用完");
                }

                // 判断当前机器码是否已经是永久使用
                if (machine.Status == MachineStatus.Active && machine.UseStatus == MachineUseStatus.Permanent)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "当前机器码已是永久");
                }

                // 先修改用户的免费更换次数
                ownerUser.FreeCount -= 1;
                await _userManager.UpdateAsync(ownerUser);

                machine.UpdateTime = BeijingTimeExtension.GetBeijingTime();
                machine.Status = MachineStatus.Active;
                machine.UseStatus = MachineUseStatus.Permanent;
                machine.DeactivationTime = null;
                _context.Machine.Update(machine);
                await _context.SaveChangesAsync();
                await transaction.CommitAsync();
                return APIResponseModel<string>.CreateSuccessResponseModel(ResponseCode.Success);
            }
            catch (Exception e)
            {
                await transaction.RollbackAsync();
                return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
            }
        }

        #endregion

        #region 将机器码停用
        /// <summary>
        /// 一键停用机器码，只有管理员和超级管理员可以操作，普通用户只能停用自己的机器码
        /// </summary>
        /// <param name="id"></param>
        /// <param name="requestUserId"></param>
        /// <returns></returns>
        internal async Task<ActionResult<APIResponseModel<string>>> DeactivateMachine(string id, long requestUserId)
        {
            try
            {
                User? user = await _userManager.FindByIdAsync(requestUserId.ToString());
                if (user == null)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindUserByIdFail);
                }

                bool isAdminOrSuperAdmin = await _userManager.IsInRoleAsync(user, "Admin") || await _userManager.IsInRoleAsync(user, "Super Admin");

                Machine? machine = await _context.Machine.FirstOrDefaultAsync(x => x.Id == id);
                if (machine == null)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindMachineByIdFail);
                }

                if (!isAdminOrSuperAdmin && machine.UserID != requestUserId)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
                }

                // 判断是不是已经停用
                if (machine.Status == MachineStatus.Frozen)
                {
                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "该机器码已经被冻结，不能重复操作");
                }

                // 开始冻结
                machine.Status = MachineStatus.Frozen;
                if (machine.DeactivationTime == null)
                {
                    machine.DeactivationTime = BeijingTimeExtension.GetBeijingTime();
                }
                machine.UpdateTime = BeijingTimeExtension.GetBeijingTime();
                machine.UpdateId = requestUserId;
                _context.Update(machine);
                await _context.SaveChangesAsync();
                return APIResponseModel<string>.CreateSuccessResponseModel(ResponseCode.Success);
            }
            catch (Exception e)
            {
                return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
            }
        }

        #endregion

        #region 获取指定的机器码详情
        /// <summary>
        /// 获取指定的机器码详情
        /// </summary>
        /// <param name="id"></param>
        /// <param name="userId"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        internal async Task<ActionResult<APIResponseModel<MachineDetailDto>>> GetMachineDetail(string id, long userId)
        {
            try
            {
                User? user = await _userManager.FindByIdAsync(userId.ToString());
                if (user == null)
                {
                    return APIResponseModel<MachineDetailDto>.CreateErrorResponseModel(ResponseCode.FindUserByIdFail);
                }

                Machine? machine = await _context.Machine.FirstOrDefaultAsync(x => x.Id == id);
                if (machine == null)
                {
                    return APIResponseModel<MachineDetailDto>.CreateErrorResponseModel(ResponseCode.FindMachineByIdFail);
                }

                bool isAdminOrSuperAdmin = await _userManager.IsInRoleAsync(user, "Admin") || await _userManager.IsInRoleAsync(user, "Super Admin");
                if (!isAdminOrSuperAdmin && machine.UserID != userId)
                {
                    return APIResponseModel<MachineDetailDto>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
                }

                MachineDetailDto machineDetail = _mapper.Map<MachineDetailDto>(machine);
                User? createdUser = await _userManager.FindByIdAsync(machine.CreateId.ToString());
                User? updatedUser = await _userManager.FindByIdAsync(machine.UpdateId.ToString());
                User? ownUser = await _userManager.FindByIdAsync(machine.UserID.ToString());
                machineDetail.CreatedUser = _mapper.Map<UserBaseDto>(createdUser);
                machineDetail.UpdatedUser = _mapper.Map<UserBaseDto>(createdUser);
                machineDetail.OwnUser = _mapper.Map<UserBaseDto>(createdUser);

                return APIResponseModel<MachineDetailDto>.CreateSuccessResponseModel(ResponseCode.Success, machineDetail);
            }
            catch (Exception e)
            {
                return APIResponseModel<MachineDetailDto>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
            }
        }

        #endregion
    }
}