admin777/LMS.service
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: admin777:eb8a48c6427115e40202642cd19e62a287162a65
Branches Tags
admin777:master
..
compare: admin777:8845fb6521b9e540ed8034065a2434a904e5294a
Branches Tags
admin777:master

No commits in common. "eb8a48c6427115e40202642cd19e62a287162a65" and "8845fb6521b9e540ed8034065a2434a904e5294a" have entirely different histories.
eb8a48c642 ... 8845fb6521

69 changed files with 282 additions and 4149 deletions
Show Stats Expand all files Collapse all files

22
LMS.Common/Attributes/NotEmptyAttribute.cs
View File

@ -1,22 +0,0 @@
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LMS.Common.Attributes
{
[AttributeUsage(AttributeTargets.Property)]
public class NotEmptyAttribute : ValidationAttribute
{
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
if (value is string str && string.IsNullOrWhiteSpace(str))
{
return new ValidationResult(ErrorMessage ?? "字段不能为空");
}
return ValidationResult.Success;
}
}
}

12
LMS.Common/Dictionary/AllOptions.cs
View File

@ -1,12 +0,0 @@
namespace LMS.Common.Dictionary;
public class AllOptions
{
public static readonly Dictionary<string, List<string>> AllOptionsRequestQuery = new()
{
{ "all", [] },
{ "tts", ["EdgeTTsRoles"] },
{ "software", ["LaitoolHomePage", "LaitoolNotice", "LaitoolUpdateContent","LaitoolVersion"]},
{ "trial" , ["LaiToolTrialDays"] }
};
}

10
LMS.Common/Dictionary/SimpleOptions.cs
View File

@ -1,10 +0,0 @@
namespace LMS.Common.Dictionary;
public class SimpleOptions
{
public static readonly Dictionary<string, List<string>> SimpleOptionsRequestQuery = new()
{
{ "ttsrole", ["EdgeTTsRoles"] },
{ "laitoolinfo", ["LaitoolHomePage", "LaitoolNotice", "LaitoolUpdateContent", "LaitoolVersion"] },
};
}

7
LMS.Common/Enum/MachineEnum.cs
View File

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

8
LMS.Common/Enum/OptionTypeEnum.cs
View File

@ -1,8 +0,0 @@
namespace LMS.Common.Enum;
public enum OptionTypeEnum
{
String = 1,
JSON = 2,
Number = 3,
}

23
LMS.Common/Enum/PromptEnum.cs
View File

@ -2,6 +2,14 @@
{
public class PromptEnum
{
public enum PromptType
{
/// <summary>
/// 开头提示词
/// </summary>
StartPrompt = 0,
}
public class PromptStatus
{
/// <summary>
@ -13,15 +21,6 @@
///提示词状态：禁用
/// </summary>
public const string Disable = "disable";
/// <summary>
/// 所有有效的提示词类型状态
/// </summary>
public static readonly HashSet<string> ValidStatuses =
[
Enable,
Disable
];
}
public class PromptTypeStatus
@ -39,11 +38,11 @@
/// <summary>
/// 所有有效的提示词类型状态
/// </summary>
public static readonly HashSet<string> ValidStatuses =
[
public static readonly HashSet<string> ValidStatuses = new HashSet<string>
{
Enable,
Disable
];
};
}
}

16
LMS.Common/Enum/ResponseCodeEnum.cs
View File

@ -77,11 +77,6 @@ namespace LMS.Common.Enums
[Description("无效的邀请码")]
InvalidAffiliateCode = 1014,
// 无效token
[Result("无效token")]
[Description("无效token")]
InvalidToken = 1015,
#endregion
#region Machine 操作失败
@ -146,10 +141,6 @@ namespace LMS.Common.Enums
[Result(ResponseString.InvalidOptions)]
[Description(ResponseString.InvalidOptions)]
InvalidOptions = 5002,
[Result(ResponseString.IdDateNotFound)]
[Description(ResponseString.IdDateNotFound)]
IdDateNotFound = 5003,
#endregion
#region 提示词操作失败
@ -202,13 +193,6 @@ namespace LMS.Common.Enums
RoleHasUser = 9004,
#endregion
#region 配置项操作失败
[Result(ResponseString.DataNotExist)]
[Description("没有找到指定的配置项")]
FindOptionsFail = 10001,
#endregion
}
}
}

31
LMS.Common/Enum/SoftwareControlEnum.cs
View File

@ -1,31 +0,0 @@
namespace LMS.Common.Enum
{
public class SoftwareControlEnum
{
public enum SoftwareControlValidityEnum
{
/// <summary>
/// 0
/// </summary>
Zero = 0,
/// <summary>
/// 一个月
/// </summary>
Thirty = 30,
/// <summary>
/// 三个月
/// </summary>
Ninety = 90,
/// <summary>
/// 六个月
/// </summary>
OneHundredAndEighty = 180,
/// <summary>
/// 一年
/// </summary>
ThreeHundredAndSixtyFive = 365,
}
}
}

14
LMS.DAO/ApplicationDbContext.cs
View File

@ -20,10 +20,6 @@ namespace LMS.DAO
public DbSet<PermissionType> PermissionType { get; set; }
public DbSet<PromptType> PromptType { get; set; }
public DbSet<Prompt> Prompt { get; set; }
public DbSet<Machine> Machine { get; set; }
public DbSet<RefreshTokens> RefreshTokens { get; set; }
@ -32,14 +28,6 @@ namespace LMS.DAO
public DbSet<RsaKeys> RsaKeys { get; set; }
public DbSet<Options> Options { get; set; }
public DbSet<Software> Software { get; set; }
public DbSet<UserSoftware> UserSoftware { get; set; }
public DbSet<SoftwareControl> SoftwareControl { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
@ -53,8 +41,6 @@ namespace LMS.DAO
? new List<string>() // 如果存储的是空字符串或空数组，则返回空列表
: JsonSerializer.Deserialize<List<string>>(v, (JsonSerializerOptions?)null) ?? new List<string>()
);
modelBuilder.Entity<UserSoftware>()
.HasKey(us => new { us.UserId, us.SoftwareId });
}
}
}

41
LMS.DAO/UserDAO/UserBasicDAO.cs
View File

@ -1,5 +1,10 @@
using LMS.Repository.Models.DB;
using Microsoft.AspNetCore.Identity;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LMS.DAO.UserDAO
{
@ -19,42 +24,6 @@ namespace LMS.DAO.UserDAO
}
return await _userManager.FindByIdAsync(userId.ToString()) != null;
}
/// <summary>
/// 判断传入的数据是不是有管理员权限或者是超级管理员权限
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public async Task<bool> CheckUserIsAdminOrSuperAdmin(long? userId)
{
if (userId == null)
{
return false;
}
User? user = await _userManager.FindByIdAsync(userId.ToString() ?? "0") ?? throw new Exception("用户不存在");
bool isAdminOrSuperAdmin = await _userManager.IsInRoleAsync(user, "Admin") || await _userManager.IsInRoleAsync(user, "Super Admin");
return isAdminOrSuperAdmin;
}
/// <summary>
/// 检查用户是不是超级管理员
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public async Task<bool> CheckUserIsSuperAdmin(long? userId)
{
if (userId == null)
{
return false;
}
User? user = await _userManager.FindByIdAsync(userId.ToString() ?? "0") ?? throw new Exception("用户不存在");
bool isSuperAdmin = await _userManager.IsInRoleAsync(user, "Super Admin");
return isSuperAdmin;
}
}
}

65
LMS.Repository/DB/Options.cs
View File

@ -1,65 +0,0 @@
using LMS.Common.Enum;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace LMS.Repository.DB;
public class Options
{
[Key]
public required string Key { get; set; } = string.Empty;
/// <summary>
/// Value of the option，这个值是一个json字符串
/// </summary>
public string? Value { get; set; } = string.Empty;
public OptionTypeEnum Type { get; set; } = OptionTypeEnum.String;
// 写一个字段，映射Value，判断是不是json字符串，是的话就解析成对象
// 写一个字段，映射Value，判断是不是json字符串，是的话就解析成对象
public T? GetValueObject<T>()
{
if (string.IsNullOrEmpty(Value))
{
return default;
}
if (Type == OptionTypeEnum.JSON)
{
return JsonConvert.DeserializeObject<T>(Value ?? "{}");
}
if (Type == OptionTypeEnum.Number)
{
if (double.TryParse(Value, out double result))
{
return (T)Convert.ChangeType(result, typeof(T));
}
return default;
}
return (T)Convert.ChangeType(Value, typeof(T));
}
// 写一个方法，设置Value的值
public void SetValueObject<T>(T value)
{
if (value == null)
{
Value = string.Empty;
return;
}
if (Type == OptionTypeEnum.JSON)
{
Value = JsonConvert.SerializeObject(value);
}
else
{
Value = value.ToString();
}
}
}

6
LMS.Repository/DB/Prompt.cs
View File

@ -1,4 +1,4 @@
namespace LMS.Repository.DB
namespace LMS.Repository.Models.DB
{
public class Prompt
{
@ -45,7 +45,7 @@
/// <summary>
/// 创建者
/// </summary>
public long CreateUserId { get; set; }
public string CreateUserId { get; set; }
/// <summary>
/// 创建时间
@ -55,7 +55,7 @@
/// <summary>
/// 更新者
/// </summary>
public long UpdateUserId { get; set; }
public string UpdateUserId { get; set; }
/// <summary>
/// 更新时间

38
LMS.Repository/DB/PromptType.cs
View File

@ -1,12 +1,35 @@
using LMS.Repository.DTO.PromptTypeDto;
namespace LMS.Repository.Models.DB
namespace LMS.Repository.Models.DB
{
/// <summary>
/// 提示词类型的库
/// </summary>
public class PromptType : PromptTypeBasic
public class PromptType
{
/// <summary>
/// ID
/// </summary>
public string Id { get; set; }
/// <summary>
/// 提示词类型编码
/// </summary>
public string Code { get; set; }
/// <summary>
/// 提示词类型名称
/// </summary>
public string Name { get; set; }
/// <summary>
/// 提示词类型描述
/// </summary>
public string? Remark { get; set; }
/// <summary>
/// 提示词类型状态
/// </summary>
public string Status { get; set; }
/// <summary>
/// 是否删除
/// </summary>
@ -15,7 +38,7 @@ namespace LMS.Repository.Models.DB
/// <summary>
/// 创建用户ID
/// </summary>
public long CreateUserId { get; set; }
public string CreateUserId { get; set; }
/// <summary>
/// 创建时间
@ -25,11 +48,14 @@ namespace LMS.Repository.Models.DB
/// <summary>
/// 更新者ID
/// </summary>
public long UpdateUserId { get; set; }
public string UpdateUserId { get; set; }
/// <summary>
/// 更新时间
/// </summary>
public DateTime UpdateTime { get; set; }
}
}

3
LMS.Repository/DB/Role.cs
View File

@ -1,4 +1,5 @@
using Microsoft.AspNetCore.Identity;
using LMS.Tools.Extensions;
using Microsoft.AspNetCore.Identity;
namespace LMS.Repository.Models.DB
{

41
LMS.Repository/DB/Software.cs
View File

@ -1,41 +0,0 @@
namespace LMS.Repository.DB;
public class Software
{
/// <summary>
/// ID
/// </summary>
public string Id { get; set; }
/// <summary>
/// 软件名称
/// </summary>
public string SoftwareName { get; set; }
/// <summary>
/// 软件代码
/// </summary>
public string SoftwareCode { get; set; }
/// <summary>
/// 创建用户ID
/// </summary>
public long CreatedUserId { get; set; }
/// <summary>
/// 更新用户ID
/// </summary>
public long UpdatedUserId { get; set; }
/// <summary>
/// 创建时间
/// </summary>
public DateTime CreatedTime { get; set; }
/// <summary>
/// 更新时间
/// </summary>
public DateTime UpdatedTime { get; set; }
/// <summary>
/// 备注
/// </summary>
public string Remark { get; set; }
/// <summary>
/// 是否启用
/// </summary>
public bool IsUse { get; set; }
}

45
LMS.Repository/DB/SoftwareControl.cs
View File

@ -1,45 +0,0 @@
namespace LMS.Repository.DB;
public class SoftwareControl
{
/// <summary>
/// ID
/// </summary>
public string Id { get; set; }
/// <summary>
/// 用户ID
/// </summary>
public long UserId { get; set; }
/// <summary>
/// 软件ID
/// </summary>
public string SoftwareId { get; set; }
/// <summary>
/// 创建用户ID
/// </summary>
public long CreatedUserId { get; set; }
/// <summary>
/// 创建时间
/// </summary>
public DateTime CreatedTime { get; set; }
/// <summary>
/// 更新用户ID
/// </summary>
public long UpdatedUserId { get; set; }
/// <summary>
/// 更新时间
/// </summary>
public DateTime UpdatedTime { get; set; }
/// <summary>
/// 备注
/// </summary>
public string Remark { get; set; }
/// <summary>
/// 到期时间
/// </summary>
public DateTime? ExpirationTime { get; set; }
/// <summary>
/// 是否永久
/// </summary>
public bool IsForever { get; set; }
}

17
LMS.Repository/DB/User.cs
View File

@ -1,5 +1,4 @@
using LMS.Repository.User;
using LMS.Tools.Extensions;
using Microsoft.AspNetCore.Identity;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
@ -34,13 +33,13 @@ namespace LMS.Repository.Models.DB
public string? Options { get; set; } = "{}";
[Column(TypeName = "datetime")]
public DateTime CreatedDate { get; set; } = BeijingTimeExtension.GetBeijingTime();
public DateTime CreatedDate { get; set; } = DateTime.Now;
[Column(TypeName = "datetime")]
public DateTime UpdatedDate { get; set; } = BeijingTimeExtension.GetBeijingTime();
public DateTime UpdatedDate { get; set; } = DateTime.Now;
[Column(TypeName = "datetime")]
public DateTime LastLoginDate { get; set; } = BeijingTimeExtension.GetBeijingTime();
public DateTime LastLoginDate { get; set; } = DateTime.Now;
public string? LastLoginIp { get; set; } = "";
@ -56,16 +55,6 @@ namespace LMS.Repository.Models.DB
/// </summary>
public string AffiliateCode { get; set; } = string.Empty;
/// <summary>
/// 用户微信号
/// </summary>
public string? WXNumber { get; set; }
/// <summary>
/// 备注
/// </summary>
public string? Remark { get; set; }
/// <summary>
/// 实际使用的Options
/// </summary>

22
LMS.Repository/DB/UserSoftware.cs
View File

@ -1,22 +0,0 @@
namespace LMS.Repository.DB;
public class UserSoftware
{
/// <summary>
/// 用户ID
/// </summary>
public long UserId { get; set; }
/// <summary>
/// 软件ID
/// </summary>
public string SoftwareId { get; set; }
/// <summary>
///
/// </summary>
public string MachineId { get; set; }
/// <summary>
/// 软件控制ID
/// </summary>
public string SoftwareControlId { get; set; }
}

16
LMS.Repository/DTO/OptionsDto.cs
View File

@ -1,16 +0,0 @@
using LMS.Common.Enum;
using System.ComponentModel.DataAnnotations;
namespace LMS.Repository.DTO;
public class OptionsDto
{
public required string Key { get; set; } = string.Empty;
/// <summary>
/// Value of the option，这个值是一个json字符串
/// </summary>
public string? Value { get; set; }
public OptionTypeEnum Type { get; set; } = OptionTypeEnum.String;
}

15
LMS.Repository/DTO/PromptDto/PromptDto.cs
View File

@ -1,15 +0,0 @@
using LMS.Repository.DB;
using LMS.Repository.DTO.PromptTypeDto;
using LMS.Repository.DTO.UserDto;
namespace LMS.Repository.DTO.PromptDto;
public class PromptDto : Prompt
{
public UserBaseDto CreatedUser { get; set; }
public UserBaseDto UpdatedUser { get; set; }
public PromptTypeBasic? PromptType { get; set; }
}

10
LMS.Repository/DTO/PromptDto/PromptNameDto.cs
View File

@ -1,10 +0,0 @@
namespace LMS.Repository.DTO.PromptDto;
public class PromptNameDto
{
public string Id { get; set; }
public string Name { get; set; }
public string PromptTypeId { get; set; }
}

8
LMS.Repository/DTO/PromptTypeDto/PrompTypeNameModel.cs
View File

@ -1,8 +0,0 @@
namespace LMS.Repository.DTO.PromptTypeDto;
public class PrompTypeNameModel
{
public string Name { get; set; }
public string Id { get; set; }
}

29
LMS.Repository/DTO/PromptTypeDto/PromptTypeBasic.cs
View File

@ -1,29 +0,0 @@
namespace LMS.Repository.DTO.PromptTypeDto;
public class PromptTypeBasic
{
/// <summary>
/// ID
/// </summary>
public string Id { get; set; }
/// <summary>
/// 提示词类型编码
/// </summary>
public string Code { get; set; }
/// <summary>
/// 提示词类型名称
/// </summary>
public string Name { get; set; }
/// <summary>
/// 提示词类型描述
/// </summary>
public string? Remark { get; set; }
/// <summary>
/// 提示词类型状态
/// </summary>
public string Status { get; set; }
}

12
LMS.Repository/DTO/PromptTypeDto/PromptTypeDto.cs
View File

@ -1,12 +0,0 @@
using LMS.Repository.DTO.UserDto;
using LMS.Repository.Models.DB;
namespace LMS.Repository.DTO.PromptTypeDto
{
public class PromptTypeDto : PromptType
{
public UserBaseDto? UpdatedUser { get; set; }
public UserBaseDto? CreatedUser { get; set; }
}
}

13
LMS.Repository/DTO/Software/SoftwareBasicDto.cs
View File

@ -1,13 +0,0 @@
namespace LMS.Repository.DTO.Software
{
public class SoftwareBasicDto
{
public string Id { get; set; } = string.Empty;
public string SoftwareName { get; set; } = string.Empty;
public string SoftwareCode { get; set; } = string.Empty;
public bool IsUse { get; set; }
}
}

44
LMS.Repository/DTO/Software/SoftwareCollectionDto.cs
View File

@ -1,44 +0,0 @@
using LMS.Repository.DTO.UserDto;
namespace LMS.Repository.DTO.Software
{
public class SoftwareCollectionDto
{
/// <summary>
/// ID
/// </summary>
public string Id { get; set; }
/// <summary>
/// 软件名称
/// </summary>
public string SoftwareName { get; set; }
/// <summary>
/// 软件代码
/// </summary>
public string SoftwareCode { get; set; }
/// <summary>
/// 创建用户ID
/// </summary>
public UserBaseDto CreatedUser { get; set; }
/// <summary>
/// 更新用户ID
/// </summary>
public UserBaseDto UpdatedUser { get; set; }
/// <summary>
/// 创建时间
/// </summary>
public DateTime CreatedTime { get; set; }
/// <summary>
/// 更新时间
/// </summary>
public DateTime UpdatedTime { get; set; }
/// <summary>
/// 备注
/// </summary>
public string Remark { get; set; }
/// <summary>
/// 是否启用
/// </summary>
public bool IsUse { get; set; }
}
}

47
LMS.Repository/DTO/Software/SoftwareControlCollectionDto.cs
View File

@ -1,47 +0,0 @@
using LMS.Repository.DTO.UserDto;
namespace LMS.Repository.DTO.Software
{
public class SoftwareControlCollectionDto
{
/// <summary>
/// ID
/// </summary>
public string Id { get; set; }
/// <summary>
/// 用户ID
/// </summary>
public UserBaseDto User { get; set; }
/// <summary>
/// 软件ID
/// </summary>
public DB.Software Software { get; set; }
/// <summary>
/// 创建用户ID
/// </summary>
public UserBaseDto CreatedUser { get; set; }
/// <summary>
/// 创建时间
/// </summary>
public DateTime CreatedTime { get; set; }
/// <summary>
/// 更新用户ID
/// </summary>
public UserBaseDto UpdatedUser { get; set; }
/// <summary>
/// 更新时间
/// </summary>
public DateTime UpdatedTime { get; set; }
/// <summary>
/// 备注
/// </summary>
public string Remark { get; set; }
/// <summary>
/// 到期时间
/// </summary>
public DateTime? ExpirationTime { get; set; }
/// <summary>
/// 是否永久
/// </summary>
public bool IsForever { get; set; }
}
}

7
LMS.Repository/DTO/UserDto/UserBaseDto.cs
View File

@ -15,11 +15,4 @@ public class UserBaseDto
public string PhoneNumber { get; set; } = string.Empty;
public string Avatar { get; set; } = string.Empty;
// 添加隐藏联系信息的方法
public void HideContactInfo()
{
Email = "**********";
PhoneNumber = "***********";
}
}

2
LMS.Repository/DTO/UserDto/UserCollectionDto.cs
View File

@ -13,7 +13,5 @@
public string LastLoginIp { get; set; } = string.Empty;
public string LastLoginDevice { get; set; } = string.Empty;
public string Remark { get; set; } = string.Empty;
}
}

