修改laitool的软件控制权限等

LMS.Common/Enum/MachineEnum.cs

@@ -21,11 +21,12 @@ namespace LMS.Common.Enums
         /// </summary>
         public enum MachineStatus
         {
-            [Description("激活")]
-            Active = 1,
-
             [Description("冻结")]
-            Frozen = 0
+            Frozen = 0,
+
+            [Description("激活")]
+            Active = 1
+
         }
     }
 }

LMS.service/Controllers/MachineController.cs

@@ -120,7 +120,7 @@ namespace LMS.service.Controllers
 
         #endregion
 
-        #region 将机器码升级为永久使用
+        #region 将机器码升级
 
         [HttpPost("{Id}")]
         [Authorize]

LMS.service/Service/MachineService.cs

@@ -1,5 +1,6 @@
 using AutoMapper;
 using LMS.DAO;
+using LMS.Repository.DB;
 using LMS.Repository.DTO;
 using LMS.Repository.DTO.UserDto;
 using LMS.Repository.Models.DB;
@@ -42,12 +43,6 @@ namespace LMS.service.Service
         /// <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();
 
@@ -106,7 +101,7 @@ namespace LMS.service.Service
 
                 if (request.UserId == null)
                 {
-                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError);
+                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "所属用户ID不能为空");
                 }
                 // 判断OwnerUserId是不是还能添加
                 User? ownerUser = await _userManager.FindByIdAsync((request.UserId ?? reqId).ToString());
@@ -131,68 +126,47 @@ namespace LMS.service.Service
                     return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "机器码状态不正确");
                 }
 
-                // 判断是不是VIP，不是VIP的话，判断之不是已经存在机器码
+                // 检测laitool软件是否存在
-                if (!await _userManager.IsInRoleAsync(ownerUser, "VIP User"))
+                Software? software = await _context.Software.FirstOrDefaultAsync(x => x.SoftwareCode == "1002");
+                if (software == null)
                 {
-                    if (await _context.Machine.AnyAsync(x => x.UserID == ownerUser.Id))
+                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "软件不存在，请联系管理员");
+                }
+
+                // 判断是不是有开通软件控制权限，所属用户ID
+                SoftwareControl? softwareControl = await _context.SoftwareControl.FirstOrDefaultAsync(x => x.UserId == ownerUser.Id && x.SoftwareId == software.Id);
+                if (softwareControl == null)
+                {
+                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "当前用户没有开通软件控制权限，请先申请软件控制权限并联系管理员开通服务");
+                }
+
+                // 判断是不是可以使用，检测到期时间和是不是永久
+                if (!softwareControl.IsForever)
+                {
+                    if (softwareControl.ExpirationTime == null || softwareControl.ExpirationTime <= BeijingTimeExtension.GetBeijingTime())
                     {
-                        return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "普通用户只能添加一个机器码");
+                        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)
                 {
-                    var checkRes = await CanAddPermanentMachine(ownerUser, (long)(request.UserId ?? reqId), null, false);
+                    return checkRes;
-                    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;
                 }
 
+                //    // 先修改用户的免费更换次数
+                ownerUser.FreeCount -= 1;
+                _context.Users.Update(ownerUser);
+                request.DeactivationTime = null;
+
                 //开始新增
                 Machine machine = _mapper.Map<Machine>(request);
+                // 使用软件控制的到期时间，要是永久的话，就是默认添加五年
+                machine.DeactivationTime = softwareControl.IsForever ? BeijingTimeExtension.GetBeijingTime().AddYears(5) : softwareControl.ExpirationTime;
+                machine.Status = MachineStatus.Active; // 所有的都是激活状态
+                machine.UseStatus = MachineUseStatus.Trial; // 所有的都是试用状态
                 machine.Id = Guid.NewGuid().ToString();
                 machine.CreateId = reqId;
                 machine.UpdateId = reqId;