8
LMS.Repository/DTO/UserDto/UserDto.cs
View File

@ -30,16 +30,8 @@ namespace LMS.Repository.DTO.UserDto
/// </summary>
public string AffiliateCode { get; set; } = string.Empty;
/// <summary>
/// 所属用户ID
/// </summary>
public long ParentId { get; set; }
/// <summary>
/// 备注
/// </summary>
public string? Remark { get; set; } = string.Empty;
/// <summary>
/// 放一些操作信息 不能频繁的修改数据库，使用的json格式存放
/// </summary>

48
LMS.Repository/Forward/ForwardModel.cs
View File

@ -1,48 +0,0 @@
using System.ComponentModel.DataAnnotations;
namespace LMS.Repository.Forward;
public class ForwardModel
{
/// <summary>
/// 提示词类型ID
/// </summary>
[Required]
public string PromptTypeId { get; set; }
/// <summary>
/// 提示词ID
/// </summary>
[Required]
public string PromptId { get; set; }
/// <summary>
/// GPT 请求网址
/// </summary>
[Required]
public string GptUrl { get; set; }
/// <summary>
/// 调用的模型
/// </summary>
[Required]
public string Model { get; set; }
/// <summary>
/// 机器码
/// </summary>
[Required]
public string MachineId { get; set; }
/// <summary>
/// API Key
/// </summary>
[Required]
public string ApiKey { get; set; }
/// <summary>
/// 处理之前的文案，基础文案
/// </summary>
[Required]
public string Word { get; set; } = string.Empty;
}

5
LMS.Repository/LMS.Repository.csproj
View File

@ -6,9 +6,12 @@
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<Folder Include="Prompt\" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Microsoft.Extensions.Identity.Stores" Version="8.0.8" />
<PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
</ItemGroup>
<ItemGroup>

12
LMS.Repository/Options/ModofyOptionsModel.cs
View File

@ -1,12 +0,0 @@
using System.ComponentModel.DataAnnotations;
namespace LMS.Repository.Options;
public class ModofyOptionsModel
{
[Required]
public required string Key { get; set; }
[Required]
public string Value { get; set; } = string.Empty;
}

45
LMS.Repository/PromptModel/ModifyPromptModel.cs
View File

@ -1,45 +0,0 @@
using System.ComponentModel.DataAnnotations;
namespace LMS.Repository.PromptModel;
public class ModifyPromptModel
{
/// <summary>
/// 名称
/// </summary>
[Required]
public string Name { get; set; }
/// <summary>
/// 提示词类型
/// </summary>
[Required]
public string PromptTypeId { get; set; }
/// <summary>
/// 提示词预设字符串
/// </summary>
[Required]
public string PromptString { get; set; }
/// <summary>
/// 描述
/// </summary>
public string? Description { get; set; }
/// <summary>
/// 备注
/// </summary>
public string? Remark { get; set; }
/// <summary>
/// 版本
/// </summary>
public int Version { get; set; }
[Required]
/// <summary>
/// 状态
/// </summary>
public string Status { get; set; }
}

29
LMS.Repository/PromptModel/ModifyPromptTypeModal.cs
View File

@ -1,29 +0,0 @@
using System.ComponentModel.DataAnnotations;
namespace LMS.Repository.PromptModel;
public class ModifyPromptTypeModal
{
/// <summary>
/// 名称
/// </summary>
[Required]
public string Name { get; set; }
/// <summary>
/// 提示词类型编码
/// </summary>
[Required]
public string Code { get; set; }
/// <summary>
/// 状态
/// </summary>
[Required]
public string Status { get; set; }
/// <summary>
/// 备注
/// </summary>
public string? Remark { get; set; } = string.Empty;
}

22
LMS.Repository/Software/AddSoftwareModel.cs
View File

@ -1,22 +0,0 @@
using LMS.Common.Attributes;
using System.ComponentModel.DataAnnotations;
namespace LMS.Repository.Software
{
public class AddSoftwareModel
{
/// <summary>
/// 软件名称
/// </summary>
[Required]
[NotEmpty(ErrorMessage = "123")]
public string SoftwareName { get; set; }
/// <summary>
/// 软件代码
/// </summary>
[Required]
[NotEmpty(ErrorMessage = "123")]
public string SoftwareCode { get; set; }
}
}

13
LMS.Repository/Software/ModifySoftwareControlValidityModel.cs
View File

@ -1,13 +0,0 @@
using LMS.Common.Enum;
namespace LMS.Repository.Software
{
public class ModifySoftwareControlValidityModel
{
public SoftwareControlEnum.SoftwareControlValidityEnum? ExpirationTime { get; set; }
public bool? IsForever { get; set; }
public bool? IsTry { get; set; }
}
}

21
LMS.Repository/User/LoginResponse.cs
View File

@ -1,21 +0,0 @@
namespace LMS.Repository.User;
public class LoginResponseBase
{
public string Token { get; set; }
public string UserName { get; set; }
public long Id { get; set; }
public string NickName { get; set; }
}
public class LoginResponse : LoginResponseBase
{
public string RefreshToken { get; set; }
}
public class SimpleLoginResponse : LoginResponseBase
{
public bool IsForver { get; set; }
public DateTime? ExpirationTime { get; set; }
}

7
LMS.Repository/User/ResetPasswordModel.cs
View File

@ -1,7 +0,0 @@
using System.ComponentModel.DataAnnotations;
public class ResetPasswordModel
{
[Required(ErrorMessage = "新密码是必填项")]
public required string NewPassword { get; set; }
}

2
LMS.Repository/User/UpdatedUserModel.cs
View File

@ -10,7 +10,5 @@
public string? UserName { get; set; }
public string? PhoneNumber { get; set; }
public List<string>? RoleNames { get; set; }
public string? Remark { get; set; }
}
}

17
LMS.Tools/Extensions/ConvertExtension.cs
View File

@ -40,22 +40,5 @@
return 0; // 默认返回0
}
/// <summary>
/// 将字符串转换为int，默认或者是转换错误返回0
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public static int ConvertStringToIntOrDefault(string input)
{
if (int.TryParse(input, out int result))
{
return result;
}
else
{
return 0;
}
}
}
}

12
LMS.service/.config/dotnet-tools.json
View File

@ -1,12 +0,0 @@
{
"version": 1,
"isRoot": true,
"tools": {
"dotnet-ef": {
"version": "8.0.10",
"commands": [
"dotnet-ef"
]
}
}
}

15
LMS.service/Configuration/AutoMapperConfig.cs
View File

@ -1,13 +1,9 @@
using AutoMapper;
using LMS.Repository.DB;
using LMS.Repository.DTO;
using LMS.Repository.DTO.PromptDto;
using LMS.Repository.DTO.PromptTypeDto;
using LMS.Repository.DTO.UserDto;
using LMS.Repository.Models.DB;
using LMS.Repository.Models.Machine;
using LMS.Repository.Models.Promission;
using LMS.Repository.PromptModel;
using LMS.Repository.RequestModel.Permission;
using static LMS.Repository.DTO.MachineResponse.MachineDto;
@ -30,17 +26,6 @@ namespace Lai_server.Configuration
CreateMap<User, UserDto>();
CreateMap<User, UserBaseDto>();
CreateMap<Options, OptionsDto>();
CreateMap<PromptType, PromptTypeDto>();
CreateMap<PromptType, PromptTypeBasic>();
CreateMap<Prompt, PromptDto>();
CreateMap<ModifyPromptModel, Prompt>();
}
}
}

150
LMS.service/Configuration/InitConfiguration/DatabaseConfiguration.cs
View File

@ -1,150 +0,0 @@
using LMS.DAO;
using LMS.Repository.DB;
using LMS.Repository.Models.DB;
using LMS.Tools.Extensions;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using LMS.Common.Enum;
using System.Threading;
using static LMS.Common.Enums.ResponseCodeEnum;
namespace LMS.service.Configuration.InitConfiguration;
/// <summary>
/// 检查数据库中的一些操作
/// </summary>
/// <param name="serviceProvider"></param>
public class DatabaseConfiguration(IServiceProvider serviceProvider) : IHostedService
{
private readonly IServiceProvider _serviceProvider = serviceProvider;
/// <summary>
/// 检查用户和角色是否创建，如果没有则创建超级管理员和默认角色
/// </summary>
/// <param name="context">数据库上下文</param>
/// <param name="userManager">用户管理器</param>
/// <param name="roleManager">角色管理器</param>
/// <param name="cancellationToken">取消令牌</param>
private static async Task CheckUserAndRoleNotCreat(ApplicationDbContext context, UserManager<User> userManager, RoleManager<Role> roleManager, CancellationToken cancellationToken)
{
// 判断数据库中是否存在超级管理员，如果不存在则创建一个
// 如果没有用户，默认没有超级管理员
User? user = await context.Users.FirstOrDefaultAsync(x => x.UserName == "admin", cancellationToken: cancellationToken);
if (user != null)
{
return;
}
User admin = new()
{
UserName = "admin",
NickName = "admin",
Email = "admin@admin.com",
AllDeviceCount = 1,
AgentPercent = 0.50,
FreeCount = 10,
CreatedDate = BeijingTimeExtension.GetBeijingTime(),
UpdatedDate = BeijingTimeExtension.GetBeijingTime(),
};
var result = await userManager.CreateAsync(admin, "Admin123.");
if (!result.Succeeded)
{
foreach (var s in result.Errors)
{
Console.WriteLine(s.Description);
return;
}
}
List<string> roleNames =
[
"Super Admin",
"Admin",
"Agent User",
"VIP User",
"Simple User"
];
for (int i = 0; i < roleNames.Count; i++)
{
// 开始添加一些默认数据。添加角色
if (await roleManager.FindByNameAsync(roleNames[i]) == null)
{
var indentiyResult = await roleManager.CreateAsync(new Role
{
Name = roleNames[i],
CreatedUserId = admin.Id,
UpdatedUserId = admin.Id,
CreatedTime = BeijingTimeExtension.GetBeijingTime(),
UpdatedTime = BeijingTimeExtension.GetBeijingTime(),
Remark = string.Empty,
});
Console.WriteLine(indentiyResult.Succeeded);
}
}
// 判断admin是否为超级管理员，如果不是，则添加
if (!await userManager.IsInRoleAsync(admin, "Super Admin"))
{
await userManager.AddToRoleAsync(admin, "Super Admin");
}
}
/// <summary>
/// 检查所有的配置项，没有的话，创建
/// </summary>
/// <param name="dbContext"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
private static async Task CheckOptionsNotCreat(ApplicationDbContext dbContext, CancellationToken cancellationToken)
{
List<Options> optionsKeyValue = [
new Options { Key = "EdgeTTsRoles", Value = "[]", Type = OptionTypeEnum.JSON },
new Options { Key = "LaitoolHomePage", Value = string.Empty, Type = OptionTypeEnum.String },
new Options { Key = "LaitoolUpdateContent", Value = string.Empty, Type = OptionTypeEnum.String },
new Options { Key = "LaitoolNotice", Value = string.Empty, Type = OptionTypeEnum.String },
new Options { Key = "LaitoolVersion", Value = string.Empty, Type = OptionTypeEnum.String },
new Options { Key = "LaiToolTrialDays", Value = "2" , Type = OptionTypeEnum.Number}
];
// 遍历所有的配置项，如果没有则添加
foreach (var item in optionsKeyValue)
{
Options? options = await dbContext.Options.FirstOrDefaultAsync(x => x.Key == item.Key, cancellationToken: cancellationToken);
if (options == null)
{
await dbContext.Options.AddAsync(item, cancellationToken);
}
}
}
public async Task StartAsync(CancellationToken cancellationToken)
{
using var scope = _serviceProvider.CreateScope();
var dbContext = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
var userManager = scope.ServiceProvider.GetRequiredService<UserManager<User>>();
var roleManager = scope.ServiceProvider.GetRequiredService<RoleManager<Role>>();
using var transaction = await dbContext.Database.BeginTransactionAsync(cancellationToken);
try
{
// 检查用户和角色是否创建
await CheckUserAndRoleNotCreat(dbContext, userManager, roleManager, cancellationToken);
// 检查 是不是有配置项，没有的化添加
await CheckOptionsNotCreat(dbContext, cancellationToken);
await dbContext.SaveChangesAsync(cancellationToken);
await transaction.CommitAsync(cancellationToken);
}
catch (Exception ex)
{
await transaction.RollbackAsync(cancellationToken);
// 根据需要处理异常，例如终止应用程序
Console.WriteLine(ex.Message);
Environment.Exit(1);
}
}
public Task StopAsync(CancellationToken cancellationToken)
{
return Task.CompletedTask;
}
}

6
LMS.service/Configuration/InitConfiguration/RsaConfigurattions.cs → LMS.service/Configuration/RsaConfigurattions.cs
View File

@ -1,14 +1,16 @@
using LMS.Common.RSAKey;

using LMS.Common.RSAKey;
using LMS.DAO;
using LMS.Repository.DB;
using LMS.Tools.Extensions;
using Microsoft.EntityFrameworkCore;
namespace LMS.service.Configuration.InitConfiguration
namespace LMS.service.Configuration
{
public class RsaConfigurattions(IServiceProvider serviceProvider) : IHostedService
{
private readonly IServiceProvider _serviceProvider = serviceProvider;
public async Task StartAsync(CancellationToken cancellationToken)
{
using var scope = _serviceProvider.CreateScope();

12
LMS.service/Configuration/ServiceConfiguration.cs
View File

@ -2,12 +2,10 @@
using LMS.DAO.PermissionDAO;
using LMS.DAO.RoleDAO;
using LMS.DAO.UserDAO;
using LMS.service.Configuration.InitConfiguration;
using LMS.service.Configuration;
using LMS.service.Service;
using LMS.service.Service.PermissionService;
using LMS.service.Service.PromptService;
using LMS.service.Service.RoleService;
using LMS.service.Service.SoftwareService;
using LMS.service.Service.UserService;
namespace Lai_server.Configuration
@ -18,7 +16,6 @@ namespace Lai_server.Configuration
{
// 注入Service
services.AddScoped<RsaConfigurattions>();
services.AddScoped<DatabaseConfiguration>();
// 注入DDL
services.AddScoped<LoginService>();
@ -28,13 +25,6 @@ namespace Lai_server.Configuration
services.AddScoped<PremissionValidationService>();
services.AddScoped<RoleService>();
services.AddScoped<UserService>();
services.AddScoped<OptionsService>();
services.AddScoped<PromptTypeService>();
services.AddScoped<PromptService>();
services.AddScoped<ForwardWordService>();
services.AddScoped<SoftwareControlService>();
services.AddScoped<SoftwareService>();
// 注入 DAO

73
LMS.service/Controllers/ForwardController.cs
View File

@ -1,73 +0,0 @@
using LMS.DAO;
using LMS.Repository.Forward;
using LMS.service.Service;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using static LMS.Common.Enums.ResponseCodeEnum;
namespace LMS.service.Controllers;
[Route("lms/[controller]/[action]")]
[ApiController]
public class ForwardController(ForwardWordService forwardWordService) : ControllerBase
{
private readonly ForwardWordService _forwardWordService = forwardWordService;
/// <summary>
/// 转发OpenAi格式的请求
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
[HttpPost]
public async Task<ActionResult<APIResponseModel<object>>> ForwardWord([FromBody] ForwardModel request)
{
if (!ModelState.IsValid)
{
return APIResponseModel<object>.CreateErrorResponseModel(ResponseCode.ParameterError);
}
return await _forwardWordService.ForwardWord(request);
}
/// <summary>
/// 流式转发
/// </summary>
/// <param name="req"></param>
/// <returns></returns>
[HttpPost]
public async Task<IActionResult> ForwardWordStream([FromBody] ForwardModel req)
{
try
{
HttpContext.Response.ContentType = "text/event-stream";
HttpContext.Response.Headers.Add("Cache-Control", "no-cache");
HttpContext.Response.Headers.Add("Connection", "keep-alive");
var settings = new JsonSerializerSettings
{
ContractResolver = new LowercaseContractResolver(),
Formatting = Formatting.Indented
};
await foreach (var s in _forwardWordService.ForwardWordStream(req))
{
// 确保遵循SSE的消息格式
//var data = "data: " + JsonConvert.SerializeObject(s, settings) + "\n\n";
await Response.WriteAsync(s);
await Response.Body.FlushAsync(); // 确保即时发送
}
}
catch (Exception e)
{
return BadRequest(e.Message);
}
return new EmptyResult();
}
public class LowercaseContractResolver : DefaultContractResolver
{
protected override string ResolvePropertyName(string propertyName)
{
return propertyName.ToLower();
}
}
}

2
LMS.service/Controllers/MachineController.cs
View File

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

72
LMS.service/Controllers/OptionsController.cs
View File

@ -1,72 +0,0 @@
using LMS.Repository.DB;
using LMS.Repository.DTO;
using LMS.Repository.Options;
using LMS.service.Service;
using LMS.Tools.Extensions;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using static LMS.Common.Enums.ResponseCodeEnum;
namespace LMS.service.Controllers
{
/// <summary>
/// Laitool 的配置项控制器
/// </summary>
/// <param name="optionsService"></param>
[Route("lms/[controller]/[action]")]
[ApiController]
public class LaitoolOptionsController(OptionsService optionsService) : ControllerBase
{
private readonly OptionsService _optionsService = optionsService;
#region 获取简单的配置项，无需权限
/// <summary>
/// 获取简单的配置项，无需权限
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
[HttpGet("{optionsKey}")]
public async Task<ActionResult<APIResponseModel<List<OptionsDto>>>> GetSimpleOptions(string optionsKey)
{
return await _optionsService.GetSimpleOptions(optionsKey);
}
#endregion
#region 获取指定的操作，需要管理员权限
[HttpGet("{optionsKey}")]
[Authorize]
public async Task<ActionResult<APIResponseModel<List<OptionsDto>>>> GetAllOptions(string optionsKey)
{
long userId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _optionsService.GetAllOptions(optionsKey, userId);
}
#endregion
#region 修改配置项
[HttpPost]
[Authorize]
public async Task<ActionResult<APIResponseModel<string>>> ModifyOptions([FromBody] List<ModofyOptionsModel> model)
{
if (!ModelState.IsValid)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError);
}
long userId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _optionsService.ModifyOptions(model, userId);
}
#endregion
//[HttpPost]
//[Authorize]
//public async Task<ActionResult<APIResponseModel<Options>>> GetOptions([FromBody] OptionsRequestModel request)
//{
// return await _optionsService.GetOptions(request);
//}
}
}

216
LMS.service/Controllers/PromptController.cs
View File

@ -1,216 +0,0 @@
using LMS.DAO;
using LMS.Repository.DTO;
using LMS.Repository.DTO.PromptDto;
using LMS.Repository.DTO.PromptTypeDto;
using LMS.Repository.PromptModel;
using LMS.service.Service.PromptService;
using LMS.Tools.Extensions;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using System.ComponentModel.DataAnnotations;
using static LMS.Common.Enums.PromptEnum;
using static LMS.Common.Enums.ResponseCodeEnum;
namespace LMS.service.Controllers
{
[Route("lms/[controller]/[action]")]
[ApiController]
public class PromptController : ControllerBase
{
private readonly ApplicationDbContext _context;
private readonly PromptTypeService _promptTypeService;
private readonly PromptService _promptService;
public PromptController(ApplicationDbContext context, PromptTypeService promptTypeService, PromptService promptService)
{
_context = context;
_promptTypeService = promptTypeService;
_promptService = promptService;
}
#region 提示词类型相关
/// <summary>
/// 获取当前的所有的提示词类型（分页）
/// </summary>
/// <param name="pageSize"> 每页的数量 </param>
/// <param name="current"> 当前页 </param>
/// <returns></returns>
[HttpGet]
[Authorize]
public async Task<ActionResult<APIResponseModel<CollectionResponse<PromptTypeDto>>>> QueryPromptypeCollection([Required] int page, [Required] int pageSize, string? code, string? name, string? status, string? remark)
{
long reuqertUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _promptTypeService.QueryPromptypeCollection(page, pageSize, code, name, status, remark, reuqertUserId);
}
/// <summary>
/// 获取所有的提示词类型的选项，ID和Name
/// </summary>
/// <returns></returns>
[HttpGet]
public async Task<ActionResult<APIResponseModel<List<PrompTypeNameModel>>>> GetPromptTypeOptions()
{
return await _promptTypeService.GetPromptTypeOptions();
}
/// <summary>
/// 通过ID获取详细的提示词类型信息
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
[HttpGet("{id}")]
[Authorize]
public async Task<ActionResult<APIResponseModel<PromptTypeDto>>> GetPromptTypeInfo(string id)
{
long reuqertUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _promptTypeService.GetPromptTypeInfo(id, reuqertUserId);
}
/// <summary>
/// 修改提示词数据
/// </summary>
/// <param name="id"></param>
/// <param name="modal"></param>
/// <returns></returns>
[HttpPost("{id}")]
[Authorize]
public async Task<ActionResult<APIResponseModel<string>>> ModityPromptType(string id, [FromBody] ModifyPromptTypeModal modal)
{
if (!ModelState.IsValid)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError);
}
long reuqertUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _promptTypeService.ModityPromptType(id, modal, reuqertUserId);
}
/// <summary>
/// 添加提示词类型数据
/// </summary>
/// <param name="modal"></param>
/// <returns></returns>
[HttpPost]
[Authorize]
public async Task<ActionResult<APIResponseModel<string>>> AddPromptType([FromBody] ModifyPromptTypeModal modal)
{
if (!ModelState.IsValid)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError);
}
long reuqertUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _promptTypeService.AddPromptType(modal, reuqertUserId);
}
/// <summary>
/// 删除提示词类型数据
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
[HttpDelete("{id}/{deletePrompt}")]
[Authorize]
public async Task<ActionResult<APIResponseModel<string>>> DeletePromptType(string id, bool deletePrompt)
{
long reuqertUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _promptTypeService.DeletePromptType(id, reuqertUserId, deletePrompt);
}
#endregion
#region 提示词相关
/// <summary>
/// 获取提示词数据的集合
/// </summary>
/// <param name="page"></param>
/// <param name="pageSize"></param>
/// <param name="name"></param>
/// <param name="promptTypeId"></param>
/// <param name="status"></param>
/// <param name="remark"></param>
/// <returns></returns>
[HttpGet]
[Authorize]
public async Task<ActionResult<APIResponseModel<CollectionResponse<PromptDto>>>> QueryPromptStringCollection([Required] int page, [Required] int pageSize, string? name, string? promptTypeId, string? status, string? remark)
{
long reuqertUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _promptService.QueryPromptStringCollection(page, pageSize, name, promptTypeId, status, remark, reuqertUserId);
}
/// <summary>
/// 获取指定提示词的详细信息
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
[HttpGet("{id}")]
[Authorize]
public async Task<ActionResult<APIResponseModel<PromptDto>>> GetPromptInfo(string id)
{
long reuqertUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _promptService.GetPromptInfo(id, reuqertUserId);
}
/// <summary>
/// 修改提示词预设数据
/// </summary>
/// <param name="id"></param>
/// <param name="model"></param>
/// <returns></returns>
[HttpPost("{id}")]
[Authorize]
public async Task<ActionResult<APIResponseModel<string>>> ModifyPrompt(string id, [FromBody] ModifyPromptModel model)
{
if (!ModelState.IsValid)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError);
}
long requertUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _promptService.ModifyPrompt(id, model, requertUserId);
}
/// <summary>
/// 添加提示词数据
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
[HttpPost]
[Authorize]
public async Task<ActionResult<APIResponseModel<string>>> AddPrompt([FromBody] ModifyPromptModel model)
{
if (!ModelState.IsValid)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError);
}
long requertUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _promptService.AddPrompt(model, requertUserId);
}
/// <summary>
/// 删除提示词数据
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
[HttpDelete("{id}")]
[Authorize]
public async Task<ActionResult<APIResponseModel<string>>> DeletePrompt(string id)
{
long requertUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _promptService.DeletePrompt(id, requertUserId);
}
/// <summary>
/// 获取所有的或者是指定的提示词预设数据 ID、Name
/// </summary>
/// <returns></returns>
[HttpGet("{option}")]
public async Task<ActionResult<APIResponseModel<List<PromptNameDto>>>> GetPromptOptions(string option)
{
return await _promptService.GetPromptOptions(option);
}
#endregion
}
}

221
LMS.service/Controllers/SoftWareController.cs
View File

@ -1,220 +1,15 @@
using LMS.Repository.DTO;
using LMS.Repository.DTO.Software;
using LMS.Repository.Software;
using LMS.service.Service.SoftwareService;
using LMS.Tools.Extensions;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using System.ComponentModel.DataAnnotations;
using System.IdentityModel.Tokens.Jwt;
using static LMS.Common.Enums.ResponseCodeEnum;
using Microsoft.AspNetCore.Mvc;
using System.Reflection;
namespace LMS.service.Controllers
{
[Route("lms/[controller]/[action]")]
public class SoftWareController : ControllerBase
public class SoftWareController : Controller
{
private readonly SoftwareControlService _softwareControlService;
private readonly SoftwareService _softwareService;
public SoftWareController(SoftwareControlService softwareControlService, SoftwareService softwareService)
{
_softwareControlService = softwareControlService;
_softwareService = softwareService;
}
#region 软件控制-同步用户的软件控制权限
/// <summary>
/// 同步用户的软件控制权限,用于用户登录后同步用户的软件控制权限
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
[HttpPost("{userId}")]
[Authorize]
public async Task<ActionResult<APIResponseModel<string>>> ApplySoftwareControl(long userId)
{
long reuqestUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _softwareControlService.ApplySoftwareControl(userId, reuqestUserId);
}
#endregion
#region 软件控制-设置软件的到期时间和是否永久
[HttpPost("{id}")]
[Authorize]
public async Task<ActionResult<APIResponseModel<string>>> ModifySoftwareControlValidity(string id, [FromBody] ModifySoftwareControlValidityModel model)
{
if (!ModelState.IsValid)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError);
}
long requestUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _softwareControlService.ModifySoftwareControlValidity(id, model, requestUserId);
}
#endregion
#region 软件控制-获取软件信息的集合
[HttpGet]
[Authorize]
public async Task<ActionResult<APIResponseModel<CollectionResponse<SoftwareControlCollectionDto>>>> GetSoftwareControlCollection([Required] int page, [Required] int pageSize, long? userId, string? softwareId, bool? IsForever, string? remark)
{
long requestUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _softwareControlService.GetSoftwareControlCollection(page, pageSize, userId, softwareId, IsForever, remark, requestUserId);
}
#endregion
#region 软件控制-删除软件控制数据
[HttpDelete("{id}")]
[Authorize]
public async Task<ActionResult<APIResponseModel<string>>> DeleteSoftwareControl(string id)
{
long requestUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _softwareControlService.DeleteSoftwareControl(id, requestUserId);
}
#endregion
#region 软件控制-各个软件检测软件控制权限
[HttpPost("{userID}/{machineId}/{softwareId}")]
[Authorize]
public async Task<ActionResult<APIResponseModel<string>>> CheckSoftwareControl(long userID, string machineId, string softwareId)
{
if (!ModelState.IsValid)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError);
}
long requestUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
// 解析jwt，获取machineID
// 从请求头中获取 JWT
var token = HttpContext.Request.Headers["Authorization"].ToString().Replace("Bearer ", "");
// 解析 JWT 并获取 MachineId
var handler = new JwtSecurityTokenHandler();
var jwtToken = handler.ReadJwtToken(token);
// 假设 MachineId 存储在 JWT 的声明中
var machineIdClaim = jwtToken.Claims.FirstOrDefault(claim => claim.Type == "DeviceInfo");
string parsedMachineId = machineIdClaim?.Value ?? "";
if (parsedMachineId != machineId || userID != requestUserId)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidToken, "登录失效，请重新登录");
}
return await _softwareControlService.CheckSoftwareControl(userID, machineId, softwareId);
}
#endregion
#region 软件控制-传入用户可以未申请权限数量
[HttpGet("{userId}")]
[Authorize]
public async Task<ActionResult<APIResponseModel<int>>> GetUserSoftwareControlCount(long userId)
{
long requestUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _softwareControlService.GetUserSoftwareControlCount(userId, requestUserId);
}
#endregion
#region 软件-添加软件数据
/// <summary>
/// 添加软件数据
/// </summary>
/// <param name="software"></param>
/// <returns></returns>
[HttpPost]
[Authorize]
public async Task<ActionResult<APIResponseModel<string>>> AddSoftware([FromBody] AddSoftwareModel software)
{
if (!ModelState.IsValid)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError);
}
long reuqestUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _softwareService.AddSoftware(software, reuqestUserId);
}
#endregion
#region 软件-修改软件信息
/// <summary>
/// 修改软件信息
/// </summary>
/// <param name="id"></param>
/// <param name="software"></param>
/// <returns></returns>
[HttpPost("{id}")]
[Authorize]
public async Task<ActionResult<APIResponseModel<string>>> MpdifySoftware(string id, [FromBody] AddSoftwareModel software)
{
if (!ModelState.IsValid)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError);
}
long reuqestUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _softwareService.ModifySoftware(id, software, reuqestUserId);
}
#endregion
#region 软件-获取软件列表信息
/// <summary>
/// 获取软件的列表信息，可以使用查询条件 softwareName, softwareCode
/// </summary>
/// <param name="page">页数</param>
/// <param name="pageSize">一页多少</param>
/// <param name="softwareName">软件名字</param>
/// <param name="softwareCode">软件编码</param>
/// <returns></returns>
[HttpGet]
[Authorize]
public async Task<ActionResult<APIResponseModel<CollectionResponse<SoftwareCollectionDto>>>> GetSoftwareCollection([Required] int page, [Required] int pageSize, string? softwareName, string? softwareCode, bool? isUse = true)
{
long reuqestUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _softwareService.GetSoftwareCollection(page, pageSize, softwareName, softwareCode, reuqestUserId, isUse);
}
#endregion
#region 软件-获取软件的信息信息，通过ID
[HttpGet("{id}")]
[Authorize]
public async Task<ActionResult<APIResponseModel<SoftwareCollectionDto>>> GetSoftwareInfoById(string id)
{
long reuqestUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _softwareService.GetSoftwareInfoById(id, reuqestUserId);
}
#endregion
#region 软件-删除软件数据
[HttpDelete("{id}")]
[Authorize]
public async Task<ActionResult<APIResponseModel<string>>> DeleteSoftware(string id)
{
long reuqestUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _softwareService.DeleteSoftware(id, reuqestUserId);
}
#endregion
#region 软件-获取所有软件的基础信息
[HttpGet]
[Authorize]
public async Task<ActionResult<APIResponseModel<List<SoftwareBasicDto>>>> GetSoftwareBaseCollection()
{
long reuqestUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _softwareService.GetSoftwareBaseCollection(reuqestUserId);
}
#endregion
//public Index()
//{
// var version = Assembly.GetExecutingAssembly().GetName().Version;
// Console.WriteLine($"Version: {version}");
//}
}
}

43
LMS.service/Controllers/UserController.cs
View File

@ -46,7 +46,7 @@ namespace LMS.service.Controllers
#endregion
#region 登录 会生成刷新token，用户后台的刷新
#region 登录
/// <summary>
/// 用户登录接口
/// </summary>
@ -81,30 +81,10 @@ namespace LMS.service.Controllers
SameSite = SameSiteMode.None,
Expires = DateTime.UtcNow.AddDays(7),
};
Response.Cookies.Append("refreshToken", ((LoginResponse)apiResponse.Data).RefreshToken, cookieOptions);
Response.Cookies.Append("refreshToken", ((LoginService.LoginResponse)apiResponse.Data).RefreshToken, cookieOptions);
return apiResponse;
}
#endregion
#region 简单登录，不生成刷新token，绑定机器码，有效期一天
[HttpPost("{softwareId}")]
public async Task<ActionResult<APIResponseModel<SimpleLoginResponse>>> SimpleLogin(string softwareId, [FromBody] LoginModel model)
{
if (!ModelState.IsValid)
{
return APIResponseModel<SimpleLoginResponse>.CreateErrorResponseModel(ResponseCode.ParameterError);
}
string? ip = HttpContext.Request.Headers["X-Forwarded-For"].FirstOrDefault();
if (string.IsNullOrEmpty(ip))
{
ip = HttpContext.Connection.RemoteIpAddress?.ToString();
}
return await _loginService.SimpleLogin(model, softwareId, ip, _keyStore);
}
#endregion
#region 注册
@ -180,7 +160,7 @@ namespace LMS.service.Controllers
#endregion
#region 获取用户列表
#region 获取用户列表
/// <summary>
/// 获取用户列表，可以使用查询条件 userName, userId, nickName, phoneNumber, email, roleNames
@ -196,10 +176,10 @@ namespace LMS.service.Controllers
/// <returns></returns>
[HttpGet]
[Authorize]
public async Task<ActionResult<APIResponseModel<CollectionResponse<UserCollectionDto>>>> QueryUserCollection([Required] int page, [Required] int pageSize, string userName, long? userId, string nickName, string phoneNumber, string email, string[] roleNames, string remark, long? parentId)
public async Task<ActionResult<APIResponseModel<CollectionResponse<UserCollectionDto>>>> QueryUserCollection([Required] int page, [Required] int pageSize, string userName, long? userId, string nickName, string phoneNumber, string email, string[] roleNames, long? parentId)
{
long reuqertUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _userService.QueryUserCollection(page, pageSize, userName, userId, nickName, phoneNumber, email, roleNames, remark, parentId, reuqertUserId);
return await _userService.QueryUserCollection(page, pageSize, userName, userId, nickName, phoneNumber, email, roleNames, parentId, reuqertUserId);
}
#endregion
@ -228,7 +208,6 @@ namespace LMS.service.Controllers
long requestUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _loginService.EnableAgent(requestUserId);
}
#endregion
#region 获取用户的代理信息
@ -242,17 +221,5 @@ namespace LMS.service.Controllers
}
#endregion
#region 管理员重置用户密码
[HttpPost("{id}")]
[Authorize]
public async Task<ActionResult<APIResponseModel<string>>> ResetPassword(long id, [FromBody] ResetPasswordModel newPassword)
{
long requestUserId = ConvertExtension.ObjectToLong(HttpContext.Items["UserId"] ?? 0);
return await _loginService.ResetPassword(id, newPassword, requestUserId);
}
#endregion
}
}