@@ -256,11 +230,7 @@ namespace LMS.service.Service
             try
             {
                 // 获取对应的machine
-                var machine = await _context.Machine.FirstOrDefaultAsync(x =>
+                Machine? machine = await _context.Machine.FirstOrDefaultAsync(x => x.MachineId == machineId && x.Status == MachineStatus.Active && x.DeactivationTime > BeijingTimeExtension.GetBeijingTime());
-                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);
@@ -308,14 +278,7 @@ namespace LMS.service.Service
                 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, "除管理员之外不可编辑");
-                    {
-                        return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
-                    }
-                    if (machine.MachineId != request.MachineId)
-                    {
-                        return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "机器码不能修改");
-                    }
                 }
 
                 // 判断当前修改后的机器码是否已经存在（不包含自己）
@@ -324,87 +287,10 @@ namespace LMS.service.Service
                     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.MachineId = request.MachineId;
-                {
-                    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);
 
@@ -560,32 +446,40 @@ namespace LMS.service.Service
                     return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindUserByIdFail);
                 }
 
-                // 判断当前用户是不是可以升级永久
+                // 直接判断是不是有软件控制权限
-                // 判断用户是不是VIP
+                Software? software = await _context.Software.FirstOrDefaultAsync(x => x.SoftwareCode == "1002");
-                if (!await _userManager.IsInRoleAsync(ownerUser, "Vip User"))
+                if (software == null)
                 {
-                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.UserNotVip);
+                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "软件不存在，请联系管理员");
                 }
 
-                // 判断是不是已经有正在使用的机器码
+                SoftwareControl? softwareControl = await _context.SoftwareControl.FirstOrDefaultAsync(x => x.UserId == ownerUser.Id && x.SoftwareId == software.Id);
-                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 (softwareControl == null)
-
-                // 判断是不是超过了用户允许的最大机器码数量
-                if ((usingMachine.Count + 1) > ownerUser.AllDeviceCount)
                 {
-                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "当前用户正在绑定的机器码数量超过最大数量");
+                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "当前用户没有开通软件控制权限，请先申请软件控制权限并联系管理员开通服务");
                 }
 
-                // 判断免费更换次数
+                // 直接同步就行，不用管之前的，直接同步时间就行，把状态修改了就行
-                if (ownerUser.FreeCount <= 0)
+                // 判断是不是可以使用，检测到期时间和是不是永久
+                var checkRes = await CanAddPermanentMachine(ownerUser, machine.UserID, machine.Id, true);
+                if (checkRes.Code != 1)
                 {
-                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "当前用户更换机器码的次数已用完");
+                    return checkRes;
                 }
 
-                // 判断当前机器码是否已经是永久使用
+                // 简单判断时间
-                if (machine.Status == MachineStatus.Active && machine.UseStatus == MachineUseStatus.Permanent)
+                if (!softwareControl.IsForever)
                 {
-                    return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "当前机器码已是永久");
+                    if (softwareControl.ExpirationTime == null || softwareControl.ExpirationTime <= BeijingTimeExtension.GetBeijingTime())
+                    {
+                        machine.UpdateTime = BeijingTimeExtension.GetBeijingTime();
+                        machine.Status = MachineStatus.Frozen;
+                        machine.DeactivationTime = BeijingTimeExtension.GetBeijingTime();
+                        _context.Machine.Update(machine);
+                        await _context.SaveChangesAsync();
+                        await transaction.CommitAsync();
+                        return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "当前用户的软件控制权限已到期，请联系管理员");
+                    }
                 }
 
                 // 先修改用户的免费更换次数
@@ -594,8 +488,8 @@ namespace LMS.service.Service
 
                 machine.UpdateTime = BeijingTimeExtension.GetBeijingTime();
                 machine.Status = MachineStatus.Active;
-                machine.UseStatus = MachineUseStatus.Permanent;
+                machine.DeactivationTime = softwareControl.IsForever ? BeijingTimeExtension.GetBeijingTime().AddYears(5) : softwareControl.ExpirationTime;
-                machine.DeactivationTime = null;
+                machine.UseStatus = MachineUseStatus.Trial;
                 _context.Machine.Update(machine);
                 await _context.SaveChangesAsync();
                 await transaction.CommitAsync();