1
LMS.service/Extensions/Middleware/DynamicPermissionMiddleware.cs
View File

@ -59,7 +59,6 @@ namespace LMS.service.Extensions.Middleware
context.Items["UserId"] = userId;
return Convert.ToInt64(userIdClaim?.Value);
}
return 0;
}
}

4
LMS.service/LMS.service.csproj
View File

@ -7,12 +7,12 @@
<UserSecretsId>ed64fb6f-9c93-43d0-b418-61f507f28420</UserSecretsId>
<DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
<DockerfileContext>.</DockerfileContext>
<Version>1.0.3</Version>
<Version>1.0.0</Version>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="AutoMapper" Version="13.0.1" />
<PackageReference Include="Betalgo.Ranul.OpenAI" Version="8.9.0" />
<PackageReference Include="Microsoft.AspNet.Identity.Core" Version="2.2.4" />
<PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="8.0.8" />
<PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="8.0.8" />
<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.8">

2
LMS.service/Program.cs
View File

@ -2,7 +2,6 @@ using Lai_server.Configuration;
using LMS.DAO;
using LMS.Repository.Models.DB;
using LMS.service.Configuration;
using LMS.service.Configuration.InitConfiguration;
using LMS.service.Extensions.Middleware;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
@ -71,7 +70,6 @@ builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerService();
builder.Services.AddHostedService<RsaConfigurattions>();
builder.Services.AddHostedService<DatabaseConfiguration>();
var app = builder.Build();

147
LMS.service/Service/ForwardWordService.cs
View File

@ -1,147 +0,0 @@
using LMS.DAO;
using LMS.Repository.DB;
using LMS.Repository.Forward;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json;
using static LMS.Common.Enums.ResponseCodeEnum;
using System.Net;
using System.Text;
using LMS.Repository.Model;
using LMS.Tools;
using Betalgo.Ranul.OpenAI.Managers;
using Betalgo.Ranul.OpenAI;
using Betalgo.Ranul.OpenAI.ObjectModels.RequestModels;
namespace LMS.service.Service;
public class ForwardWordService(ApplicationDbContext context)
{
private readonly ApplicationDbContext _context = context;
/// <summary>
/// 转发OpenAi格式的请求 非流
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public async Task<ActionResult<APIResponseModel<object>>> ForwardWord(ForwardModel request)
{
try
{
// 要校验机器码，但是目前不需要
if (request.Word == null || request.Word == "")
{
return APIResponseModel<object>.CreateErrorResponseModel(ResponseCode.ParameterError);
}
// 获取提示词预设
Prompt? prompt = await _context.Prompt.FirstOrDefaultAsync(x => x.PromptTypeId == request.PromptTypeId && x.Id == request.PromptId);
if (prompt == null)
{
return APIResponseModel<object>.CreateErrorResponseModel(ResponseCode.FindPromptStringFail);
}
// 开始拼接请求体
using HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + request.ApiKey);
string json = JsonConvert.SerializeObject(new
{
model = request.Model,
temperature = 0.3,
messages = new List<OpenAI.RequestMessage>
{
new OpenAI.RequestMessage
{
role = "system",
content = prompt.PromptString
},
new OpenAI.RequestMessage
{
role = "user",
content = request.Word
}
}
});
// 判断请求的url是不是满足条件
if (string.IsNullOrEmpty(request.GptUrl))
{
throw new Exception("请求的url为空");
}
if (!request.GptUrl.StartsWith("https://ark.cn-beijing.volces.com") && !request.GptUrl.StartsWith("https://api.moonshot.cn") && !request.GptUrl.StartsWith("https://laitool.net") && !request.GptUrl.StartsWith("https://api.laitool.cc") && !request.GptUrl.StartsWith("https://laitool.cc"))
{
throw new Exception("请求的url不合法");
}
client.Timeout = Timeout.InfiniteTimeSpan;
var response = await client.PostAsync(request.GptUrl, new StringContent(json, Encoding.UTF8, "application/json"));
// 判断返回的状态码
if (response.StatusCode != HttpStatusCode.OK)
{
// 读取响应体
string responseContent = await response.Content.ReadAsStringAsync();
return APIResponseModel<object>.CreateErrorResponseModel(ResponseCode.ForwardWordFail, responseContent, "请求失败");
}
var content = await response.Content.ReadAsStringAsync();
// 序列化一下
return APIResponseModel<object>.CreateSuccessResponseModel(content);
}
catch (Exception e)
{
return APIResponseModel<object>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
}
}
public async IAsyncEnumerable<string> ForwardWordStream(ForwardModel request)
{
// 要校验机器码，但是目前不需要
if (request.Word == null || request.Word == "")
{
throw new Exception("参数错误");
}
// 获取提示词预设
Prompt? prompt = await _context.Prompt.FirstOrDefaultAsync(x => x.PromptTypeId == request.PromptTypeId && x.Id == request.PromptId);
if (prompt == null)
{
throw new Exception(ResponseCode.FindPromptStringFail.GetResult());
}
var openAiService = new OpenAIService(new OpenAIOptions()
{
ApiKey = request.ApiKey,
BaseDomain = request.GptUrl,
});
var completionResult = openAiService.ChatCompletion.CreateCompletionAsStream(new ChatCompletionCreateRequest
{
Messages = new List<ChatMessage>
{
ChatMessage.FromSystem(prompt.PromptString),
ChatMessage.FromUser(request.Word)
},
Model = request.Model,
Stream = true
});
await foreach (var completion in completionResult)
{
if (completion.Successful)
{ // 这边只返回数据，不返回全部的数据结构了
yield return completion.Choices.First().Message.Content ?? "";
}
else
{
if (completion.Error == null)
{
throw new Exception("Unknown Error");
}
throw new Exception($"{completion.Error.Code}: {completion.Error.Message}");
}
}
}
}

227
LMS.service/Service/MachineService.cs
View File

@ -1,6 +1,5 @@
using AutoMapper;
using LMS.DAO;
using LMS.Repository.DB;
using LMS.Repository.DTO;
using LMS.Repository.DTO.UserDto;
using LMS.Repository.Models.DB;
@ -43,6 +42,12 @@ 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();
@ -101,10 +106,10 @@ namespace LMS.service.Service
if (request.UserId == null)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "所属用户ID不能为空");
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError);
}
// 判断OwnerUserId是不是还能添加
User? ownerUser = await _userManager.FindByIdAsync((request.UserId ?? reqId).ToString());
User? ownerUser = await _userManager.FindByIdAsync(request.UserId.ToString());
if (ownerUser == null)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindUserByIdFail);
@ -126,47 +131,60 @@ namespace LMS.service.Service
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "机器码状态不正确");
}
// 检测laitool软件是否存在
Software? software = await _context.Software.FirstOrDefaultAsync(x => x.SoftwareCode == "1002");
if (software == null)
// 判断是不是VIP，不是VIP的话，判断之不是已经存在机器码
if (!await _userManager.IsInRoleAsync(ownerUser, "VIP User"))
{
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())
if (await _context.Machine.AnyAsync(x => x.UserID == ownerUser.Id))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "当前用户的软件控制权限已到期，请联系管理员");
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "普通用户只能添加一个机器码");
}
}
// 判断用户是不是还能不能添加机器码
var checkRes = await CanAddPermanentMachine(ownerUser, (long)(request.UserId ?? reqId), null, false);
if (checkRes.Code != 1)
if (request.UseStatus == MachineUseStatus.Trial)
{
return checkRes;
}
var checkRes = await CanAddPermanentMachine(ownerUser, (long)request.UserId, null, false);
if (checkRes.Code != 1)
{
return checkRes;
}
// 必传停用时间
if (request.DeactivationTime == null)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "试用机器码必须传入停用时间");
}
request.DeactivationTime = request.DeactivationTime?.AddHours(8);
// // 先修改用户的免费更换次数
ownerUser.FreeCount -= 1;
_context.Users.Update(ownerUser);
request.DeactivationTime = null;
// 判断停用时间是不是少于当前的
if (request.DeactivationTime < BeijingTimeExtension.GetBeijingTime())
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "到期时间不能小于当前时间");
}
Console.WriteLine(BeijingTimeExtension.GetBeijingTime().ToString());
int s = (request.DeactivationTime - BeijingTimeExtension.GetBeijingTime()).Value.Days;
// 判断当前时间和现在的时间差大于三天，报错
if ((request.DeactivationTime - BeijingTimeExtension.GetBeijingTime()).Value.Days >= 3)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "到期时间不能超过三天");
}
// 先修改用户的免费更换次数
ownerUser.FreeCount -= 1;
_context.Users.Update(ownerUser);
}
else
{
var checkRes = await CanAddPermanentMachine(ownerUser, (long)request.UserId, 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.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;
@ -230,7 +248,11 @@ namespace LMS.service.Service
try
{
// 获取对应的machine
Machine? machine = await _context.Machine.FirstOrDefaultAsync(x => x.MachineId == machineId && x.Status == MachineStatus.Active && x.DeactivationTime > BeijingTimeExtension.GetBeijingTime());
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 && DateTime.Now < x.DeactivationTime && x.Status == MachineStatus.Active)));
if (machine == null)
{
return APIResponseModel<MachineStatusResponse>.CreateErrorResponseModel(ResponseCode.MachineNotFound);
@ -261,6 +283,12 @@ namespace LMS.service.Service
using var transaction = _context.Database.BeginTransaction();
try
{
// 修改
// 判断当前用户是否有修改和管理机器码的权限
//if (!await _context.Permission.AnyAsync(x => x.UserId == reqId && (x.PermissionCode == SubPermissionType.ManageMachine || x.PermissionCode == SubPermissionType.ModifyMachine)))
//{
// return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
//}
// 判断传入的userId是否存在
User? user = await _userManager.FindByIdAsync(reqId.ToString());
if (user == null)
@ -278,7 +306,14 @@ namespace LMS.service.Service
bool isAdminOrSuperAdmin = await _userManager.IsInRoleAsync(user, "Admin") || await _userManager.IsInRoleAsync(user, "Super Admin");
if (!isAdminOrSuperAdmin)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction, "除管理员之外不可编辑");
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, "机器码不能修改");
}
}
// 判断当前修改后的机器码是否已经存在（不包含自己）
@ -287,10 +322,84 @@ 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.DeactivationTime = request.DeactivationTime;
}
if (request.Status == MachineStatus.Active && request.UseStatus == MachineUseStatus.Permanent)
{
machine.DeactivationTime = null;
}
machine.UseStatus = request.UseStatus;
machine.MachineId = request.MachineId;
machine.Status = request.Status;
machine.Remark = request.Remark;
_context.Machine.Update(machine);
@ -446,40 +555,32 @@ namespace LMS.service.Service
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindUserByIdFail);
}
// 直接判断是不是有软件控制权限
Software? software = await _context.Software.FirstOrDefaultAsync(x => x.SoftwareCode == "1002");
if (software == null)
// 判断当前用户是不是可以升级永久
// 判断用户是不是VIP
if (!await _userManager.IsInRoleAsync(ownerUser, "Vip User"))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "软件不存在，请联系管理员");
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.UserNotVip);
}
SoftwareControl? softwareControl = await _context.SoftwareControl.FirstOrDefaultAsync(x => x.UserId == ownerUser.Id && x.SoftwareId == software.Id);
if (softwareControl == null)
// 判断是不是已经有正在使用的机器码
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, "当前用户没有开通软件控制权限，请先申请软件控制权限并联系管理员开通服务");
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "当前用户正在绑定的机器码数量超过最大数量");
}
// 直接同步就行，不用管之前的，直接同步时间就行，把状态修改了就行
// 判断是不是可以使用，检测到期时间和是不是永久
var checkRes = await CanAddPermanentMachine(ownerUser, machine.UserID, machine.Id, true);
if (checkRes.Code != 1)
// 判断免费更换次数
if (ownerUser.FreeCount <= 0)
{
return checkRes;
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "当前用户更换机器码的次数已用完");
}
// 简单判断时间
if (!softwareControl.IsForever)
// 判断当前机器码是否已经是永久使用
if (machine.Status == MachineStatus.Active && machine.UseStatus == MachineUseStatus.Permanent)
{
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, "当前用户的软件控制权限已到期，请联系管理员");
}
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.InvalidOptions, "当前机器码已是永久");
}
// 先修改用户的免费更换次数
@ -488,8 +589,8 @@ namespace LMS.service.Service
machine.UpdateTime = BeijingTimeExtension.GetBeijingTime();
machine.Status = MachineStatus.Active;
machine.DeactivationTime = softwareControl.IsForever ? BeijingTimeExtension.GetBeijingTime().AddYears(5) : softwareControl.ExpirationTime;
machine.UseStatus = MachineUseStatus.Trial;
machine.UseStatus = MachineUseStatus.Permanent;
machine.DeactivationTime = null;
_context.Machine.Update(machine);
await _context.SaveChangesAsync();
await transaction.CommitAsync();

163
LMS.service/Service/OptionsService.cs
View File

@ -1,163 +0,0 @@
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
}
}

377
LMS.service/Service/PromptService/PromptService.cs
View File

@ -1,377 +0,0 @@
using AutoMapper;
using LMS.DAO;
using LMS.DAO.UserDAO;
using LMS.Repository.DB;
using LMS.Repository.DTO;
using LMS.Repository.DTO.PromptDto;
using LMS.Repository.DTO.PromptTypeDto;
using LMS.Repository.DTO.UserDto;
using LMS.Repository.Models.DB;
using LMS.Repository.PromptModel;
using LMS.Tools.Extensions;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;
using static LMS.Common.Enums.PromptEnum;
using static LMS.Common.Enums.ResponseCodeEnum;
namespace LMS.service.Service.PromptService;
public class PromptService(UserBasicDao userBasicDao, ApplicationDbContext context, IMapper mapper, UserManager<User> userManager)
{
private readonly UserBasicDao _userBasicDao = userBasicDao;
private readonly ApplicationDbContext _context = context;
private readonly IMapper _mapper = mapper;
private readonly UserManager<User> _userManager = userManager;
#region 查询数据集合
/// <summary>
/// 获取提示词数据的集合
/// </summary>
/// <param name="page"></param>
/// <param name="pageSize"></param>
/// <param name="name"></param>
/// <param name="promptTypeId"></param>
/// <param name="status"></param>
/// <param name="remark"></param>
/// <param name="reuqertUserId"></param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public async Task<ActionResult<APIResponseModel<CollectionResponse<PromptDto>>>> QueryPromptStringCollection(int page, int pageSize, string? name, string? promptTypeId, string? status, string? remark, long requertUserId)
{
try
{
bool isAdminAndSuperAdmin = await _userBasicDao.CheckUserIsAdminOrSuperAdmin(requertUserId);
if (!isAdminAndSuperAdmin)
{
return APIResponseModel<CollectionResponse<PromptDto>>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
IQueryable<Prompt>? query = _context.Prompt;
if (!string.IsNullOrEmpty(name))
{
query = query.Where(x => x.Name.Contains(name));
}
if (!string.IsNullOrEmpty(promptTypeId))
{
query = query.Where(x => x.PromptTypeId == promptTypeId);
}
if (!string.IsNullOrEmpty(status))
{
if (!PromptStatus.ValidStatuses.Contains(status))
{
return APIResponseModel<CollectionResponse<PromptDto>>.CreateErrorResponseModel(ResponseCode.ParameterError, "Status is invalid");
}
query = query.Where(x => x.Status == status);
}
if (!string.IsNullOrEmpty(remark))
{
query = query.Where(x => x.Remark.Contains(remark));
}
// 开始返回数据
// 通过ID降序
query = query.OrderByDescending(x => x.CreateTime);
// 查询总数
int total = await query.CountAsync();
// 分页
query = query.Skip((page - 1) * pageSize).Take(pageSize);
List<Prompt>? prompts = await query.ToListAsync();
List<PromptDto> promptDtos = [];
for (int i = 0; prompts != null && i < prompts.Count; i++)
{
Prompt prompt = prompts[i];
User? createdUser = await _userManager.FindByIdAsync(prompt.CreateUserId.ToString());
User? updatedUser = await _userManager.FindByIdAsync(prompt.UpdateUserId.ToString());
PromptDto promptDto = _mapper.Map<Prompt, PromptDto>(prompt);
promptDto.CreatedUser = _mapper.Map<UserBaseDto>(createdUser);
promptDto.UpdatedUser = _mapper.Map<UserBaseDto>(updatedUser);
PromptType? promptType = await _context.PromptType.FirstOrDefaultAsync(x => x.Id == prompt.PromptTypeId);
promptDto.PromptType = _mapper.Map<PromptTypeBasic>(promptType);
promptDtos.Add(promptDto);
}
return APIResponseModel<CollectionResponse<PromptDto>>.CreateSuccessResponseModel(new CollectionResponse<PromptDto>
{
Total = total,
Collection = promptDtos,
Current = page
});
}
catch (Exception e)
{
return APIResponseModel<CollectionResponse<PromptDto>>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
}
}
#endregion
#region 获取指定提示词的详细信息
/// <summary>
/// 获取指定提示词的详细信息
/// </summary>
/// <param name="id">提示词数据的ID</param>
/// <param name="reuqertUserId"></param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public async Task<ActionResult<APIResponseModel<PromptDto>>> GetPromptInfo(string id, long reuqertUserId)
{
try
{
bool isAdminAndSuperAdmin = await _userBasicDao.CheckUserIsAdminOrSuperAdmin(reuqertUserId);
if (!isAdminAndSuperAdmin)
{
return APIResponseModel<PromptDto>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
Prompt? prompt = await _context.Prompt.FirstOrDefaultAsync(x => x.Id == id);
if (prompt == null)
{
return APIResponseModel<PromptDto>.CreateErrorResponseModel(ResponseCode.FindPromptStringFail);
}
PromptDto promptDto = _mapper.Map<PromptDto>(prompt);
User? createdUser = await _userManager.FindByIdAsync(prompt.CreateUserId.ToString());
User? updatedUser = await _userManager.FindByIdAsync(prompt.UpdateUserId.ToString());
promptDto.CreatedUser = _mapper.Map<UserBaseDto>(createdUser);
promptDto.UpdatedUser = _mapper.Map<UserBaseDto>(updatedUser);
PromptType? promptType = await _context.PromptType.FirstOrDefaultAsync(x => x.Id == prompt.PromptTypeId);
promptDto.PromptType = _mapper.Map<PromptTypeBasic>(promptType);
return APIResponseModel<PromptDto>.CreateSuccessResponseModel(promptDto);
}
catch (Exception e)
{
return APIResponseModel<PromptDto>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
}
}
#endregion
#region 修改提示词预设数据
/// <summary>
/// 修改提示词预设数据
/// </summary>
/// <param name="id"></param>
/// <param name="model"></param>
/// <param name="requertUserId"></param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public async Task<ActionResult<APIResponseModel<string>>> ModifyPrompt(string id, ModifyPromptModel model, long requertUserId)
{
try
{
bool isAdminAndSuperAdmin = await _userBasicDao.CheckUserIsAdminOrSuperAdmin(requertUserId);
if (!isAdminAndSuperAdmin)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
Prompt? prompt = await _context.Prompt.FirstOrDefaultAsync(x => x.Id == id);
if (prompt == null)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindPromptStringFail);
}
if (!PromptStatus.ValidStatuses.Contains(model.Status))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "Status is invalid");
}
// 判断名字是不是存在
if (await _context.Prompt.AnyAsync(x => x.Name == model.Name && x.Id != id))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "名字已存在，新增失败");
}
if (!string.IsNullOrWhiteSpace(model.PromptTypeId))
{
PromptType? promptType = await _context.PromptType.FirstOrDefaultAsync(x => x.Id == model.PromptTypeId);
if (promptType == null)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "指定的提示词ID不存在，请检查");
}
prompt.PromptTypeCode = promptType.Code;
}
if (string.IsNullOrEmpty(model.PromptString))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "提示词预设不能为空，请检查");
}
prompt.Name = model.Name;
prompt.PromptTypeId = model.PromptTypeId;
prompt.PromptString = model.PromptString;
prompt.Description = model.Description;
prompt.Remark = model.Remark;
prompt.Status = model.Status;
prompt.Version = model.Version;
prompt.UpdateTime = BeijingTimeExtension.GetBeijingTime();
prompt.UpdateUserId = requertUserId;
_context.Update(prompt);
await _context.SaveChangesAsync();
return APIResponseModel<string>.CreateSuccessResponseModel("修改成功");
}
catch (Exception e)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
}
}
#endregion
#region 添加提示词数据
/// <summary>
/// 添加提示词数据
/// </summary>
/// <param name="model"></param>
/// <param name="requertUserId"></param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public async Task<ActionResult<APIResponseModel<string>>> AddPrompt(ModifyPromptModel model, long requertUserId)
{
try
{
Prompt prompt = _mapper.Map<Prompt>(model);
bool isAdminAndSuperAdmin = await _userBasicDao.CheckUserIsAdminOrSuperAdmin(requertUserId);
if (!isAdminAndSuperAdmin)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
// 判断是不是有相同的名字的数存在
if (await _context.Prompt.AnyAsync(x => x.Name == model.Name))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.PromptStringExist);
}
// 判断提示词类型是不是存在
if (string.IsNullOrWhiteSpace(model.PromptTypeId))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "提示词类型不能为空，请检查");
}
else
{
PromptType? promptType = await _context.PromptType.FirstOrDefaultAsync(x => x.Id == model.PromptTypeId);
if (promptType == null)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "指定的提示词类型ID不存在，请检查");
}
prompt.PromptTypeCode = promptType.Code;
}
// 判断状态
if (!PromptStatus.ValidStatuses.Contains(model.Status))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "Status is invalid");
}
prompt.Id = Guid.NewGuid().ToString();
prompt.CreateTime = BeijingTimeExtension.GetBeijingTime();
prompt.UpdateTime = BeijingTimeExtension.GetBeijingTime();
prompt.CreateUserId = requertUserId;
prompt.UpdateUserId = requertUserId;
prompt.Version = 1;
await _context.Prompt.AddAsync(prompt);
await _context.SaveChangesAsync();
return APIResponseModel<string>.CreateSuccessResponseModel(prompt.Id);
}
catch (Exception e)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
}
}
#endregion
#region 删除提示词数据
/// <summary>
/// 删除提示词数据
/// </summary>
/// <param name="id"></param>
/// <param name="requertUserId"></param>
/// <returns></returns>
public async Task<ActionResult<APIResponseModel<string>>> DeletePrompt(string id, long requertUserId)
{
try
{
bool isAdminAndSuperAdmin = await _userBasicDao.CheckUserIsAdminOrSuperAdmin(requertUserId);
if (!isAdminAndSuperAdmin)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
Prompt? prompt = await _context.Prompt.FirstOrDefaultAsync(x => x.Id == id);
if (prompt == null)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindPromptStringFail);
}
_context.Prompt.Remove(prompt);
await _context.SaveChangesAsync();
return APIResponseModel<string>.CreateSuccessResponseModel("删除成功");
}
catch (Exception e)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
}
}
#endregion
#region 获取指定的或者是所有的提示词预设数据 ID、Name
/// <summary>
/// 获取指定的或者是所有的提示词预设数据 ID、Name
/// </summary>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public async Task<ActionResult<APIResponseModel<List<PromptNameDto>>>> GetPromptOptions(string option)
{
try
{
IQueryable<Prompt> query = _context.Prompt;
List<Prompt> promptList = [];
if (option.Equals("all", StringComparison.CurrentCultureIgnoreCase))
{
// 全部
promptList = await query.ToListAsync();
}
else
{
PromptType? promptType = await _context.PromptType.FirstOrDefaultAsync(x => x.Id == option);
if (promptType == null)
{
return APIResponseModel<List<PromptNameDto>>.CreateErrorResponseModel(ResponseCode.ParameterError, "指定的提示词类型不存在，请检查");
}
query = query.Where(x => x.PromptTypeId == option);
promptList = await query.ToListAsync();
}
List<PromptNameDto> promptNames = [];
for (int i = 0; promptList != null && i < promptList.Count; i++)
{
Prompt prompt = promptList[i];
PromptNameDto promptName = new()
{
Id = prompt.Id,
Name = prompt.Name,
PromptTypeId = prompt.PromptTypeId
};
promptNames.Add(promptName);
}
return APIResponseModel<List<PromptNameDto>>.CreateSuccessResponseModel(promptNames);
}
catch (Exception e)
{
return APIResponseModel<List<PromptNameDto>>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
}
}
#endregion
}

358
LMS.service/Service/PromptService/PromptTypeService.cs
View File

@ -1,358 +0,0 @@
using AutoMapper;
using LMS.DAO;
using LMS.DAO.UserDAO;
using LMS.Repository.DTO;
using LMS.Repository.DTO.PromptTypeDto;
using LMS.Repository.DTO.UserDto;
using LMS.Repository.Models.DB;
using LMS.Repository.PromptModel;
using LMS.Tools.Extensions;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using static LMS.Common.Enums.PromptEnum;
using static LMS.Common.Enums.ResponseCodeEnum;
namespace LMS.service.Service.PromptService;
public class PromptTypeService
{
private readonly ApplicationDbContext _context;
private readonly IMapper _mapper;
private readonly UserBasicDao _userBaseDao;
private readonly UserManager<User> _userManager;
public PromptTypeService(ApplicationDbContext context, IMapper mapper, UserBasicDao userBaseDao, UserManager<User> userManager)
{
_context = context;
_mapper = mapper;
_userBaseDao = userBaseDao;
_userManager = userManager;
}
#region 获取当前的所有的提示词类型数据（分页）
/// <summary>
/// 获取当前的所有的提示词类型数据（分页）
/// </summary>
/// <param name="page"></param>
/// <param name="pageSize"></param>
/// <param name="code"></param>
/// <param name="name"></param>
/// <param name="status"></param>
/// <param name="remark"></param>
/// <param name="reuqertUserId"></param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public async Task<ActionResult<APIResponseModel<CollectionResponse<PromptTypeDto>>>> QueryPromptypeCollection(int page, int pageSize, string? code, string? name, string? status, string? remark, long reuqertUserId)
{
try
{
bool isAdminOrSuperAdmin = await _userBaseDao.CheckUserIsAdminOrSuperAdmin(reuqertUserId);
if (!isAdminOrSuperAdmin)
{
return APIResponseModel<CollectionResponse<PromptTypeDto>>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
// 开始查询
IQueryable<PromptType>? query = _context.PromptType;
if (!string.IsNullOrWhiteSpace(code))
{
query = query.Where(x => x.Code.Contains(code));
}
if (!string.IsNullOrWhiteSpace(name))
{
query = query.Where(x => x.Name.Contains(name));
}
if (!string.IsNullOrWhiteSpace(status))
{
if (!PromptTypeStatus.ValidStatuses.Contains(status))
{
return APIResponseModel<CollectionResponse<PromptTypeDto>>.CreateErrorResponseModel(ResponseCode.ParameterError, "Status is invalid");
}
query = query.Where(x => x.Status == status);
}
if (!string.IsNullOrWhiteSpace(remark))
{
query = query.Where(x => !string.IsNullOrWhiteSpace(x.Remark) && x.Remark.Contains(remark));
}
// 通过ID降序
query = query.OrderByDescending(x => x.CreateTime);
// 查询总数
int total = await query.CountAsync();
// 分页
query = query.Skip((page - 1) * pageSize).Take(pageSize);
List<PromptType>? prompttypes = await query.ToListAsync();
List<PromptTypeDto> promptTypeDtos = [];
for (int i = 0; prompttypes != null && i < prompttypes.Count; i++)
{
PromptType prompttype = prompttypes[i];
User? createdUser = await _userManager.FindByIdAsync(prompttype.CreateUserId.ToString());
User? updatedUser = await _userManager.FindByIdAsync(prompttype.UpdateUserId.ToString());
PromptTypeDto promptTypeDto = _mapper.Map<PromptType, PromptTypeDto>(prompttype);
promptTypeDto.CreatedUser = _mapper.Map<UserBaseDto>(createdUser);
promptTypeDto.UpdatedUser = _mapper.Map<UserBaseDto>(updatedUser);
promptTypeDtos.Add(promptTypeDto);
}
return APIResponseModel<CollectionResponse<PromptTypeDto>>.CreateSuccessResponseModel(new CollectionResponse<PromptTypeDto>
{
Total = total,
Collection = promptTypeDtos,
Current = page,
});
}
catch (Exception e)
{
return APIResponseModel<CollectionResponse<PromptTypeDto>>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
}
}
#endregion
#region 通过ID获取详细的提示词类型信息
/// <summary>
/// 通过ID获取详细的提示词类型信息
/// </summary>
/// <param name="id"></param>
/// <param name="reuqertUserId"></param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public async Task<ActionResult<APIResponseModel<PromptTypeDto>>> GetPromptTypeInfo(string id, long reuqertUserId)
{
try
{
bool isAdminOrSuperAdmin = await _userBaseDao.CheckUserIsAdminOrSuperAdmin(reuqertUserId);
if (!isAdminOrSuperAdmin)
{
return APIResponseModel<PromptTypeDto>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
PromptType? promptType = await _context.PromptType.FirstOrDefaultAsync(x => x.Id == id);
if (promptType == null)
{
return APIResponseModel<PromptTypeDto>.CreateErrorResponseModel(ResponseCode.FindPromptTypeFail);
}
PromptTypeDto promptTypeDto = _mapper.Map<PromptTypeDto>(promptType);
User? createdUser = await _userManager.FindByIdAsync(promptType.CreateUserId.ToString());
User? updatedUser = await _userManager.FindByIdAsync(promptType.UpdateUserId.ToString());
promptTypeDto.CreatedUser = _mapper.Map<UserBaseDto>(createdUser);
promptTypeDto.UpdatedUser = _mapper.Map<UserBaseDto>(updatedUser);
return APIResponseModel<PromptTypeDto>.CreateSuccessResponseModel(promptTypeDto);
}
catch (Exception e)
{
return APIResponseModel<PromptTypeDto>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
}
}
#endregion
#region 修改提示词类型数据
/// <summary>
/// 修改提示词类型数据
/// </summary>
/// <param name="id"></param>
/// <param name="modal"></param>
/// <param name="reuqertUserId"></param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public async Task<ActionResult<APIResponseModel<string>>> ModityPromptType(string id, ModifyPromptTypeModal modal, long reuqertUserId)
{
using var transaction = _context.Database.BeginTransaction();
try
{
bool isAdminOrSuperAdmin = await _userBaseDao.CheckUserIsAdminOrSuperAdmin(reuqertUserId);
if (!isAdminOrSuperAdmin)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
PromptType? promptType = await _context.PromptType.FirstOrDefaultAsync(x => x.Id == id);
if (promptType == null)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindPromptTypeFail);
}
if (!PromptTypeStatus.ValidStatuses.Contains(modal.Status))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "Status is invalid");
}
// 判断name是不是存在相同的
if (await _context.PromptType.AnyAsync(x => x.Name == modal.Name && x.Id != id))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "名称已存在");
}
if (await _context.PromptType.AnyAsync(x => x.Code == modal.Code && x.Id != id))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "Code已存在");
}
promptType.Code = modal.Code;
promptType.Name = modal.Name;
promptType.Status = modal.Status;
promptType.Remark = modal.Remark;
promptType.UpdateTime = BeijingTimeExtension.GetBeijingTime();
promptType.UpdateUserId = reuqertUserId;
await _context.SaveChangesAsync();
await transaction.CommitAsync();
return APIResponseModel<string>.CreateSuccessResponseModel("修改提示词类型数据成功");
}
catch (Exception e)
{
await transaction.RollbackAsync();
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
}
}
#endregion
#region 添加提示词类型数据
/// <summary>
/// 添加提示词类型数据
/// </summary>
/// <param name="modal"></param>
/// <param name="reuqertUserId"></param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public async Task<ActionResult<APIResponseModel<string>>> AddPromptType(ModifyPromptTypeModal modal, long reuqertUserId)
{
try
{
bool isAdminOrSuperAdmin = await _userBaseDao.CheckUserIsAdminOrSuperAdmin(reuqertUserId);
if (!isAdminOrSuperAdmin)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
if (!PromptTypeStatus.ValidStatuses.Contains(modal.Status))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "Status is invalid");
}
// 判断name是不是存在相同的
if (await _context.PromptType.AnyAsync(x => x.Name == modal.Name))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "名称已存在");
}
if (await _context.PromptType.AnyAsync(x => x.Code == modal.Code))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "Code已存在");
}
// 开始添加
// 开始添加数据
PromptType promptType = new()
{
Id = System.Guid.NewGuid().ToString(),
Code = modal.Code,
Name = modal.Name,
CreateTime = System.DateTime.Now,
UpdateTime = System.DateTime.Now,
CreateUserId = reuqertUserId,
UpdateUserId = reuqertUserId,
Remark = modal.Remark,
Status = modal.Status,
IsDeleted = false
};
await _context.PromptType.AddAsync(promptType);
await _context.SaveChangesAsync();
return APIResponseModel<string>.CreateSuccessResponseModel("添加提示词类型数据成功");
}
catch (Exception e)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
}
}
#endregion
#region 删除提示词类型数据
/// <summary>
/// 删除提示词类型数据
/// </summary>
/// <param name="id"></param>
/// <param name="reuqertUserId"></param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public async Task<ActionResult<APIResponseModel<string>>> DeletePromptType(string id, long reuqertUserId, bool deletePrompt)
{
try
{
bool isAdminOrSuperAdmin = await _userBaseDao.CheckUserIsAdminOrSuperAdmin(reuqertUserId);
if (!isAdminOrSuperAdmin)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
PromptType? promptType = await _context.PromptType.FirstOrDefaultAsync(x => x.Id == id);
if (promptType == null)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindPromptTypeFail);
}
// 判断是不是删除所有的提示词类型相关的提示词数据
bool hasPrompt = await _context.Prompt.AnyAsync(x => x.PromptTypeId == promptType.Id);
if (hasPrompt && !deletePrompt)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.PromptStringExist, "当前删除的提示词类型数据有关联的提示词数据");
}
if (hasPrompt && deletePrompt)
{
// 直接删除全部数据
_context.Prompt.RemoveRange(_context.Prompt.Where(x => x.PromptTypeId == promptType.Id));
await _context.SaveChangesAsync();
}
_context.PromptType.Remove(promptType);
await _context.SaveChangesAsync();
return APIResponseModel<string>.CreateSuccessResponseModel("删除提示词类型数据成功以及所有的关联提示词数据成功");
}
catch (Exception e)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
}
}
#endregion
#region 获取所有的提示词类型的选项，ID和Name
/// <summary>
/// 获取所有的提示词类型的选项，ID和Name
/// </summary>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public async Task<ActionResult<APIResponseModel<List<PrompTypeNameModel>>>> GetPromptTypeOptions()
{
try
{
List<PromptType> promptTypes = await _context.PromptType.ToListAsync();
List<PrompTypeNameModel> promptNameModels = [];
foreach (var item in promptTypes)
{
promptNameModels.Add(new PrompTypeNameModel
{
Id = item.Id,
Name = item.Name
});
};
return APIResponseModel<List<PrompTypeNameModel>>.CreateSuccessResponseModel(promptNameModels);
}
catch (Exception e)
{
return APIResponseModel<List<PrompTypeNameModel>>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
}
}
#endregion
}

474
LMS.service/Service/SoftwareService/SoftwareControlService.cs
View File

@ -1,474 +0,0 @@
using AutoMapper;
using LMS.Common.Enum;
using LMS.DAO;
using LMS.DAO.UserDAO;
using LMS.Repository.DB;
using LMS.Repository.DTO;
using LMS.Repository.DTO.Software;
using LMS.Repository.DTO.UserDto;
using LMS.Repository.Models.DB;
using LMS.Repository.Software;
using LMS.Tools;
using LMS.Tools.Extensions;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using static LMS.Common.Enums.ResponseCodeEnum;
namespace LMS.service.Service.SoftwareService
{
public class SoftwareControlService(UserBasicDao userBasicDao, ApplicationDbContext dbContext, IMapper mapper)
{
private readonly UserBasicDao _userBasicDao = userBasicDao;
private readonly ApplicationDbContext _dbContext = dbContext;
private readonly IMapper _mapper = mapper;
#region 软件控制-同步用户的软件控制权限
/// <summary>
/// 用户自动同步软件控制，和software中的一致，只要没有的数据都同步上，不管isUse，这个会在后面过滤掉
/// </summary>
/// <param name="id"></param>
/// <param name=""></param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
internal async Task<ActionResult<APIResponseModel<string>>> ApplySoftwareControl(long id, long requestUserId)
{
using var transaction = _dbContext.Database.BeginTransaction();
try
{
// 用户ID和请求ID不一致，且请求ID不是管理员或超级管理员，返回无权限操作
if (id != requestUserId && !await _userBasicDao.CheckUserIsAdminOrSuperAdmin(requestUserId))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
// 检查用户是否存在
if (!await _userBasicDao.CheckUserExistsByID(id))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindUserByIdFail);
}
List<SoftwareControl> softwareControl = await _dbContext.SoftwareControl.Where(x => x.UserId == id).ToListAsync();
List<Software> software = await _dbContext.Software.ToListAsync();
bool isAdd = false;
// 判断是不是所有的软件都有权限，如果没有就添加
foreach (var item in software)
{
if (softwareControl.FirstOrDefault(x => x.SoftwareId == item.Id) == null)
{
SoftwareControl softwareControlModel = new SoftwareControl
{
Id = Guid.NewGuid().ToString(),
UserId = id,
SoftwareId = item.Id,
CreatedUserId = requestUserId,
CreatedTime = BeijingTimeExtension.GetBeijingTime(),
UpdatedUserId = requestUserId,
UpdatedTime = BeijingTimeExtension.GetBeijingTime(),
Remark = string.Empty,
IsForever = false,
ExpirationTime = null,
};
await _dbContext.SoftwareControl.AddAsync(softwareControlModel);
isAdd = true;
}
}
// 判断现在的，将再soft中没有的软件控制删除
foreach (var item1 in softwareControl)
{
if (software.FirstOrDefault(x => x.Id == item1.SoftwareId) == null)
{
_dbContext.SoftwareControl.Remove(item1);
isAdd = true;
}
}
await _dbContext.SaveChangesAsync();
await transaction.CommitAsync();
if (isAdd)
{
return APIResponseModel<string>.CreateSuccessResponseModel("同步所有的软件权限成功");
}
else
{
return APIResponseModel<string>.CreateSuccessResponseModel("当前已获取所有的软件控制权限，不需要做处理");
}
}
catch (Exception ex)
{
await transaction.RollbackAsync();
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, ex.Message);
}
}
#endregion
#region 软件控制-设置软件的到期时间和是否永久
/// <summary>
/// 设置软件的到期时间和是否永久
/// </summary>
/// <param name="id">软件控制项的ID</param>
/// <param name="model">传入的数据</param>
/// <param name="requestUserId">请求的用户ID</param>
/// <returns></returns>
public async Task<ActionResult<APIResponseModel<string>>> ModifySoftwareControlValidity(string id, ModifySoftwareControlValidityModel model, long requestUserId)
{
try
{
if (model.IsForever == null && model.ExpirationTime == null && model.IsTry == null)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError);
}
model.IsTry ??= false;
// 检查用户是不是管理员
if (!await _userBasicDao.CheckUserIsAdminOrSuperAdmin(requestUserId))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
// 判断指定ID的软件控制项是否存在
SoftwareControl? softwareControl = await _dbContext.SoftwareControl.FirstOrDefaultAsync(x => x.Id == id);
if (softwareControl == null)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.IdDateNotFound);
}
// 试用
if (model.IsTry == true)
{
// 设置更新时间和更新人
softwareControl.UpdatedTime = BeijingTimeExtension.GetBeijingTime();
softwareControl.UpdatedUserId = requestUserId;
double trialDays = 1;
Options? options = await _dbContext.Options.FirstOrDefaultAsync(x => x.Key == "LaiToolTrialDays");
if (options != null)
{
double s = options.GetValueObject<double>();
trialDays = s;
}
softwareControl.ExpirationTime = BeijingTimeExtension.GetBeijingTime().AddDays(trialDays);
softwareControl.IsForever = false;
// 更新数据库
_dbContext.SoftwareControl.Update(softwareControl);
await _dbContext.SaveChangesAsync();
return APIResponseModel<string>.CreateSuccessResponseModel("修改成功");
}
if (model.ExpirationTime != null)
{
// 判断model传入的枚举值是不是再对应的enum中是有效的
if (!Enum.IsDefined(typeof(SoftwareControlEnum.SoftwareControlValidityEnum), model.ExpirationTime))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "传入的到期时间不在有效范围内");
}
}
// 判断当前数据是不是永久，如果是永久，就不能修改
if (softwareControl.IsForever && model.IsForever == true)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "当前已是永久，不可再修改");
}
// 判断传入的modal的IsForever是不是true，是的话直接设置未永久，不是的话，设置到期时间
if (model.IsForever == true)
{
softwareControl.IsForever = true;
softwareControl.ExpirationTime = null;
}
else
{
// 这边判断现在的到期时间是不是大于现在的时间，是的话，再到期时间的基础上加上传入的时间，不是的话，直接再现在时间加上传入的时间，如果现在是永久，直接设置到期时间为现在时间加上传入的时间
if (model.ExpirationTime == null)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "当前到期时间为空，不可修改");
}
if (softwareControl.IsForever == true)
{
softwareControl.ExpirationTime = BeijingTimeExtension.GetBeijingTime().AddDays((double)model.ExpirationTime.Value);
softwareControl.IsForever = false;
}
else
{
if (softwareControl.ExpirationTime > BeijingTimeExtension.GetBeijingTime())
{
if (model.ExpirationTime == SoftwareControlEnum.SoftwareControlValidityEnum.Zero)
{
softwareControl.ExpirationTime = BeijingTimeExtension.GetBeijingTime();
}
else
{
softwareControl.ExpirationTime = softwareControl.ExpirationTime.Value.AddDays((double)model.ExpirationTime.Value);
}
}
else
{
softwareControl.ExpirationTime = BeijingTimeExtension.GetBeijingTime().AddDays((double)model.ExpirationTime.Value);
}
}
}
// 设置更新时间和更新人
softwareControl.UpdatedTime = BeijingTimeExtension.GetBeijingTime();
softwareControl.UpdatedUserId = requestUserId;
// 更新数据库
_dbContext.SoftwareControl.Update(softwareControl);
await _dbContext.SaveChangesAsync();
return APIResponseModel<string>.CreateSuccessResponseModel("修改成功");
}
catch (Exception ex)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, ex.Message);
}
}
#endregion
#region 软件控制-获取软件信息的集合
/// <summary>
/// 获取软件信息的集合
/// </summary>
/// <param name="page"></param>
/// <param name="pageSize"></param>
/// <param name="userId"></param>
/// <param name="softwareId"></param>
/// <param name="isForever"></param>
/// <param name="remark"></param>
/// <param name="reuqestUserId"></param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public async Task<ActionResult<APIResponseModel<CollectionResponse<SoftwareControlCollectionDto>>>> GetSoftwareControlCollection(int page, int pageSize, long? userId, string? softwareId, bool? isForever, string? remark, long requestUserId)
{
try
{
// 判断权限，如果不是管理员或超级管理员，就判断是不是自己的数据，不是的话，返回无权限操作
IQueryable<SoftwareControl> query = _dbContext.SoftwareControl.AsQueryable();
bool isAdminOrSuperAdmin = await _userBasicDao.CheckUserIsAdminOrSuperAdmin(requestUserId);
if (!isAdminOrSuperAdmin && userId != requestUserId)
{
return APIResponseModel<CollectionResponse<SoftwareControlCollectionDto>>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
if (userId != null)
{
query = query.Where(x => x.UserId == userId);
}
if (softwareId != null)
{
query = query.Where(x => x.SoftwareId == softwareId);
}
if (isForever != null)
{
query = query.Where(x => x.IsForever == isForever);
}
if (!string.IsNullOrWhiteSpace(remark))
{
query = query.Where(x => x.Remark.Contains(remark));
}
if (!isAdminOrSuperAdmin)
{
// 通过 softwareId 过滤掉isUse为false的数
List<string> softwareIds = await _dbContext.Software.Where(x => x.IsUse == true).Select(x => x.Id).ToListAsync();
query = query.Where(x => softwareIds.Contains(x.SoftwareId));
}
// 通过ID降序
query = query.OrderByDescending(x => x.CreatedTime);
// 查询总数
int total = await query.CountAsync();
// 分页
query = query.Skip((page - 1) * pageSize).Take(pageSize);
List<SoftwareControl> softwareControls = await query.ToListAsync();
List<SoftwareControlCollectionDto> softwareControlCollectionDtos = new List<SoftwareControlCollectionDto>();
foreach (var item in softwareControls)
{
SoftwareControlCollectionDto softwareControlCollectionDto = new SoftwareControlCollectionDto
{
Id = item.Id,
IsForever = item.IsForever,
ExpirationTime = item.ExpirationTime,
Remark = item.Remark,
CreatedTime = item.CreatedTime,
UpdatedTime = item.UpdatedTime,
};
Software? software = await _dbContext.Software.FirstOrDefaultAsync(x => x.Id == item.SoftwareId);
if (software != null)
{
softwareControlCollectionDto.Software = software;
}
User? user = await _dbContext.Users.FirstOrDefaultAsync(x => x.Id == item.UserId);
softwareControlCollectionDto.User = _mapper.Map<UserBaseDto>(user);
softwareControlCollectionDto.User.HideContactInfo();
User? createdUser = await _dbContext.Users.FirstOrDefaultAsync(x => x.Id == item.CreatedUserId);
softwareControlCollectionDto.CreatedUser = _mapper.Map<UserBaseDto>(createdUser);
softwareControlCollectionDto.CreatedUser.HideContactInfo();
User? updatedUser = await _dbContext.Users.FirstOrDefaultAsync(x => x.Id == item.UpdatedUserId);
softwareControlCollectionDto.UpdatedUser = _mapper.Map<UserBaseDto>(updatedUser);
softwareControlCollectionDto.UpdatedUser.HideContactInfo();
softwareControlCollectionDtos.Add(softwareControlCollectionDto);
}
return APIResponseModel<CollectionResponse<SoftwareControlCollectionDto>>.CreateSuccessResponseModel(new CollectionResponse<SoftwareControlCollectionDto>
{
Total = total,
Collection = softwareControlCollectionDtos,
Current = page,
});
}
catch (Exception ex)
{
return APIResponseModel<CollectionResponse<SoftwareControlCollectionDto>>.CreateErrorResponseModel(ResponseCode.SystemError, ex.Message);
}
}
#endregion
#region 软件控制-删除软件控制数据
/// <summary>
/// 删除软件控制数据
/// </summary>
/// <param name="id"></param>
/// <param name="requestUserId"></param>
/// <returns></returns>
public async Task<ActionResult<APIResponseModel<string>>> DeleteSoftwareControl(string id, long requestUserId)
{
try
{
if (!await _userBasicDao.CheckUserIsAdminOrSuperAdmin(requestUserId))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
SoftwareControl? softwareControl = await _dbContext.SoftwareControl.FirstOrDefaultAsync(x => x.Id == id);
if (softwareControl == null)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.IdDateNotFound);
}
_dbContext.SoftwareControl.Remove(softwareControl);
await _dbContext.SaveChangesAsync();
return APIResponseModel<string>.CreateSuccessResponseModel("删除成功");
}
catch (Exception ex)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, ex.Message);
}
}
#endregion
#region 软件检查权限以及登录状态
/// <summary>
/// 检查软件控制权限 以及登录状态
/// </summary>
/// <param name="userID"></param>
/// <param name="machineId"></param>
/// <param name="softwareId"></param>
/// <returns></returns>
public async Task<ActionResult<APIResponseModel<string>>> CheckSoftwareControl(long userID, string machineId, string softwareId)
{
try
{
// 判断软件是不是存在
if (!await _dbContext.Software.AnyAsync(x => x.Id == softwareId))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.IdDateNotFound);
}
// 判断是不是有关联信息，没有的话就是没有登录，或者是机器码不一致，再其他地方登录过了
UserSoftware? userSoftware = await _dbContext.UserSoftware.FirstOrDefaultAsync(x => x.UserId == userID && x.MachineId == machineId);
if (userSoftware == null)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction, "无用户登录信息或登录信息不正确，请确认是不是登录多次，请重新登录");
}
// 判断是不是有权限
SoftwareControl? softwareControl = await _dbContext.SoftwareControl.FirstOrDefaultAsync(x => x.UserId == userID && x.SoftwareId == softwareId);
if (softwareControl == null)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction, "无权限操作，请先申请权限");
}
// 判断是不是还能用
if (softwareControl.IsForever == true || softwareControl.ExpirationTime > BeijingTimeExtension.GetBeijingTime())
{
// 可用
return APIResponseModel<string>.CreateSuccessResponseModel("1");
}
else
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction, "权限已过期，请重新申请");
}
}
catch (Exception ex)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, ex.Message);
}
}
#endregion
#region 软件控制-用户可申请的软件控制数量
/// <summary>
/// 用户可申请的软件控制数量
/// </summary>
/// <param name="userId"></param>
/// <param name="requestUserId"></param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public async Task<ActionResult<APIResponseModel<int>>> GetUserSoftwareControlCount(long userId, long requestUserId)
{
try
{
bool isAdminOrSuperAdmin = await _userBasicDao.CheckUserIsAdminOrSuperAdmin(requestUserId);
if (!isAdminOrSuperAdmin && userId != requestUserId)
{
return APIResponseModel<int>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
User? user = await _dbContext.Users.FirstOrDefaultAsync(x => x.Id == userId);
if (user == null)
{
return APIResponseModel<int>.CreateErrorResponseModel(ResponseCode.FindUserByIdFail);
}
List<Software> software = await _dbContext.Software.Where(x => x.IsUse == true).ToListAsync();
List<SoftwareControl> softwareControls = await _dbContext.SoftwareControl.Where(x => x.UserId == userId).ToListAsync();
// 判断software中的softwareId是否在softwareControl中，不在的话，不在的话计数
int count = 0;
foreach (var item in software)
{
if (softwareControls.FirstOrDefault(x => x.SoftwareId == item.Id) == null)
{
count++;
}
}
return APIResponseModel<int>.CreateSuccessResponseModel(count);
}
catch (Exception ex)
{
return APIResponseModel<int>.CreateErrorResponseModel(ResponseCode.SystemError, ex.Message);
}
}
#endregion
}
}

320
LMS.service/Service/SoftwareService/SoftwareService.cs
View File

@ -1,320 +0,0 @@
using AutoMapper;
using LMS.DAO;
using LMS.DAO.UserDAO;
using LMS.Repository.DB;
using LMS.Repository.DTO;
using LMS.Repository.DTO.Software;
using LMS.Repository.DTO.UserDto;
using LMS.Repository.Models.DB;
using LMS.Repository.Software;
using LMS.Tools.Extensions;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using static LMS.Common.Enums.ResponseCodeEnum;
namespace LMS.service.Service.SoftwareService
{
public class SoftwareService(UserBasicDao userBasicDao, ApplicationDbContext dbContext, IMapper mapper)
{
private readonly UserBasicDao _userBasicDao = userBasicDao;
private readonly ApplicationDbContext _dbContext = dbContext;
private readonly IMapper _mapper = mapper;
#region 添加软件数据
/// <summary>
/// 添加软件数据
/// </summary>
/// <param name="software"></param>
/// <param name="reuqestUserId"></param>
/// <returns></returns>
public async Task<ActionResult<APIResponseModel<string>>> AddSoftware(AddSoftwareModel software, long reuqestUserId)
{
try
{
// 判断用户是不是超级管理员
if (!(await _userBasicDao.CheckUserIsSuperAdmin(reuqestUserId)))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
// 判断软件名字软件代码是不是存在,存在的话,报错
bool isSoftwareExists = await _dbContext.Software.AnyAsync(x => x.SoftwareName == software.SoftwareName || x.SoftwareCode == software.SoftwareCode);
if (isSoftwareExists)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "软件名称或软件编码已存在,请检查");
}
// 开始添加软件
Software software1 = new Software
{
Id = Guid.NewGuid().ToString(),
SoftwareName = software.SoftwareName,
SoftwareCode = software.SoftwareCode,
CreatedUserId = reuqestUserId,
UpdatedUserId = reuqestUserId,
CreatedTime = BeijingTimeExtension.GetBeijingTime(),
UpdatedTime = BeijingTimeExtension.GetBeijingTime(),
Remark = string.Empty,
IsUse = true
};
await _dbContext.Software.AddAsync(software1);
await _dbContext.SaveChangesAsync();
// Add software
return APIResponseModel<string>.CreateSuccessResponseModel("Add software successfully");
}
catch (Exception ex)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, ex.Message);
}
}
#endregion
#region 修改软件信息
/// <summary>
/// 修改软件信息
/// </summary>
/// <param name="id"></param>
/// <param name="software"></param>
/// <param name="reuqestUserId"></param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public async Task<ActionResult<APIResponseModel<string>>> ModifySoftware(string id, AddSoftwareModel software, long reuqestUserId)
{
try
{
// 判断用户是不是超级管理员
if (!(await _userBasicDao.CheckUserIsSuperAdmin(reuqestUserId)))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
// 判断传入的ID是不是存在
Software? software2 = await _dbContext.Software.FirstOrDefaultAsync(x => x.Id == id);
if (software2 == null)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "Software does not exist");
}
// 判断软件名字软件代码是不是存在，不包含当前的,存在的话,报错
bool isSoftwareExists = await _dbContext.Software.AnyAsync(x => (x.SoftwareName == software.SoftwareName || x.SoftwareCode == software.SoftwareCode) && x.Id != id);
if (isSoftwareExists)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "软件名称或软件编码已存在,请检查");
}
software2.SoftwareName = software.SoftwareName;
software2.SoftwareCode = software.SoftwareCode;
software2.UpdatedUserId = reuqestUserId;
software2.UpdatedTime = BeijingTimeExtension.GetBeijingTime();
_dbContext.Update(software2);
await _dbContext.SaveChangesAsync();
return APIResponseModel<string>.CreateSuccessResponseModel("Modify software successfully");
}
catch (Exception ex)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, ex.Message);
}
}
#endregion
#region 获取软件列表信息
/// <summary>
/// 获取软件信息的列表，可以使用查询条件 softwareName, softwareCode
/// </summary>
/// <param name="page"></param>
/// <param name="pageSize"></param>
/// <param name="softwareName"></param>
/// <param name="softwareCode"></param>
/// <param name="reuqestUserId"></param>
/// <returns></returns>
public async Task<ActionResult<APIResponseModel<CollectionResponse<SoftwareCollectionDto>>>> GetSoftwareCollection(int page, int pageSize, string? softwareName, string? softwareCode, long reuqestUserId, bool? isUse)
{
try
{
if (!await _userBasicDao.CheckUserIsSuperAdmin(reuqestUserId))
{
return APIResponseModel<CollectionResponse<SoftwareCollectionDto>>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
IQueryable<Software> query = _dbContext.Software.AsQueryable();
if (!string.IsNullOrWhiteSpace(softwareName))
{
query = query.Where(x => x.SoftwareName.Contains(softwareName));
}
if (!string.IsNullOrWhiteSpace(softwareCode))
{
query = query.Where(x => x.SoftwareCode.Contains(softwareCode));
}
if (isUse != null)
{
query = query.Where(x => x.IsUse == isUse);
}
// 按照创建时间排序
query = query.OrderByDescending(x => x.CreatedTime);
// 计算总数
int count = await query.CountAsync();
// 分页
List<Software> softwareList = await query.Skip((page - 1) * pageSize).Take(pageSize).ToListAsync();
List<SoftwareCollectionDto> softwareCollectionDtos = [];
for (int i = 0; i < softwareList.Count; i++)
{
SoftwareCollectionDto softwareCollectionDto = new()
{
Id = softwareList[i].Id,
SoftwareName = softwareList[i].SoftwareName,
SoftwareCode = softwareList[i].SoftwareCode,
CreatedTime = softwareList[i].CreatedTime,
UpdatedTime = softwareList[i].UpdatedTime,
Remark = softwareList[i].Remark,
IsUse = softwareList[i].IsUse
};
User? createdUser = await _dbContext.Users.FirstOrDefaultAsync(x => x.Id == softwareList[i].CreatedUserId);
softwareCollectionDto.CreatedUser = _mapper.Map<UserBaseDto>(createdUser);
softwareCollectionDto.CreatedUser.HideContactInfo();
User? updatedUser = await _dbContext.Users.FirstOrDefaultAsync(x => x.Id == softwareList[i].UpdatedUserId);
softwareCollectionDto.UpdatedUser = _mapper.Map<UserBaseDto>(updatedUser);
softwareCollectionDto.UpdatedUser.HideContactInfo();
softwareCollectionDtos.Add(softwareCollectionDto);
}
return APIResponseModel<CollectionResponse<SoftwareCollectionDto>>.CreateSuccessResponseModel(new CollectionResponse<SoftwareCollectionDto>
{
Total = count,
Collection = softwareCollectionDtos,
Current = page
});
}
catch (Exception ex)
{
return APIResponseModel<CollectionResponse<SoftwareCollectionDto>>.CreateErrorResponseModel(ResponseCode.SystemError, ex.Message);
}
}
#endregion
#region 获取软件信息，通用ID
/// <summary>
/// 获取软件信息，通过ID
/// </summary>
/// <param name="id"></param>
/// <param name="reuqestUserId"></param>
/// <returns></returns>
public async Task<ActionResult<APIResponseModel<SoftwareCollectionDto>>> GetSoftwareInfoById(string id, long reuqestUserId)
{
try
{
if (!await _userBasicDao.CheckUserIsSuperAdmin(reuqestUserId))
{
return APIResponseModel<SoftwareCollectionDto>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
Software? software = await _dbContext.Software.FirstOrDefaultAsync(x => x.Id == id);
if (software == null)
{
return APIResponseModel<SoftwareCollectionDto>.CreateErrorResponseModel(ResponseCode.ParameterError, "Software does not exist");
}
SoftwareCollectionDto softwareCollection = new SoftwareCollectionDto
{
Id = software.Id,
SoftwareName = software.SoftwareName,
SoftwareCode = software.SoftwareCode,
CreatedTime = software.CreatedTime,
UpdatedTime = software.UpdatedTime,
Remark = software.Remark,
IsUse = software.IsUse
};
User? createdUser = await _dbContext.Users.FirstOrDefaultAsync(x => x.Id == software.CreatedUserId);
softwareCollection.CreatedUser = _mapper.Map<UserBaseDto>(createdUser);
User? updatedUser = await _dbContext.Users.FirstOrDefaultAsync(x => x.Id == software.UpdatedUserId);
softwareCollection.UpdatedUser = _mapper.Map<UserBaseDto>(updatedUser);
return APIResponseModel<SoftwareCollectionDto>.CreateSuccessResponseModel(softwareCollection);
}
catch (Exception ex)
{
return APIResponseModel<SoftwareCollectionDto>.CreateErrorResponseModel(ResponseCode.SystemError, ex.Message);
}
}
#endregion
#region 删除软件数据
/// <summary>
/// 删除软件，通过软件ID
/// </summary>
/// <param name="id"></param>
/// <param name="reuqestUserId"></param>
/// <returns></returns>
public async Task<ActionResult<APIResponseModel<string>>> DeleteSoftware(string id, long reuqestUserId)
{
try
{
if (!await _userBasicDao.CheckUserIsSuperAdmin(reuqestUserId))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
Software? software = await _dbContext.Software.FirstOrDefaultAsync(x => x.Id == id);
if (software == null)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "Software does not exist");
}
software.IsUse = false;
_dbContext.Software.Update(software);
await _dbContext.SaveChangesAsync();
return APIResponseModel<string>.CreateSuccessResponseModel("soft Delete software successfully");
//Software? software = await _dbContext.Software.FirstOrDefaultAsync(x => x.Id == id);
//if (software == null)
//{
// return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "Software does not exist");
//}
//// 开始删除软件
//_dbContext.Software.Remove(software);
////TODO: 删除软件相关的数据（用户软件关联表，软件控制表）
//await _dbContext.SaveChangesAsync();
//return APIResponseModel<string>.CreateSuccessResponseModel("Delete software successfully");
}
catch (Exception ex)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, ex.Message);
}
}
#endregion
/// <summary>
/// 获取所有软件的基础信息
/// </summary>
/// <param name="reuqestUserId"></param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public async Task<ActionResult<APIResponseModel<List<SoftwareBasicDto>>>> GetSoftwareBaseCollection(long reuqestUserId)
{
try
{
List<Software> softwares = await _dbContext.Software.ToListAsync();
List<SoftwareBasicDto> softwareBasicDtos = [];
for (int i = 0; i < softwares.Count; i++)
{
SoftwareBasicDto softwareBasicDto = new SoftwareBasicDto
{
Id = softwares[i].Id,
SoftwareName = softwares[i].SoftwareName,
SoftwareCode = softwares[i].SoftwareCode,
IsUse = softwares[i].IsUse
};
softwareBasicDtos.Add(softwareBasicDto);
}
return APIResponseModel<List<SoftwareBasicDto>>.CreateSuccessResponseModel(softwareBasicDtos);
}
catch (Exception ex)
{
return APIResponseModel<List<SoftwareBasicDto>>.CreateErrorResponseModel(ResponseCode.SystemError, ex.Message);
}
}
}
}

242
LMS.service/Service/UserService/LoginService.cs
View File

@ -1,11 +1,9 @@

using LMS.Common.RSAKey;
using LMS.DAO;
using LMS.DAO.UserDAO;
using LMS.Repository.DB;
using LMS.Repository.Models.DB;
using LMS.Repository.Models.User;
using LMS.Repository.User;
using LMS.service.Data;
using LMS.Tools.Extensions;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
@ -14,38 +12,47 @@ using Microsoft.IdentityModel.Tokens;
using System.Collections.Concurrent;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Security.Cryptography.Xml;
using System.Text;
using static LMS.Common.Enums.ResponseCodeEnum;
namespace LMS.service.Service.UserService
{
public class LoginService(UserManager<User> userManager, ApplicationDbContext context, SecurityService securityService, UserBasicDao userBasicDao)
public class LoginService
{
private readonly UserManager<User> _userManager = userManager;
private readonly ApplicationDbContext _context = context;
private readonly SecurityService _securityService = securityService;
private readonly UserBasicDao _userBasicDao = userBasicDao;
private readonly UserManager<User> _userManager;
private readonly ApplicationDbContext _context;
private readonly SecurityService _securityService;
public LoginService(UserManager<User> userManager, ApplicationDbContext context, SecurityService securityService)
{
_userManager = userManager;
_context = context;
_securityService = securityService;
}
public class LoginResponse
{
public string Token { get; set; }
public string UserName { get; set; }
public long Id { get; set; }
public string NickName { get; set; }
public string RefreshToken { get; set; }
}
#region 生成JWT
/// <summary>
/// 生成JWT
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public string GenerateJWT(User user, int hours = 6, string deviceInfo = "")
public string GenerateJWT(User user)
{
var claims = new List<Claim>
{
new(ClaimTypes.NameIdentifier, user.Id.ToString()),
new(ClaimTypes.Name, user.UserName),
// 获取角色（目前只有管理员）
new(ClaimTypes.Role, "AdminUser")
};
if (!string.IsNullOrEmpty(deviceInfo))
{
claims.Add(new Claim("DeviceInfo", deviceInfo));
}
var claims = new List<Claim>();
claims.Add(new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()));
claims.Add(new Claim(ClaimTypes.Name, user.UserName));
// 获取角色（目前只有管理员）
claims.Add(new Claim(ClaimTypes.Role, "AdminUser"));
//foreach (string role in roles)
//{
// claims.Add(new Claim(ClaimTypes.Role, role));
@ -60,7 +67,7 @@ namespace LMS.service.Service.UserService
//设置Token的过期时间
DateTime expires = DateTime.Now.AddHours(hours);
DateTime expires = DateTime.Now.AddHours(1);
byte[] secBytes = Encoding.UTF8.GetBytes(key);
var secKey = new SymmetricSecurityKey(secBytes);
@ -74,9 +81,6 @@ namespace LMS.service.Service.UserService
return jwt;
}
#endregion
#region 用户登录，生成刷新token
/// <summary>
/// 用户登录的服务层方法
/// </summary>
@ -168,9 +172,6 @@ namespace LMS.service.Service.UserService
}
}
#endregion
#region 刷新token的方法
/// <summary>
/// 刷新token的方法
/// </summary>
@ -207,8 +208,6 @@ namespace LMS.service.Service.UserService
}
}
#endregion
#region 将用户设置为代理
/// <summary>
/// 将用户设置为代理，要做一系列检查
@ -274,189 +273,6 @@ namespace LMS.service.Service.UserService
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
}
}
#endregion
//TODO 未测试
#region 用户登录的服务层方法，简化版，只是登录，不生成刷新token
/// <summary>
/// 用户登录的服务层方法，简化版，只是登录，不生成刷新token
/// </summary>
/// <param name="model"></param>
/// <param name="_keyStore"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public async Task<ActionResult<APIResponseModel<SimpleLoginResponse>>> SimpleLogin(LoginModel model, string softwareId, string ip, ConcurrentDictionary<string, (string Key, DateTime Expiry)> _keyStore)
{
using var transaction = await _context.Database.BeginTransactionAsync();
try
{
if (string.IsNullOrWhiteSpace(model.DeviceInfo))
{
return APIResponseModel<SimpleLoginResponse>.CreateErrorResponseModel(ResponseCode.ParameterError);
}
if (!_keyStore.TryRemove(model.TokenId, out var keyInfo)) // 没有找到对应的公钥
{
return APIResponseModel<SimpleLoginResponse>.CreateErrorResponseModel(ResponseCode.UserPasswordFail);
}
if (BeijingTimeExtension.GetBeijingTime() > keyInfo.Expiry) // 公钥超时
{
return APIResponseModel<SimpleLoginResponse>.CreateErrorResponseModel(ResponseCode.UserPasswordFail);
}
var rsaKeyId = keyInfo.Key;
var privateKey = _securityService.DecryptWithAES(rsaKeyId);
// 用户密码解密
string decryptedPassword = RsaKeyPairGenerator.Decrypt(privateKey, model.Password);
if (model.UserName == null)
{
throw new ArgumentNullException("UserName");
}
User? user = await _userManager.FindByNameAsync(model.UserName);
if (user == null)
{
return APIResponseModel<SimpleLoginResponse>.CreateErrorResponseModel(ResponseCode.FindUserByNameFail);
}
if (await _userManager.IsLockedOutAsync(user))
{
return APIResponseModel<SimpleLoginResponse>.CreateErrorResponseModel(ResponseCode.UserIsLockedOut);
}
var result = await _userManager.CheckPasswordAsync(user, decryptedPassword);
if (!result)
{
// 失败计数器加1
await _userManager.AccessFailedAsync(user);
return APIResponseModel<SimpleLoginResponse>.CreateErrorResponseModel(ResponseCode.UserPasswordFail);
}
// 密码正确，确认权限
// 检查当前用户是不是有软件控制权限
Software? software = await _context.Software.FirstOrDefaultAsync(s => s.Id == softwareId);
if (software == null)
{
return APIResponseModel<SimpleLoginResponse>.CreateErrorResponseModel(ResponseCode.IdDateNotFound, "没有找到指定的软件信息，请联系管理员");
}
SoftwareControl? softwareControl = await _context.SoftwareControl.FirstOrDefaultAsync(sc => sc.UserId == user.Id && sc.SoftwareId == softwareId);
if (softwareControl == null)
{
return APIResponseModel<SimpleLoginResponse>.CreateErrorResponseModel(ResponseCode.NotPermissionAction, "当前用户没有软件控制权限，请联系管理员");
}
// 不是永久，需要判断是不是到期
if (softwareControl.IsForever == false && (softwareControl.ExpirationTime == null || softwareControl.ExpirationTime <= BeijingTimeExtension.GetBeijingTime()))
{
return APIResponseModel<SimpleLoginResponse>.CreateErrorResponseModel(ResponseCode.NotPermissionAction, "当前用户的软件权限已到期，请联系管理员");
}
UserSoftware? userSoftware = await _context.UserSoftware.FirstOrDefaultAsync(us => us.UserId == user.Id && us.SoftwareId == softwareId);
if (userSoftware == null)
{
// 新建
userSoftware = new UserSoftware()
{
UserId = user.Id,
SoftwareId = softwareId,
MachineId = model.DeviceInfo,
SoftwareControlId = softwareControl.Id
};
await _context.UserSoftware.AddAsync(userSoftware);
}
else
{
// 修改
userSoftware.MachineId = model.DeviceInfo;
_context.Update(userSoftware);
await _context.SaveChangesAsync();
}
// 密码正确，返回token
string jwt = GenerateJWT(user, 24, model.DeviceInfo);
await _context.SaveChangesAsync();
await transaction.CommitAsync();
return APIResponseModel<SimpleLoginResponse>.CreateSuccessResponseModel(new SimpleLoginResponse()
{
Token = jwt,
UserName = user.UserName ?? "",
Id = user.Id,
NickName = user.NickName
});
}
catch (Exception e)
{
await transaction.RollbackAsync();
return APIResponseModel<SimpleLoginResponse>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
}
}
#endregion
#region 管理员重置用户密码
/// <summary>
/// 管理员重置用户密码
/// </summary>
/// <param name="id">被重置的用户ID</param>
/// <param name="newPassword">新密码</param>
/// <param name="requestUserId">请求的用户ID</param>
/// <returns></returns>
public async Task<ActionResult<APIResponseModel<string>>> ResetPassword(long id, ResetPasswordModel newPassword, long requestUserId)
{
using var transaction = await _context.Database.BeginTransactionAsync();
try
{
if (string.IsNullOrWhiteSpace(newPassword.NewPassword))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "新密码必填");
}
// 检查当前用户是不是超级管理员
bool isSuperAdmin = await _userBasicDao.CheckUserIsSuperAdmin(requestUserId);
if (!isSuperAdmin)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
// 查找需要重置密码的用户
var user = await _userManager.FindByIdAsync(id.ToString());
if (user == null)
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.FindUserByIdFail);
}
// 移除用户当前密码（如果用户没有密码，则需要跳过此步骤）
var hasPassword = await _userManager.HasPasswordAsync(user);
if (hasPassword)
{
var removePasswordResult = await _userManager.RemovePasswordAsync(user);
if (!removePasswordResult.Succeeded)
{
var errors = string.Join("; ", removePasswordResult.Errors.Select(e => e.Description));
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, $"移除旧密码失败：{errors}");
}
}
// 为用户设置新密码
var addPasswordResult = await _userManager.AddPasswordAsync(user, newPassword.NewPassword);
if (!addPasswordResult.Succeeded)
{
var errors = string.Join("; ", addPasswordResult.Errors.Select(e => e.Description));
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, $"重置密码失败：{errors}");
}
await transaction.CommitAsync();
return APIResponseModel<string>.CreateSuccessResponseModel("密码已成功重置");
}
catch (Exception e)
{
await transaction.RollbackAsync();
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.SystemError, e.Message);
}
}
#endregion
}
}

23
LMS.service/Service/UserService/UserService.cs
View File

@ -73,8 +73,7 @@ namespace LMS.service.Service.UserService
Options = user.OptionsJson,
AgentPercent = user.AgentPercent,
AffiliateCode = user.AffiliateCode,
ParentId = user.ParentId ?? 0,
Remark = user.Remark ?? string.Empty
ParentId = user.ParentId ?? 0
};
return APIResponseModel<UserDto>.CreateSuccessResponseModel(userDto);
}
@ -88,7 +87,7 @@ namespace LMS.service.Service.UserService
#region 查询用户列表
internal async Task<ActionResult<APIResponseModel<CollectionResponse<UserCollectionDto>>>> QueryUserCollection(int page, int pageSize, string userName, long? userId, string nickName, string phoneNumber, string email, string[] roleNames, string? remark, long? parentId, long reuqertUserId)
internal async Task<ActionResult<APIResponseModel<CollectionResponse<UserCollectionDto>>>> QueryUserCollection(int page, int pageSize, string userName, long? userId, string nickName, string phoneNumber, string email, string[] roleNames, long? parentId, long reuqertUserId)
{
try
{
@ -174,11 +173,6 @@ namespace LMS.service.Service.UserService
query = query.Where(x => !string.IsNullOrWhiteSpace(x.Email) && x.Email.Contains(email));
}
if (!string.IsNullOrWhiteSpace(remark))
{
query = query.Where(x => !string.IsNullOrWhiteSpace(x.Remark) && x.Remark.Contains(remark));
}
if (roleIds.Count > 0)
{
query = query.Where(x => userIds.Contains(x.Id));
@ -205,10 +199,9 @@ namespace LMS.service.Service.UserService
PhoneNumber = x.PhoneNumber ?? string.Empty,
CreatedDate = x.CreatedDate,
LastLoginDate = x.LastLoginDate,
LastLoginIp = x.LastLoginIp ?? string.Empty,
LastLoginDevice = x.LastLoginDevice ?? string.Empty,
ParentId = x.ParentId ?? 0,
Remark = x.Remark ?? string.Empty
LastLoginIp = x.LastLoginIp,
LastLoginDevice = x.LastLoginDevice,
ParentId = x.ParentId ?? 0
}).ToList();
for (int i = 0; i < userCollections.Count; i++)
{
@ -269,12 +262,6 @@ namespace LMS.service.Service.UserService
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.NotPermissionAction);
}
if (string.IsNullOrWhiteSpace(userModel.Remark))
{
return APIResponseModel<string>.CreateErrorResponseModel(ResponseCode.ParameterError, "备注必填");
}
user.Remark = userModel.Remark;
// 开始修改用户信息
if (userModel.AgentPercent != null)
{

281
SQL/Structure/Structure.sql
View File

@ -1,281 +0,0 @@
/*
Navicat Premium Dump SQL
Source Server : 亿速云（国内）
Source Server Type : MySQL
Source Server Version : 80018 (8.0.18)
Source Host : yisurds-66dc0b453c05d4.rds.ysydb1.com:14080
Source Schema : LMS_TEST
Target Server Type : MySQL
Target Server Version : 80018 (8.0.18)
File Encoding : 65001
Date: 13/10/2024 21:05:08
*/
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for ApiEndpoints
-- ----------------------------
CREATE TABLE IF NOT EXISTS `ApiEndpoints` (
`Id` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
`HttpMethod` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT 'Http请求方式',
`Path` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT 'Http请求地址',
`CreateTime` datetime NOT NULL COMMENT '创建时间',
`RequiredPermissionIds` json NOT NULL COMMENT '需要的权限ID',
`CreatedId` bigint(20) NOT NULL COMMENT '创建者ID',
`UpdatedId` bigint(20) NOT NULL COMMENT '更新者ID',
PRIMARY KEY (`Id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Table structure for AspNetRoleClaims
-- ----------------------------
CREATE TABLE IF NOT EXISTS `AspNetRoleClaims` (
`Id` int(11) NOT NULL AUTO_INCREMENT,
`RoleId` bigint(20) NOT NULL,
`ClaimType` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL,
`ClaimValue` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL,
PRIMARY KEY (`Id`) USING BTREE,
INDEX `IX_AspNetRoleClaims_RoleId`(`RoleId` ASC) USING BTREE,
CONSTRAINT `FK_AspNetRoleClaims_AspNetRoles_RoleId` FOREIGN KEY (`RoleId`) REFERENCES `AspNetRoles` (`Id`) ON DELETE CASCADE ON UPDATE RESTRICT
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Table structure for AspNetRoles
-- ----------------------------
CREATE TABLE IF NOT EXISTS `AspNetRoles` (
`Id` bigint(20) NOT NULL AUTO_INCREMENT,
`Name` varchar(256) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
`NormalizedName` varchar(256) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
`ConcurrencyStamp` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL,
`CreatedUserId` bigint(20) NOT NULL,
`UpdatedUserId` bigint(20) NOT NULL,
`CreatedTime` datetime NOT NULL,
`UpdatedTime` datetime NOT NULL,
`Remark` text CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL,
PRIMARY KEY (`Id`) USING BTREE,
UNIQUE INDEX `RoleNameIndex`(`NormalizedName` ASC) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Table structure for AspNetUserClaims
-- ----------------------------
CREATE TABLE IF NOT EXISTS `AspNetUserClaims` (
`Id` int(11) NOT NULL AUTO_INCREMENT,
`UserId` bigint(20) NOT NULL,
`ClaimType` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL,
`ClaimValue` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL,
PRIMARY KEY (`Id`) USING BTREE,
INDEX `IX_AspNetUserClaims_UserId`(`UserId` ASC) USING BTREE,
CONSTRAINT `FK_AspNetUserClaims_AspNetUsers_UserId` FOREIGN KEY (`UserId`) REFERENCES `AspNetUsers` (`Id`) ON DELETE CASCADE ON UPDATE RESTRICT
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Table structure for AspNetUserLogins
-- ----------------------------
CREATE TABLE IF NOT EXISTS `AspNetUserLogins` (
`LoginProvider` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
`ProviderKey` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
`ProviderDisplayName` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL,
`UserId` bigint(20) NOT NULL,
PRIMARY KEY (`LoginProvider`, `ProviderKey`) USING BTREE,
INDEX `IX_AspNetUserLogins_UserId`(`UserId` ASC) USING BTREE,
CONSTRAINT `FK_AspNetUserLogins_AspNetUsers_UserId` FOREIGN KEY (`UserId`) REFERENCES `AspNetUsers` (`Id`) ON DELETE CASCADE ON UPDATE RESTRICT
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Table structure for AspNetUserRoles
-- ----------------------------
CREATE TABLE IF NOT EXISTS `AspNetUserRoles` (
`UserId` bigint(20) NOT NULL,
`RoleId` bigint(20) NOT NULL,
PRIMARY KEY (`UserId`, `RoleId`) USING BTREE,
INDEX `IX_AspNetUserRoles_RoleId`(`RoleId` ASC) USING BTREE,
CONSTRAINT `FK_AspNetUserRoles_AspNetRoles_RoleId` FOREIGN KEY (`RoleId`) REFERENCES `AspNetRoles` (`Id`) ON DELETE CASCADE ON UPDATE RESTRICT,
CONSTRAINT `FK_AspNetUserRoles_AspNetUsers_UserId` FOREIGN KEY (`UserId`) REFERENCES `AspNetUsers` (`Id`) ON DELETE CASCADE ON UPDATE RESTRICT
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Table structure for AspNetUserTokens
-- ----------------------------
CREATE TABLE IF NOT EXISTS `AspNetUserTokens` (
`UserId` bigint(20) NOT NULL,
`LoginProvider` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
`Name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
`Value` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL,
PRIMARY KEY (`UserId`, `LoginProvider`, `Name`) USING BTREE,
CONSTRAINT `FK_AspNetUserTokens_AspNetUsers_UserId` FOREIGN KEY (`UserId`) REFERENCES `AspNetUsers` (`Id`) ON DELETE CASCADE ON UPDATE RESTRICT
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Table structure for AspNetUsers
-- ----------------------------
CREATE TABLE IF NOT EXISTS `AspNetUsers` (
`Id` bigint(20) NOT NULL AUTO_INCREMENT,
`NickName` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
`CreatedDate` datetime NOT NULL,
`UpdatedDate` datetime NOT NULL,
`LastLoginDate` datetime NOT NULL,
`LastLoginIp` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
`LastLoginDevice` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
`UserName` varchar(256) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
`NormalizedUserName` varchar(256) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
`Email` varchar(256) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
`NormalizedEmail` varchar(256) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
`EmailConfirmed` tinyint(1) NOT NULL,
`PasswordHash` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL,
`SecurityStamp` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL,
`ConcurrencyStamp` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL,
`PhoneNumber` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL,
`PhoneNumberConfirmed` tinyint(1) NOT NULL,
`TwoFactorEnabled` tinyint(1) NOT NULL,
`LockoutEnd` datetime(6) NULL DEFAULT NULL,
`LockoutEnabled` tinyint(1) NULL DEFAULT NULL,
`AccessFailedCount` int(11) NULL DEFAULT NULL,
`FreeCount` bigint(20) NOT NULL DEFAULT 5 COMMENT '免费修改机器码的次数',
`AgentPercent` double NOT NULL DEFAULT 0.5 COMMENT '代理分成的百分比',
`AllDeviceCount` bigint(10) NOT NULL DEFAULT 1 COMMENT '可用的机器码数量（买了几次）',
`Options` json NULL,
`ParentId` bigint(20) NULL DEFAULT NULL,
`AffiliateCode` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
PRIMARY KEY (`Id`) USING BTREE,
UNIQUE INDEX `UserNameIndex`(`NormalizedUserName` ASC) USING BTREE,
INDEX `EmailIndex`(`NormalizedEmail` ASC) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Table structure for Machine
-- ----------------------------
CREATE TABLE IF NOT EXISTS `Machine` (
`Id` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT 'ID',
`MachineId` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '用户电脑的机器码',
`CreateTime` datetime NOT NULL COMMENT '创建时间',
`UpdateTime` datetime NOT NULL COMMENT '更新时间',
`DeactivationTime` datetime NULL DEFAULT NULL COMMENT '停用时间',
`Status` int(11) NOT NULL COMMENT '状态 （激活/冻结）',
`CreateId` bigint(20) NOT NULL COMMENT '创建者ID',
`UpdateId` bigint(20) NOT NULL COMMENT '更新者ID',
`UseStatus` int(11) NOT NULL COMMENT '使用状态（使用/永久）',
`Remark` text CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL COMMENT '备注',
`UserID` bigint(20) NOT NULL COMMENT '机器码所属ID',
PRIMARY KEY (`Id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Table structure for Permission
-- ----------------------------
CREATE TABLE IF NOT EXISTS `Permission` (
`Id` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '权限的ID',
`UserId` bigint(20) NULL DEFAULT NULL COMMENT '用户的ID',
`MachineId` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '机器码的ID（是ID，不是机器码）',
`RoleId` bigint(20) NULL DEFAULT NULL COMMENT '角色ID',
`PermissionTypeIds` json NULL COMMENT '权限类型的ID（子权限）',
`PermissionCode` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '权限对应的Code',
`CreateUserId` bigint(20) NOT NULL COMMENT '创建人ID',
`UpdateUserId` bigint(20) NOT NULL COMMENT '更新人ID',
`CreateTime` datetime NOT NULL COMMENT '创建时间',
`UpdateTime` datetime NOT NULL COMMENT '更新时间',
`Remark` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL COMMENT '备注',
`Type` int(11) NOT NULL COMMENT '对应的类型\r\n对应 User，Role，Machine\r\n设置对应的type 检查对应的属性数据是不是存在\r\n',
PRIMARY KEY (`Id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Table structure for PermissionType
-- ----------------------------
CREATE TABLE IF NOT EXISTS `PermissionType` (
`Id` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '权限ID',
`Name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '权限的名字',
`Code` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '表示权限的代码',
`Type` int(11) NOT NULL COMMENT '权限的分类（user和machine，role，prompt,permission，自定义）',
`CreateUserId` bigint(20) NOT NULL COMMENT '创建者ID',
`CreateTime` datetime NOT NULL COMMENT '创建时间',
`UpdateUserId` bigint(20) NOT NULL COMMENT '更新者ID',
`UpdateTime` datetime NOT NULL COMMENT '更新权限类型的时间',
`Remark` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL COMMENT '权限的描述',
PRIMARY KEY (`Id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Table structure for Prompt
-- ----------------------------
CREATE TABLE IF NOT EXISTS `Prompt` (
`Id` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT 'ID',
`Name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '提示词预设的名称',
`PromptTypeId` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '提示词的类型ID',
`PromptTypeCode` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '提示词的类型编码',
`PromptString` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '提示词预设字符串',
`Version` int(11) NOT NULL COMMENT '当前版本',
`Status` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '状态',
`Description` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '提示词的描述',
`CreateUserId` bigint(20) NOT NULL COMMENT '创建者',
`CreateTime` datetime NOT NULL COMMENT '创建时间',
`UpdateUserId` bigint(20) NOT NULL COMMENT '更新者',
`UpdateTime` datetime NOT NULL COMMENT '更新时间',
`Remark` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '备注',
PRIMARY KEY (`Id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '存放提示词的表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- Table structure for PromptType
-- ----------------------------
CREATE TABLE IF NOT EXISTS `PromptType` (
`Id` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT 'ID',
`Code` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '提示词类型编码',
`Name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '提示词类型名称',
`Remark` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '提示词类型描述',
`Status` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '提示词类型状态',
`IsDeleted` tinyint(1) NOT NULL COMMENT '是否删除',
`CreateUserId` bigint(20) NOT NULL COMMENT '创建用户ID',
`CreateTime` datetime NOT NULL COMMENT '创建时间',
`UpdateUserId` bigint(20) NOT NULL COMMENT '更新者ID',
`UpdateTime` datetime NOT NULL COMMENT '更新时间',
PRIMARY KEY (`Id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '提示词类型的库' ROW_FORMAT = Dynamic;
-- ----------------------------
-- Table structure for RefreshTokens
-- ----------------------------
CREATE TABLE IF NOT EXISTS `RefreshTokens` (
`Id` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT 'ID ',
`UserId` bigint(20) NOT NULL COMMENT '用户ID\r\n',
`Token` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '刷新token',
`Expiration` datetime NOT NULL COMMENT '到期时间',
`Revoked` bit(1) NOT NULL COMMENT '是不是失效',
`CreatedTime` datetime NOT NULL COMMENT '创建时间',
`LastCheckIp` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '上次校验IP',
`DeviceInfo` text CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '设备信息，浏览器信息等',
PRIMARY KEY (`Id` DESC) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Table structure for RsaKeys
-- ----------------------------
CREATE TABLE IF NOT EXISTS `RsaKeys` (
`Id` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT 'ID 主键',
`PublicKey` text CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '公钥',
`EncryptedPrivateKey` text CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '加密后的私钥',
`EncryptionKey` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '加密私钥的随机字符串',
`EncryptionIV` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '加密私钥的IV',
`KeyVersion` int(11) NOT NULL COMMENT 'Key的版本',
`CreatedTime` datetime NOT NULL COMMENT '创建时间',
`LastUsed` datetime NULL DEFAULT NULL COMMENT '上次使用的时间',
`UseCount` int(11) NOT NULL DEFAULT 0 COMMENT '使用的次数',
`ExpirationTime` datetime NOT NULL COMMENT '到期时间',
PRIMARY KEY (`Id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = 'RSA密钥存储表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- Table structure for __EFMigrationsHistory
-- ----------------------------
CREATE TABLE IF NOT EXISTS `__EFMigrationsHistory` (
`MigrationId` varchar(150) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
`ProductVersion` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
PRIMARY KEY (`MigrationId`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
SET FOREIGN_KEY_CHECKS = 1;

30
SQL/v0.0.1/Options.sql
View File

@ -1,30 +0,0 @@
/*
Navicat Premium Dump SQL
Source Server : 亿速云（国内）
Source Server Type : MySQL
Source Server Version : 80018 (8.0.18)
Source Host : yisurds-66dc0b453c05d4.rds.ysydb1.com:14080
Source Schema : LMS_TEST
Target Server Type : MySQL
Target Server Version : 80018 (8.0.18)
File Encoding : 65001
Date: 17/10/2024 21:42:59
*/
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for Options
-- ----------------------------
CREATE TABLE IF NOT EXISTS `Options` (
`Key` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
`Value` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL,
`Type` int(11) NOT NULL,
PRIMARY KEY (`Key`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
SET FOREIGN_KEY_CHECKS = 1;

37
SQL/v1.0.2/Software.sql
View File

@ -1,37 +0,0 @@
/*
Navicat Premium Dump SQL
Source Server : 亿速云（国内）
Source Server Type : MySQL
Source Server Version : 80018 (8.0.18)
Source Host : yisurds-66dc0b453c05d4.rds.ysydb1.com:14080
Source Schema : LMS_TEST
Target Server Type : MySQL
Target Server Version : 80018 (8.0.18)
File Encoding : 65001
Date: 27/12/2024 21:36:00
*/
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for Software
-- ----------------------------
DROP TABLE IF EXISTS `Software`;
CREATE TABLE `Software` (
`Id` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT 'ID',
`SoftwareName` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '软件名称',
`SoftwareCode` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '软件代码',
`CreatedUserId` bigint(20) NULL DEFAULT NULL COMMENT '创建用户ID',
`UpdatedUserId` bigint(20) NULL DEFAULT NULL COMMENT '更新用户ID',
`CreatedTime` datetime NULL DEFAULT NULL COMMENT '创建时间',
`UpdatedTime` datetime NULL DEFAULT NULL COMMENT '更新时间',
`Remark` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '备注',
`IsUse` tinyint(1) NULL DEFAULT NULL COMMENT '是否启用',
PRIMARY KEY (`Id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
SET FOREIGN_KEY_CHECKS = 1;

38
SQL/v1.0.2/SoftwareControl.sql
View File

@ -1,38 +0,0 @@
/*
Navicat Premium Dump SQL
Source Server : 亿速云（国内）
Source Server Type : MySQL
Source Server Version : 80018 (8.0.18)
Source Host : yisurds-66dc0b453c05d4.rds.ysydb1.com:14080
Source Schema : LMS_TEST
Target Server Type : MySQL
Target Server Version : 80018 (8.0.18)
File Encoding : 65001
Date: 27/12/2024 21:36:10
*/
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for SoftwareControl
-- ----------------------------
DROP TABLE IF EXISTS `SoftwareControl`;
CREATE TABLE `SoftwareControl` (
`Id` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT 'ID',
`UserId` bigint(20) NOT NULL COMMENT '用户ID',
`SoftwareId` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '软件ID',
`CreatedUserId` bigint(20) NULL DEFAULT NULL COMMENT '创建用户ID',
`CreatedTime` datetime NULL DEFAULT NULL COMMENT '创建时间',
`UpdatedUserId` bigint(20) NULL DEFAULT NULL COMMENT '更新用户ID',
`UpdatedTime` datetime NULL DEFAULT NULL COMMENT '更新时间',
`Remark` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '备注',
`ExpirationTime` datetime NULL DEFAULT NULL COMMENT '到期时间',
`IsForever` tinyint(1) NULL DEFAULT NULL COMMENT '是否永久',
PRIMARY KEY (`Id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
SET FOREIGN_KEY_CHECKS = 1;

32
SQL/v1.0.2/UserSoftware.sql
View File

@ -1,32 +0,0 @@
/*
Navicat Premium Dump SQL
Source Server : 亿速云（国内）
Source Server Type : MySQL
Source Server Version : 80018 (8.0.18)
Source Host : yisurds-66dc0b453c05d4.rds.ysydb1.com:14080
Source Schema : LMS_TEST
Target Server Type : MySQL
Target Server Version : 80018 (8.0.18)
File Encoding : 65001
Date: 27/12/2024 21:36:16
*/
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for UserSoftware
-- ----------------------------
DROP TABLE IF EXISTS `UserSoftware`;
CREATE TABLE `UserSoftware` (
`UserId` bigint(20) NOT NULL COMMENT '用户ID',
`SoftwareId` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '软件ID',
`MachineId` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '机器码ID',
`SoftwareControlId` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '软件控制ID',
PRIMARY KEY (`UserId`, `SoftwareId`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
SET FOREIGN_KEY_CHECKS = 1;