diff --git a/Entities/Contracts/ClassTeacher.cs b/Entities/Contracts/ClassTeacher.cs
index 3434624..5b1e5ab 100644
--- a/Entities/Contracts/ClassTeacher.cs
+++ b/Entities/Contracts/ClassTeacher.cs
@@ -14,11 +14,13 @@ namespace Entities.Contracts
 		[Key] 
 		[Column("class_id")]
 		public Guid ClassId { get; set; }
+		[ForeignKey(nameof(ClassId))]
 		public Class Class { get; set; }
 
 		[Key] 
 		[Column("teacher_id")] 
 		public Guid TeacherId { get; set; }
+		[ForeignKey(nameof(TeacherId))]
 		public User Teacher { get; set; }
 
 		[Column("subject_taught")]
diff --git a/Entities/Contracts/User.cs b/Entities/Contracts/User.cs
index 52352db..4054383 100644
--- a/Entities/Contracts/User.cs
+++ b/Entities/Contracts/User.cs
@@ -21,7 +21,9 @@ namespace Entities.Contracts
 		[Column("deleted")]
 		public bool IsDeleted { get; set; }
 
+		[InverseProperty(nameof(ClassTeacher.Teacher))]
 		public ICollection<ClassTeacher> TaughtClassesLink { get; set; }
+		[InverseProperty(nameof(ClassStudent.Student))]
 		public ICollection<ClassStudent> EnrolledClassesLink { get; set; }
 
 		public ICollection<Question> CreatedQuestions { get; set; }
diff --git a/TechHelper.Client/Exam/ExamStruct.cs b/TechHelper.Client/Exam/ExamStruct.cs
index 7ecdd33..9e36b90 100644
--- a/TechHelper.Client/Exam/ExamStruct.cs
+++ b/TechHelper.Client/Exam/ExamStruct.cs
@@ -24,9 +24,9 @@ namespace TechHelper.Client.Exam
 
 	public class QuestionAnswerStatus
 	{
-		public string QuestionSequence { get; set; } = string.Empty; // 题目序号，例如 "1.1"
-		public string QuestionText { get; set; } = string.Empty;     // 题目文本
-		public float QuestionScore { get; set; }                    // 题目分值
+		public string QuestionSequence { get; set; } = string.Empty;	// 题目序号，例如 "1.1"
+		public string QuestionText { get; set; } = string.Empty;		// 题目文本
+		public float QuestionScore { get; set; }						// 题目分值
 		public Dictionary<Guid, bool> StudentCorrectStatus { get; set; } = new Dictionary<Guid, bool>();
 		// Key: Student.Id, Value: true 表示正确，false 表示错误
 	}
diff --git a/TechHelper.Client/Exam/QuestionSimple.cs b/TechHelper.Client/Exam/QuestionSimple.cs
deleted file mode 100644
index da098b6..0000000
--- a/TechHelper.Client/Exam/QuestionSimple.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-using System.Xml.Serialization;
-
-namespace TechHelper.Client.Exam.QuestionSimple
-{
-
-	[XmlRoot("QG")]
-	public class QuestionGroup
-	{
-		[XmlElement("T")]
-		public string Title { get; set; }
-		[XmlElement("QR")]
-		public string QuestionReference { get; set; } = "";
-		[XmlArray("SQs")]
-		[XmlArrayItem("SQ")]
-		public List<SubQuestion> SubQuestions { get; set; } = new List<SubQuestion>();
-		[XmlArray("SQGs")]
-		[XmlArrayItem("QG")]
-		public List<QuestionGroup> SubQuestionGroups { get; set; } = new List<QuestionGroup>();
-	}
-	public class SubQuestion
-	{
-		[XmlElement("T")]
-		public string Stem { get; set; }
-		[XmlArray("Os")]
-		[XmlArrayItem("O")]
-		public List<Option> Options { get; set; } = new List<Option>();
-		[XmlElement("SA")]
-		public string SampleAnswer { get; set; } = "";
-	}
-	public class Option
-	{
-		[XmlAttribute("V")]
-		public string Value { get; set; }
-	}
-
-}
diff --git a/TechHelper.Client/HttpInterceptor/HttpInterceptorHandlerService.cs b/TechHelper.Client/HttpInterceptor/HttpInterceptorHandlerService.cs
index 2dacf93..8ebd7ad 100644
--- a/TechHelper.Client/HttpInterceptor/HttpInterceptorHandlerService.cs
+++ b/TechHelper.Client/HttpInterceptor/HttpInterceptorHandlerService.cs
@@ -1,19 +1,19 @@
-using Microsoft.AspNetCore.Components; 
+using Microsoft.AspNetCore.Components;
 using System.Net;
-using System.Net.Http.Headers; 
-using TechHelper.Client.HttpRepository; 
+using System.Net.Http.Headers;
+using TechHelper.Client.HttpRepository;
 
 
 namespace BlazorProducts.Client.HttpInterceptor
 {
 	public class HttpInterceptorHandlerService : DelegatingHandler
 	{
-		private readonly NavigationManager _navManager; 
-		private readonly RefreshTokenService2 _refreshTokenService; 
+		private readonly NavigationManager _navManager;
+		private readonly IRefreshTokenService _refreshTokenService;
 
 		public HttpInterceptorHandlerService(
 			NavigationManager navManager,
-			RefreshTokenService2 refreshTokenService)
+			IRefreshTokenService refreshTokenService)
 		{
 			_navManager = navManager;
 			_refreshTokenService = refreshTokenService;
@@ -25,15 +25,14 @@ namespace BlazorProducts.Client.HttpInterceptor
 
 			if (absolutePath != null && !absolutePath.Contains("token") && !absolutePath.Contains("account"))
 			{
-				var token = await _refreshTokenService.TryRefreshToken(); 
+				var token = await _refreshTokenService.TryRefreshToken();
 				if (!string.IsNullOrEmpty(token))
 				{
-					
 					request.Headers.Authorization = new AuthenticationHeaderValue("bearer", token);
 				}
 			}
 
-			
+
 			var response = await base.SendAsync(request, cancellationToken);
 
 			await HandleResponse(response);
@@ -45,17 +44,17 @@ namespace BlazorProducts.Client.HttpInterceptor
 		{
 			if (response is null)
 			{
-				
+
 				_navManager.NavigateTo("/error");
-				throw new HttpResponseException("服务器不可用。"); 
+				throw new HttpResponseException("服务器不可用。");
 			}
 
-			
+
 			if (!response.IsSuccessStatusCode)
 			{
-				
+
 				var errorContent = await response.Content.ReadAsStringAsync();
-				Console.WriteLine($"HTTP 错误: {response.StatusCode}. 详情: {errorContent}"); 
+				Console.WriteLine($"HTTP 错误: {response.StatusCode}. 详情: {errorContent}");
 
 				switch (response.StatusCode)
 				{
@@ -67,8 +66,15 @@ namespace BlazorProducts.Client.HttpInterceptor
 						// 400 Bad Request error. Often, you don't navigate for this; you display validation errors on the UI.
 						break;
 					case HttpStatusCode.Unauthorized:
-						// 401 Unauthorized error. Navigate to an unauthorized page or login page.
-						_navManager.NavigateTo("/unauthorized"); // Or: _navManager.NavigateTo("/authentication/login");
+						var token = await _refreshTokenService.TryRefreshToken();
+						if (!string.IsNullOrEmpty(token))
+						{
+							_navManager.NavigateTo(_navManager.Uri, forceLoad: true);
+						}
+						else
+						{
+							_navManager.NavigateTo("/unauthorized");
+						}
 						break;
 					default:
 						// For all other errors, navigate to a general error page.
diff --git a/TechHelper.Client/HttpRepository/AuthenticationClientService.cs b/TechHelper.Client/HttpRepository/AuthenticationClientService.cs
index 02167d5..5dc1436 100644
--- a/TechHelper.Client/HttpRepository/AuthenticationClientService.cs
+++ b/TechHelper.Client/HttpRepository/AuthenticationClientService.cs
@@ -20,13 +20,12 @@ namespace TechHelper.Client.HttpRepository
 		private readonly ILocalStorageService _localStorageService;
 		private readonly NavigationManager _navigationManager;
 
-		// 构造函数现在直接接收 HttpClient
-		public AuthenticationClientService(HttpClient client, // <-- 修正点：直接注入 HttpClient
+		public AuthenticationClientService(HttpClient client, 
 			AuthenticationStateProvider authenticationStateProvider,
 			ILocalStorageService localStorageService,
 			NavigationManager navigationManager)
 		{
-			_client = client; // <-- 修正点：直接赋值
+			_client = client; 
 			_localStorageService = localStorageService;
 			_stateProvider = authenticationStateProvider;
 			_navigationManager = navigationManager;
@@ -34,8 +33,6 @@ namespace TechHelper.Client.HttpRepository
 
 		public async Task<AuthResponseDto> LoginAsync(UserForAuthenticationDto userForAuthenticationDto)
 		{
-			// 移除 using (_client = _clientFactory.CreateClient("Default"))
-			// _client 已经是注入的实例，直接使用它
 			var reponse = await _client.PostAsJsonAsync("account/login",
 				userForAuthenticationDto);
 
@@ -71,7 +68,6 @@ namespace TechHelper.Client.HttpRepository
 
 		public async Task<string> RefreshTokenAsync()
 		{
-			// 移除 using (_client = _clientFactory.CreateClient("Default"))
 			var token = _localStorageService.GetItem<string>("authToken");
 			var refreshToken = _localStorageService.GetItem<string>("refreshToken");
 
@@ -167,6 +163,9 @@ namespace TechHelper.Client.HttpRepository
 			((AuthStateProvider)_stateProvider).NotifyUserAuthentication(
 				result.Token);
 
+
+			
+
 			_client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue(
 				"bearer", result.Token);
 
diff --git a/TechHelper.Client/HttpRepository/RefreshTokenService.cs b/TechHelper.Client/HttpRepository/RefreshTokenService.cs
index d11fcdc..31029ab 100644
--- a/TechHelper.Client/HttpRepository/RefreshTokenService.cs
+++ b/TechHelper.Client/HttpRepository/RefreshTokenService.cs
@@ -24,16 +24,15 @@ namespace TechHelper.Client.HttpRepository
 			var authState = await _authenticationStateProvider.Value.GetAuthenticationStateAsync();
 			var user = authState.User;
 
-			// 如果 user 或 claims 为空，表示用户未认证，直接返回空字符串
 			if (user?.Identity == null || !user.Identity.IsAuthenticated)
 			{
 				return string.Empty;
 			}
 
-			var expClaim = user.FindFirst(c => c.Type.Equals("exp"))?.Value; // 使用 ?. 防止空引用
+			var expClaim = user.FindFirst(c => c.Type.Equals("exp"))?.Value; 
 			if (string.IsNullOrEmpty(expClaim))
 			{
-				return string.Empty; // 没有过期时间声明，也直接返回
+				return string.Empty; 
 			}
 
 			var expTime = DateTimeOffset.FromUnixTimeSeconds(
@@ -41,9 +40,11 @@ namespace TechHelper.Client.HttpRepository
 
 			var diff = expTime - DateTime.UtcNow;
 
-			// 只有当令牌即将过期时才尝试刷新
+
+			var n = DateTime.UtcNow;
+
 			if (diff.TotalMinutes <= 2)
-				return await _authenticationClientService.Value.RefreshTokenAsync(); // 访问 .Value 来调用方法
+				return await _authenticationClientService.Value.RefreshTokenAsync(); 
 
 			return string.Empty;
 		}
diff --git a/TechHelper.Client/HttpRepository/RefreshTokenService2.cs b/TechHelper.Client/HttpRepository/RefreshTokenService2.cs
deleted file mode 100644
index a17f8cf..0000000
--- a/TechHelper.Client/HttpRepository/RefreshTokenService2.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-using Microsoft.AspNetCore.Components.Authorization;
-
-namespace TechHelper.Client.HttpRepository
-{
-	public class RefreshTokenService2
-	{
-		private readonly Lazy<AuthenticationStateProvider> _authenticationStateProvider;
-		private readonly Lazy<IAuthenticationClientService> _authenticationClientService;
-
-		public RefreshTokenService2(IServiceProvider serviceProvider)
-		{
-			_authenticationStateProvider = new Lazy<AuthenticationStateProvider>(
-				() => serviceProvider.GetRequiredService<AuthenticationStateProvider>());
-
-			_authenticationClientService = new Lazy<IAuthenticationClientService>(
-				() => serviceProvider.GetRequiredService<IAuthenticationClientService>());
-		}
-
-		public async Task<string> TryRefreshToken()
-		{
-			var authState = await _authenticationStateProvider.Value.GetAuthenticationStateAsync();
-			var user = authState.User;
-
-			if (user?.Identity == null || !user.Identity.IsAuthenticated)
-			{
-				return string.Empty;
-			}
-
-			var expClaim = user.FindFirst(c => c.Type.Equals("exp"))?.Value; 
-			if (string.IsNullOrEmpty(expClaim))
-			{
-				return string.Empty; 
-			}
-
-			var expTime = DateTimeOffset.FromUnixTimeSeconds(
-				Convert.ToInt64(expClaim));
-
-			var diff = expTime - DateTime.UtcNow;
-
-			if (diff.TotalMinutes <= 2)
-				return await _authenticationClientService.Value.RefreshTokenAsync(); 
-
-			return string.Empty;
-		}
-	}
-}
diff --git a/TechHelper.Client/Pages/Exam/AssignmentDetailView.razor b/TechHelper.Client/Pages/Exam/AssignmentDetailView.razor
new file mode 100644
index 0000000..7c4b75f
--- /dev/null
+++ b/TechHelper.Client/Pages/Exam/AssignmentDetailView.razor
@@ -0,0 +1,10 @@
+<MudText> QuestionNum </MudText>
+<MudText> QuestionTypeDis </MudText>
+<MudText> ErrorQuestionTypeDis </MudText>
+<MudText> ErrorLessonDis </MudText>
+<MudText> ErrorIndexDis </MudText>
+<MudText> ErrorNum </MudText>
+
+@code {
+
+}
diff --git a/TechHelper.Client/Pages/Exam/QuestionDetailView.razor b/TechHelper.Client/Pages/Exam/QuestionDetailView.razor
new file mode 100644
index 0000000..2211b2f
--- /dev/null
+++ b/TechHelper.Client/Pages/Exam/QuestionDetailView.razor
@@ -0,0 +1,9 @@
+<MudText> Title </MudText>
+<MudText> Error Person Num </MudText>
+<MudText> List Error Person </MudText>
+<MudText> Lesson </MudText>
+<MudText> Keypoint </MudText>
+<MudText> Answer </MudText>
+@code {
+
+}
diff --git a/TechHelper.Client/Pages/Manage/Class.razor.cs b/TechHelper.Client/Pages/Manage/Class.razor.cs
index 9fd7a56..da7154f 100644
--- a/TechHelper.Client/Pages/Manage/Class.razor.cs
+++ b/TechHelper.Client/Pages/Manage/Class.razor.cs
@@ -4,6 +4,7 @@ using Microsoft.AspNetCore.Components.Authorization;
 using MudBlazor;
 using System.Collections.Frozen;
 using System.ComponentModel.DataAnnotations;
+using System.Security.Claims;
 using TechHelper.Client.HttpRepository;
 using TechHelper.Client.Services;
 
diff --git a/TechHelper.Client/Program.cs b/TechHelper.Client/Program.cs
index f2611b0..e6b8e82 100644
--- a/TechHelper.Client/Program.cs
+++ b/TechHelper.Client/Program.cs
@@ -44,7 +44,6 @@ builder.Services.AddScoped<IRefreshTokenService, RefreshTokenService>();
 builder.Services.AddScoped<IClassServices, ClasssServices>();
 builder.Services.AddScoped<IEmailSender, QEmailSender>();
 builder.Services.AddScoped<HttpInterceptorHandlerService>();
-builder.Services.AddScoped<RefreshTokenService2>();
 builder.Services.AddScoped<IAIService, AiService>();
 builder.Services.AddHttpClient("WebApiClient", client =>
 {
diff --git a/TechHelper.Client/Services/ClasssServices.cs b/TechHelper.Client/Services/ClasssServices.cs
index 63fd362..5a93d29 100644
--- a/TechHelper.Client/Services/ClasssServices.cs
+++ b/TechHelper.Client/Services/ClasssServices.cs
@@ -1,15 +1,18 @@
 using Entities.DTO;
-using System.Net.Http.Json; 
+using System.Net.Http.Json;
+using TechHelper.Client.HttpRepository;
 
 namespace TechHelper.Client.Services
 {
 	public class ClasssServices : IClassServices
 	{
 		private readonly HttpClient _client;
+		private readonly IAuthenticationClientService _authenticationClientService;
 
-		public ClasssServices(HttpClient client)
+		public ClasssServices(HttpClient client, IAuthenticationClientService authenticationClientService)
 		{
 			_client = client;
+			_authenticationClientService = authenticationClientService;
 		}
 
 		public Task<ResponseDto> CreateClass(UserRegistrationToClassDto userClass)
@@ -25,6 +28,8 @@ namespace TechHelper.Client.Services
 					userRegistrationToClassDto);
 				var data = await result.Content.ReadAsStringAsync();
 
+				await _authenticationClientService.RefreshTokenAsync();
+
 				return new ResponseDto
 				{
 					IsSuccessfulRegistration = result.IsSuccessStatusCode,
diff --git a/TechHelper.Client/Services/ExamService.cs b/TechHelper.Client/Services/ExamService.cs
index fb6ef57..4c0812b 100644
--- a/TechHelper.Client/Services/ExamService.cs
+++ b/TechHelper.Client/Services/ExamService.cs
@@ -9,13 +9,13 @@ namespace TechHelper.Client.Services
 {
 	public class ExamService : IExamService
 	{
-		private readonly IAIService _aIService; // 遵循命名规范，字段前加下划线
-		private readonly HttpClient _client; // 直接注入 HttpClient
+		private readonly IAIService _aIService; 
+		private readonly HttpClient _client; 
 
-		public ExamService(IAIService aIService, HttpClient client) // 修正点：直接注入 HttpClient
+		public ExamService(IAIService aIService, HttpClient client) 
 		{
 			_aIService = aIService;
-			_client = client; // 赋值注入的 HttpClient 实例
+			_client = client; 
 		}
 
 		public ApiResponse ConvertToXML<T>(string xmlContent)
diff --git a/TechHelper.Server/Context/Configuration/ClassTeacherConfiguration.cs b/TechHelper.Server/Context/Configuration/ClassTeacherConfiguration.cs
index 786a8d4..ffed8b3 100644
--- a/TechHelper.Server/Context/Configuration/ClassTeacherConfiguration.cs
+++ b/TechHelper.Server/Context/Configuration/ClassTeacherConfiguration.cs
@@ -53,7 +53,7 @@ namespace TechHelper.Context.Configuration
 			builder.HasOne(ct => ct.Teacher)          // 当前 ClassTeacher 链接到一个 User (老师)
 				.WithMany(u => u.TaughtClassesLink)   // 那个 User (老师) 可以有多个 ClassTeacher 记录 (为所教授的班级)
 				.HasForeignKey(ct => ct.TeacherId)    // 外键是 ClassTeacher.TeacherId
-				.OnDelete(DeleteBehavior.Restrict);   // 当 User (老师) 被删除时，如果还有相关的 ClassTeacher 记录，则会阻止删除。
+				.OnDelete(DeleteBehavior.Cascade);   // 当 User (老师) 被删除时，如果还有相关的 ClassTeacher 记录，则会阻止删除。
 													  // 这通常是防止数据丢失的更安全选择。如果你希望老师被删除时，其所有任教关系也一并删除，可改为 DeleteBehavior.Cascade。
 		}
 	}
diff --git a/TechHelper.Server/Migrations/20250625032845_up.Designer.cs b/TechHelper.Server/Migrations/20250625032845_up.Designer.cs
new file mode 100644
index 0000000..48552ae
--- /dev/null
+++ b/TechHelper.Server/Migrations/20250625032845_up.Designer.cs
@@ -0,0 +1,1238 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using TechHelper.Context;
+
+#nullable disable
+
+namespace TechHelper.Server.Migrations
+{
+    [DbContext(typeof(ApplicationContext))]
+    [Migration("20250625032845_up")]
+    partial class up
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.16")
+                .HasAnnotation("Relational:MaxIdentifierLength", 64);
+
+            MySqlModelBuilderExtensions.AutoIncrementColumns(modelBuilder);
+
+            modelBuilder.Entity("Entities.Contracts.Assignment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("created_at");
+
+                    b.Property<Guid>("CreatorId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("created_by");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("longtext")
+                        .HasColumnName("description");
+
+                    b.Property<DateTime>("DueDate")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("due_date");
+
+                    b.Property<Guid>("ExamStructId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("exam_struct_id");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("tinyint(1)")
+                        .HasColumnName("deleted");
+
+                    b.Property<float>("Score")
+                        .HasColumnType("float")
+                        .HasColumnName("score");
+
+                    b.Property<byte>("SubjectArea")
+                        .HasColumnType("tinyint unsigned")
+                        .HasColumnName("subject_area");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("varchar(255)")
+                        .HasColumnName("title");
+
+                    b.Property<byte>("TotalQuestions")
+                        .HasColumnType("tinyint unsigned")
+                        .HasColumnName("total_points");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("updated_at");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("char(36)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatorId");
+
+                    b.HasIndex("ExamStructId")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("assignments", (string)null);
+                });
+
+            modelBuilder.Entity("Entities.Contracts.AssignmentAttachment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)")
+                        .HasColumnName("id");
+
+                    b.Property<Guid>("AssignmentId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("assignment_id");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("varchar(255)")
+                        .HasColumnName("file_name");
+
+                    b.Property<string>("FilePath")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("varchar(255)")
+                        .HasColumnName("file_path");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("tinyint(1)")
+                        .HasColumnName("deleted");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("uploaded_at");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssignmentId");
+
+                    b.ToTable("assignment_attachments");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.AssignmentClass", b =>
+                {
+                    b.Property<Guid>("AssignmentId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("assignment_id")
+                        .HasColumnOrder(0);
+
+                    b.Property<Guid>("ClassId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("class_id")
+                        .HasColumnOrder(1);
+
+                    b.Property<DateTime>("AssignedAt")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("assigned_at");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false)
+                        .HasColumnName("deleted");
+
+                    b.HasKey("AssignmentId", "ClassId");
+
+                    b.HasIndex("ClassId");
+
+                    b.ToTable("assignment_class", (string)null);
+                });
+
+            modelBuilder.Entity("Entities.Contracts.AssignmentQuestion", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("created_at");
+
+                    b.Property<byte>("Index")
+                        .HasColumnType("tinyint unsigned")
+                        .HasColumnName("question_number");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false)
+                        .HasColumnName("deleted");
+
+                    b.Property<Guid?>("ParentAssignmentQuestionId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("parent_question_group_id");
+
+                    b.Property<Guid?>("QuestionContextId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("description");
+
+                    b.Property<Guid?>("QuestionId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("question_id");
+
+                    b.Property<float?>("Score")
+                        .HasColumnType("float")
+                        .HasColumnName("score");
+
+                    b.Property<byte>("StructType")
+                        .HasColumnType("tinyint unsigned")
+                        .HasColumnName("group_state");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(1024)
+                        .HasColumnType("varchar(1024)")
+                        .HasColumnName("title");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ParentAssignmentQuestionId");
+
+                    b.HasIndex("QuestionContextId");
+
+                    b.HasIndex("QuestionId");
+
+                    b.ToTable("assignment_questions", (string)null);
+                });
+
+            modelBuilder.Entity("Entities.Contracts.Class", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("created_at");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<DateTime>("CreatedAt"));
+
+                    b.Property<string>("Description")
+                        .HasColumnType("longtext")
+                        .HasColumnName("description");
+
+                    b.Property<byte>("Grade")
+                        .HasColumnType("tinyint unsigned")
+                        .HasColumnName("grade");
+
+                    b.Property<Guid?>("HeadTeacherId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("head_teacher_id");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false)
+                        .HasColumnName("deleted");
+
+                    b.Property<byte>("Number")
+                        .HasColumnType("tinyint unsigned")
+                        .HasColumnName("class");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("updated_at");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlComputedColumn(b.Property<DateTime>("UpdatedAt"));
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("HeadTeacherId");
+
+                    b.ToTable("classes", (string)null);
+                });
+
+            modelBuilder.Entity("Entities.Contracts.ClassStudent", b =>
+                {
+                    b.Property<Guid>("ClassId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("class_id")
+                        .HasColumnOrder(0);
+
+                    b.Property<Guid>("StudentId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("student_id")
+                        .HasColumnOrder(1);
+
+                    b.Property<DateTime>("EnrollmentDate")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("enrollment_date");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false)
+                        .HasColumnName("deleted");
+
+                    b.HasKey("ClassId", "StudentId");
+
+                    b.HasIndex("StudentId");
+
+                    b.ToTable("class_student", (string)null);
+                });
+
+            modelBuilder.Entity("Entities.Contracts.ClassTeacher", b =>
+                {
+                    b.Property<Guid>("ClassId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("class_id");
+
+                    b.Property<Guid>("TeacherId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("teacher_id");
+
+                    b.Property<byte>("SubjectTaught")
+                        .HasColumnType("tinyint unsigned")
+                        .HasColumnName("subject_taught");
+
+                    b.HasKey("ClassId", "TeacherId");
+
+                    b.HasIndex("TeacherId");
+
+                    b.ToTable("class_teachers", (string)null);
+                });
+
+            modelBuilder.Entity("Entities.Contracts.KeyPoint", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("varchar(255)");
+
+                    b.Property<Guid>("LessonID")
+                        .HasColumnType("char(36)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LessonID");
+
+                    b.ToTable("key_point");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.Lesson", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<Guid>("TextbookID")
+                        .HasColumnType("char(36)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("varchar(255)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TextbookID");
+
+                    b.ToTable("lesson");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.LessonQuestion", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)");
+
+                    b.Property<Guid>("LessonID")
+                        .HasColumnType("char(36)");
+
+                    b.Property<string>("Question")
+                        .IsRequired()
+                        .HasMaxLength(65535)
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LessonID");
+
+                    b.ToTable("lesson_question");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.Question", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)")
+                        .HasColumnName("id");
+
+                    b.Property<string>("Answer")
+                        .HasMaxLength(65535)
+                        .HasColumnType("longtext")
+                        .HasColumnName("correct_answer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("created_at");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<DateTime>("CreatedAt"));
+
+                    b.Property<Guid>("CreatorId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("created_by");
+
+                    b.Property<byte>("DifficultyLevel")
+                        .HasMaxLength(10)
+                        .HasColumnType("tinyint unsigned")
+                        .HasColumnName("difficulty_level");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false)
+                        .HasColumnName("deleted");
+
+                    b.Property<Guid?>("KeyPointId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("key_point");
+
+                    b.Property<Guid?>("LessonId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("lesson");
+
+                    b.Property<string>("Options")
+                        .HasColumnType("longtext")
+                        .HasColumnName("options");
+
+                    b.Property<byte>("SubjectArea")
+                        .HasMaxLength(100)
+                        .HasColumnType("tinyint unsigned")
+                        .HasColumnName("subject_area");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(65535)
+                        .HasColumnType("longtext")
+                        .HasColumnName("question_text");
+
+                    b.Property<byte>("Type")
+                        .HasMaxLength(20)
+                        .HasColumnType("tinyint unsigned")
+                        .HasColumnName("question_type");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("updated_at");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatorId");
+
+                    b.HasIndex("KeyPointId");
+
+                    b.HasIndex("LessonId");
+
+                    b.HasIndex("Title")
+                        .HasAnnotation("MySql:IndexPrefixLength", new[] { 20 });
+
+                    b.ToTable("questions", (string)null);
+                });
+
+            modelBuilder.Entity("Entities.Contracts.QuestionContext", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("QuestionContexts");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.Submission", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)")
+                        .HasColumnName("id");
+
+                    b.Property<Guid>("AssignmentId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("assignment_id");
+
+                    b.Property<Guid>("AttemptNumber")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("attempt_number");
+
+                    b.Property<DateTime?>("GradedAt")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("graded_at");
+
+                    b.Property<Guid?>("GraderId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("graded_by");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false)
+                        .HasColumnName("deleted");
+
+                    b.Property<string>("OverallFeedback")
+                        .IsRequired()
+                        .HasColumnType("longtext")
+                        .HasColumnName("overall_feedback");
+
+                    b.Property<float?>("OverallGrade")
+                        .HasPrecision(5, 2)
+                        .HasColumnType("float")
+                        .HasColumnName("overall_grade");
+
+                    b.Property<int>("Status")
+                        .HasMaxLength(15)
+                        .HasColumnType("int")
+                        .HasColumnName("status");
+
+                    b.Property<Guid>("StudentId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("student_id");
+
+                    b.Property<DateTime>("SubmissionTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("submission_time");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssignmentId");
+
+                    b.HasIndex("GraderId");
+
+                    b.HasIndex("StudentId");
+
+                    b.ToTable("submissions", (string)null);
+                });
+
+            modelBuilder.Entity("Entities.Contracts.SubmissionDetail", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)")
+                        .HasColumnName("id");
+
+                    b.Property<Guid>("AssignmentQuestionId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("assignment_question_id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("created_at");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<DateTime>("CreatedAt"));
+
+                    b.Property<bool?>("IsCorrect")
+                        .HasColumnType("tinyint(1)")
+                        .HasColumnName("is_correct");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false)
+                        .HasColumnName("deleted");
+
+                    b.Property<float?>("PointsAwarded")
+                        .HasPrecision(5, 2)
+                        .HasColumnType("float")
+                        .HasColumnName("points_awarded");
+
+                    b.Property<string>("StudentAnswer")
+                        .IsRequired()
+                        .HasColumnType("longtext")
+                        .HasColumnName("student_answer");
+
+                    b.Property<Guid>("StudentId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("student_id");
+
+                    b.Property<Guid>("SubmissionId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("submission_id");
+
+                    b.Property<string>("TeacherFeedback")
+                        .IsRequired()
+                        .HasColumnType("longtext")
+                        .HasColumnName("teacher_feedback");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("updated_at");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssignmentQuestionId");
+
+                    b.HasIndex("StudentId");
+
+                    b.HasIndex("SubmissionId");
+
+                    b.ToTable("submission_details", (string)null);
+                });
+
+            modelBuilder.Entity("Entities.Contracts.Textbook", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)");
+
+                    b.Property<byte>("Grade")
+                        .HasColumnType("tinyint unsigned");
+
+                    b.Property<byte>("Publisher")
+                        .HasColumnType("tinyint unsigned");
+
+                    b.Property<byte>("SubjectArea")
+                        .HasColumnType("tinyint unsigned");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("textbook");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("DisplayName")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("varchar(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("tinyint(1)")
+                        .HasColumnName("deleted");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("varchar(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("varchar(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("RefreshToken")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("RefreshTokenExpiryTime")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("varchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole<System.Guid>", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("varchar(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("varchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("a203eb76-97f0-418f-bc06-9549297d2ac3"),
+                            Name = "Student",
+                            NormalizedName = "STUDENT"
+                        },
+                        new
+                        {
+                            Id = new Guid("195b19c5-fd30-455c-9f38-9842b44bf5c3"),
+                            Name = "Teacher",
+                            NormalizedName = "TEACHER"
+                        },
+                        new
+                        {
+                            Id = new Guid("53cc63db-74bc-47a8-b71a-7e120d4018a9"),
+                            Name = "Administrator",
+                            NormalizedName = "ADMINISTRATOR"
+                        });
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("longtext");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("char(36)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("longtext");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("char(36)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("varchar(255)");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("varchar(255)");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("longtext");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("char(36)");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("char(36)");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("char(36)");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("char(36)");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("varchar(255)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("varchar(255)");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("Entities.Contracts.Assignment", b =>
+                {
+                    b.HasOne("Entities.Contracts.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Entities.Contracts.AssignmentQuestion", "ExamStruct")
+                        .WithOne("Assignment")
+                        .HasForeignKey("Entities.Contracts.Assignment", "ExamStructId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Entities.Contracts.User", null)
+                        .WithMany("CreatedAssignments")
+                        .HasForeignKey("UserId");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("ExamStruct");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.AssignmentAttachment", b =>
+                {
+                    b.HasOne("Entities.Contracts.Assignment", "Assignment")
+                        .WithMany("AssignmentAttachments")
+                        .HasForeignKey("AssignmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Assignment");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.AssignmentClass", b =>
+                {
+                    b.HasOne("Entities.Contracts.Assignment", "Assignment")
+                        .WithMany("AssignmentClasses")
+                        .HasForeignKey("AssignmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Entities.Contracts.Class", "Class")
+                        .WithMany("AssignmentClasses")
+                        .HasForeignKey("ClassId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Assignment");
+
+                    b.Navigation("Class");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.AssignmentQuestion", b =>
+                {
+                    b.HasOne("Entities.Contracts.AssignmentQuestion", "ParentAssignmentQuestion")
+                        .WithMany("ChildrenAssignmentQuestion")
+                        .HasForeignKey("ParentAssignmentQuestionId");
+
+                    b.HasOne("Entities.Contracts.QuestionContext", "QuestionContext")
+                        .WithMany("Questions")
+                        .HasForeignKey("QuestionContextId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("Entities.Contracts.Question", "Question")
+                        .WithMany("AssignmentQuestions")
+                        .HasForeignKey("QuestionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("ParentAssignmentQuestion");
+
+                    b.Navigation("Question");
+
+                    b.Navigation("QuestionContext");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.Class", b =>
+                {
+                    b.HasOne("Entities.Contracts.User", "HeadTeacher")
+                        .WithMany()
+                        .HasForeignKey("HeadTeacherId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("HeadTeacher");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.ClassStudent", b =>
+                {
+                    b.HasOne("Entities.Contracts.Class", "Class")
+                        .WithMany("ClassStudents")
+                        .HasForeignKey("ClassId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Entities.Contracts.User", "Student")
+                        .WithMany("EnrolledClassesLink")
+                        .HasForeignKey("StudentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Class");
+
+                    b.Navigation("Student");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.ClassTeacher", b =>
+                {
+                    b.HasOne("Entities.Contracts.Class", "Class")
+                        .WithMany("ClassTeachers")
+                        .HasForeignKey("ClassId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Entities.Contracts.User", "Teacher")
+                        .WithMany("TaughtClassesLink")
+                        .HasForeignKey("TeacherId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Class");
+
+                    b.Navigation("Teacher");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.KeyPoint", b =>
+                {
+                    b.HasOne("Entities.Contracts.Lesson", "Lesson")
+                        .WithMany("KeyPoints")
+                        .HasForeignKey("LessonID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Lesson");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.Lesson", b =>
+                {
+                    b.HasOne("Entities.Contracts.Textbook", "Textbook")
+                        .WithMany("Lessons")
+                        .HasForeignKey("TextbookID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Textbook");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.LessonQuestion", b =>
+                {
+                    b.HasOne("Entities.Contracts.Lesson", "Lesson")
+                        .WithMany("LessonQuestions")
+                        .HasForeignKey("LessonID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Lesson");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.Question", b =>
+                {
+                    b.HasOne("Entities.Contracts.User", "Creator")
+                        .WithMany("CreatedQuestions")
+                        .HasForeignKey("CreatorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Entities.Contracts.KeyPoint", "KeyPoint")
+                        .WithMany("Questions")
+                        .HasForeignKey("KeyPointId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("Entities.Contracts.Lesson", "Lesson")
+                        .WithMany("Questions")
+                        .HasForeignKey("LessonId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("KeyPoint");
+
+                    b.Navigation("Lesson");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.Submission", b =>
+                {
+                    b.HasOne("Entities.Contracts.Assignment", "Assignment")
+                        .WithMany("Submissions")
+                        .HasForeignKey("AssignmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Entities.Contracts.User", "Grader")
+                        .WithMany("GradedSubmissions")
+                        .HasForeignKey("GraderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("Entities.Contracts.User", "Student")
+                        .WithMany("SubmissionsAsStudent")
+                        .HasForeignKey("StudentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Assignment");
+
+                    b.Navigation("Grader");
+
+                    b.Navigation("Student");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.SubmissionDetail", b =>
+                {
+                    b.HasOne("Entities.Contracts.AssignmentQuestion", "AssignmentQuestion")
+                        .WithMany("SubmissionDetails")
+                        .HasForeignKey("AssignmentQuestionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Entities.Contracts.User", "Student")
+                        .WithMany("SubmissionDetails")
+                        .HasForeignKey("StudentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Entities.Contracts.Submission", "Submission")
+                        .WithMany("SubmissionDetails")
+                        .HasForeignKey("SubmissionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AssignmentQuestion");
+
+                    b.Navigation("Student");
+
+                    b.Navigation("Submission");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole<System.Guid>", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
+                {
+                    b.HasOne("Entities.Contracts.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
+                {
+                    b.HasOne("Entities.Contracts.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole<System.Guid>", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Entities.Contracts.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
+                {
+                    b.HasOne("Entities.Contracts.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Entities.Contracts.Assignment", b =>
+                {
+                    b.Navigation("AssignmentAttachments");
+
+                    b.Navigation("AssignmentClasses");
+
+                    b.Navigation("Submissions");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.AssignmentQuestion", b =>
+                {
+                    b.Navigation("Assignment");
+
+                    b.Navigation("ChildrenAssignmentQuestion");
+
+                    b.Navigation("SubmissionDetails");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.Class", b =>
+                {
+                    b.Navigation("AssignmentClasses");
+
+                    b.Navigation("ClassStudents");
+
+                    b.Navigation("ClassTeachers");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.KeyPoint", b =>
+                {
+                    b.Navigation("Questions");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.Lesson", b =>
+                {
+                    b.Navigation("KeyPoints");
+
+                    b.Navigation("LessonQuestions");
+
+                    b.Navigation("Questions");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.Question", b =>
+                {
+                    b.Navigation("AssignmentQuestions");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.QuestionContext", b =>
+                {
+                    b.Navigation("Questions");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.Submission", b =>
+                {
+                    b.Navigation("SubmissionDetails");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.Textbook", b =>
+                {
+                    b.Navigation("Lessons");
+                });
+
+            modelBuilder.Entity("Entities.Contracts.User", b =>
+                {
+                    b.Navigation("CreatedAssignments");
+
+                    b.Navigation("CreatedQuestions");
+
+                    b.Navigation("EnrolledClassesLink");
+
+                    b.Navigation("GradedSubmissions");
+
+                    b.Navigation("SubmissionDetails");
+
+                    b.Navigation("SubmissionsAsStudent");
+
+                    b.Navigation("TaughtClassesLink");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/TechHelper.Server/Migrations/20250625032845_up.cs b/TechHelper.Server/Migrations/20250625032845_up.cs
new file mode 100644
index 0000000..5f073a2
--- /dev/null
+++ b/TechHelper.Server/Migrations/20250625032845_up.cs
@@ -0,0 +1,95 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+#pragma warning disable CA1814 // Prefer jagged arrays over multidimensional
+
+namespace TechHelper.Server.Migrations
+{
+    /// <inheritdoc />
+    public partial class up : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_class_teachers_AspNetUsers_teacher_id",
+                table: "class_teachers");
+
+            migrationBuilder.DeleteData(
+                table: "AspNetRoles",
+                keyColumn: "Id",
+                keyValue: new Guid("8b814a50-fd96-4bfa-a666-b247c0f13e22"));
+
+            migrationBuilder.DeleteData(
+                table: "AspNetRoles",
+                keyColumn: "Id",
+                keyValue: new Guid("ab2c8f8c-1ade-4ff5-9eb4-2925a89567b1"));
+
+            migrationBuilder.DeleteData(
+                table: "AspNetRoles",
+                keyColumn: "Id",
+                keyValue: new Guid("c6f92bbf-190f-47a5-b4d6-ed6874a378e8"));
+
+            migrationBuilder.InsertData(
+                table: "AspNetRoles",
+                columns: new[] { "Id", "ConcurrencyStamp", "Name", "NormalizedName" },
+                values: new object[,]
+                {
+                    { new Guid("195b19c5-fd30-455c-9f38-9842b44bf5c3"), null, "Teacher", "TEACHER" },
+                    { new Guid("53cc63db-74bc-47a8-b71a-7e120d4018a9"), null, "Administrator", "ADMINISTRATOR" },
+                    { new Guid("a203eb76-97f0-418f-bc06-9549297d2ac3"), null, "Student", "STUDENT" }
+                });
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_class_teachers_AspNetUsers_teacher_id",
+                table: "class_teachers",
+                column: "teacher_id",
+                principalTable: "AspNetUsers",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_class_teachers_AspNetUsers_teacher_id",
+                table: "class_teachers");
+
+            migrationBuilder.DeleteData(
+                table: "AspNetRoles",
+                keyColumn: "Id",
+                keyValue: new Guid("195b19c5-fd30-455c-9f38-9842b44bf5c3"));
+
+            migrationBuilder.DeleteData(
+                table: "AspNetRoles",
+                keyColumn: "Id",
+                keyValue: new Guid("53cc63db-74bc-47a8-b71a-7e120d4018a9"));
+
+            migrationBuilder.DeleteData(
+                table: "AspNetRoles",
+                keyColumn: "Id",
+                keyValue: new Guid("a203eb76-97f0-418f-bc06-9549297d2ac3"));
+
+            migrationBuilder.InsertData(
+                table: "AspNetRoles",
+                columns: new[] { "Id", "ConcurrencyStamp", "Name", "NormalizedName" },
+                values: new object[,]
+                {
+                    { new Guid("8b814a50-fd96-4bfa-a666-b247c0f13e22"), null, "Administrator", "ADMINISTRATOR" },
+                    { new Guid("ab2c8f8c-1ade-4ff5-9eb4-2925a89567b1"), null, "Student", "STUDENT" },
+                    { new Guid("c6f92bbf-190f-47a5-b4d6-ed6874a378e8"), null, "Teacher", "TEACHER" }
+                });
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_class_teachers_AspNetUsers_teacher_id",
+                table: "class_teachers",
+                column: "teacher_id",
+                principalTable: "AspNetUsers",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Restrict);
+        }
+    }
+}
diff --git a/TechHelper.Server/Migrations/ApplicationContextModelSnapshot.cs b/TechHelper.Server/Migrations/ApplicationContextModelSnapshot.cs
index 3c5c7ec..22b79a9 100644
--- a/TechHelper.Server/Migrations/ApplicationContextModelSnapshot.cs
+++ b/TechHelper.Server/Migrations/ApplicationContextModelSnapshot.cs
@@ -744,19 +744,19 @@ namespace TechHelper.Server.Migrations
                     b.HasData(
                         new
                         {
-                            Id = new Guid("ab2c8f8c-1ade-4ff5-9eb4-2925a89567b1"),
+                            Id = new Guid("a203eb76-97f0-418f-bc06-9549297d2ac3"),
                             Name = "Student",
                             NormalizedName = "STUDENT"
                         },
                         new
                         {
-                            Id = new Guid("c6f92bbf-190f-47a5-b4d6-ed6874a378e8"),
+                            Id = new Guid("195b19c5-fd30-455c-9f38-9842b44bf5c3"),
                             Name = "Teacher",
                             NormalizedName = "TEACHER"
                         },
                         new
                         {
-                            Id = new Guid("8b814a50-fd96-4bfa-a666-b247c0f13e22"),
+                            Id = new Guid("53cc63db-74bc-47a8-b71a-7e120d4018a9"),
                             Name = "Administrator",
                             NormalizedName = "ADMINISTRATOR"
                         });
@@ -982,7 +982,7 @@ namespace TechHelper.Server.Migrations
                     b.HasOne("Entities.Contracts.User", "Teacher")
                         .WithMany("TaughtClassesLink")
                         .HasForeignKey("TeacherId")
-                        .OnDelete(DeleteBehavior.Restrict)
+                        .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
                     b.Navigation("Class");
diff --git a/TechHelper.Server/Services/AuthenticationService.cs b/TechHelper.Server/Services/AuthenticationService.cs
index 0f3fbc6..fc0cbad 100644
--- a/TechHelper.Server/Services/AuthenticationService.cs
+++ b/TechHelper.Server/Services/AuthenticationService.cs
@@ -60,9 +60,14 @@ namespace TechHelper.Services
 			var classInfo = await _classService.GetUserClass(user.Id);
 			if (classInfo.Status)
 			{
-				(byte, byte) info = ((byte, byte))classInfo.Result;
-				claims.Add(new Claim("Grade", info.Item1.ToString()));
-				claims.Add(new Claim("Class", info.Item2.ToString()));
+				var classs = classInfo.Result as List<Class>;
+
+				classs?.ForEach(c =>
+				{
+
+					claims.Add(new Claim("Grade", c.Grade.ToString()));
+					claims.Add(new Claim("Class", c.Number.ToString()));
+				});
 			}
 
 			return claims;
@@ -74,7 +79,7 @@ namespace TechHelper.Services
 				issuer: _jwtSettings.ValidIssuer,
 				audience: _jwtSettings.ValidAudience,
 				claims: claims,
-				expires: DateTime.Now.AddMinutes(Convert.ToDouble(
+				expires: DateTime.UtcNow.AddMinutes(Convert.ToDouble(
 					_jwtSettings.ExpiryInMinutes)),
 				signingCredentials: signingCredentials);
 
diff --git a/TechHelper.Server/Services/ClassService.cs b/TechHelper.Server/Services/ClassService.cs
index fed024e..6f95de8 100644
--- a/TechHelper.Server/Services/ClassService.cs
+++ b/TechHelper.Server/Services/ClassService.cs
@@ -2,6 +2,7 @@
 using Entities.Contracts;
 using Entities.DTO;
 using Microsoft.AspNetCore.Identity;
+using Microsoft.EntityFrameworkCore;
 using Org.BouncyCastle.Crypto;
 using SharedDATA.Api;
 
@@ -105,7 +106,7 @@ namespace TechHelper.Services
 		}
 
 		// 实现 IBaseService<ClassDto, int>.GetAsync
-		public async Task<ApiResponse> GetAsync(Guid id) 
+		public async Task<ApiResponse> GetAsync(Guid id)
 		{
 			try
 			{
@@ -126,13 +127,20 @@ namespace TechHelper.Services
 			}
 		}
 
-		public async Task<ApiResponse> GetUserClass(Guid user)
+		public async Task<ApiResponse> GetUserClass(Guid id)
 		{
-			var existingUserClass = await _work.GetRepository<ClassStudent>().GetFirstOrDefaultAsync(predicate: c=>c.StudentId == user);
-			if(existingUserClass == null) return new ApiResponse("该学生没有班级。");
+			var tch = await _work.GetRepository<ClassTeacher>().GetAllAsync(predicate: user => user.TeacherId == id, include: i => i
+			.Include(t => t.Class));
+			var std = await _work.GetRepository<ClassStudent>().GetAllAsync(predicate: user => user.StudentId == id, include: i => i
+			.Include(t => t.Class));
 
-			var classId = await _work.GetRepository<Class>().GetFirstOrDefaultAsync(predicate: c => c.Id == existingUserClass.ClassId);
-			return new ApiResponse(true, (classId.Grade, classId.Number));
+			if (tch == null && std == null) return new ApiResponse("你没有加入任何班级。");
+
+
+			List<Class> result = new List<Class>();
+			tch?.ToList().ForEach(c => result.Add(c.Class));
+			std?.ToList().ForEach(c => result.Add(c.Class));
+			return ApiResponse.Success(result: result);
 		}
 
 		// 实现 IBaseService<ClassDto, int>.UpdateAsync
@@ -142,14 +150,14 @@ namespace TechHelper.Services
 			{
 				// 首先通过 ID 查找现有实体
 				var existingClass = await _work.GetRepository<Class>().GetFirstOrDefaultAsync(
-					predicate: c => c.Number == model.Class); 
+					predicate: c => c.Number == model.Class);
 
 				if (existingClass == null)
 				{
 					return new ApiResponse("班级未找到。");
 				}
 
-				_mapper.Map(model, existingClass); 
+				_mapper.Map(model, existingClass);
 				_work.GetRepository<Class>().Update(existingClass);
 
 				if (await _work.SaveChangesAsync() > 0)
@@ -172,47 +180,87 @@ namespace TechHelper.Services
 				var existingClass = await _work.GetRepository<Class>().GetFirstOrDefaultAsync(
 					predicate: (c => c.Number == user.ClassId && c.Grade == user.GradeId));
 
-				var finduser = await _userManager.FindByEmailAsync(user.User);
+				// finduser and usrinfo are redundant if they are for the same user.
+				// Let's just use usrinfo
+				// var finduser = await _userManager.FindByEmailAsync(user.User); 
 
-				if (existingClass == null || finduser == null || usrinfo == null)
+				if (existingClass == null || usrinfo == null) // Simplified check
 				{
-					return new ApiResponse("班级未找到。");
+					return new ApiResponse("班级或用户未找到。"); // More accurate message
 				}
 
-
+				bool registrationExists = false;
 
 				if (user.Roles == UserRoles.Student)
 				{
-					var addresult = await _work.GetRepository<ClassStudent>().InsertAsync(new ClassStudent
+					// Check for existing student registration
+					var existingStudentRegistration = await _work.GetRepository<ClassStudent>().GetFirstOrDefaultAsync(
+						predicate: cs => cs.StudentId == usrinfo.Id && cs.ClassId == existingClass.Id);
+
+					if (existingStudentRegistration != null)
 					{
-						StudentId = finduser.Id,
-						ClassId = existingClass.Id
-					});
+						registrationExists = true;
+					}
+					else
+					{
+						var addresult = await _work.GetRepository<ClassStudent>().InsertAsync(new ClassStudent
+						{
+							StudentId = usrinfo.Id, // Use usrinfo.Id
+							ClassId = existingClass.Id
+						});
+					}
 
 					await _userManager.AddToRoleAsync(usrinfo, UserRoles.Student.ToString());
 				}
 				else if (user.Roles == UserRoles.Teacher)
 				{
-					var classTeacher = new ClassTeacher
+					// Check for existing teacher registration
+					var existingTeacherRegistration = await _work.GetRepository<ClassTeacher>().GetFirstOrDefaultAsync(
+						predicate: ct => ct.TeacherId == usrinfo.Id && ct.ClassId == existingClass.Id);
+
+					if (existingTeacherRegistration != null)
 					{
-						ClassId = existingClass.Id,
-						TeacherId = existingClass.Id,
-						SubjectTaught = user.SubjectArea
-					};
-					await _work.GetRepository<ClassTeacher>().InsertAsync(classTeacher);
+						registrationExists = true;
+					}
+					else
+					{
+						var classTeacher = new ClassTeacher
+						{
+							ClassId = existingClass.Id,
+							TeacherId = usrinfo.Id, // Use usrinfo.Id
+							SubjectTaught = user.SubjectArea
+						};
+						await _work.GetRepository<ClassTeacher>().InsertAsync(classTeacher);
+					}
 
 					await _userManager.AddToRoleAsync(usrinfo, UserRoles.Teacher.ToString());
 				}
 
+				if (registrationExists)
+				{
+					return new ApiResponse("用户已在此班级注册，请勿重复注册。");
+				}
+
 				if (await _work.SaveChangesAsync() > 0)
 				{
+					// It's possible SaveChangesAsync returns 0 even if a role was added
+					// A more robust check might be needed depending on your exact requirements.
 					return new ApiResponse(true, _mapper.Map<ClassDto>(existingClass));
 				}
+
+				// If SaveChangesAsync returns 0 and registrationExists is false, it means no actual DB change occurred for the ClassStudent/ClassTeacher insert.
+				// This could happen if only the role was added, but the ClassStudent/Teacher was already there (and caught by the check).
+				// Or it means the insert failed for another reason not caught by the duplicate check.
+				// The previous error message "班级注册失败" is still appropriate in such cases.
 				return new ApiResponse("班级注册失败。");
 
 			}
-			catch (Exception ex) { return new ApiResponse($"注册进班级时发生错误: {ex.Message}"); }
+			catch (Exception ex)
+			{
+				// Log the exception details for debugging
+				// _logger.LogError(ex, "注册进班级时发生错误"); 
+				return new ApiResponse($"注册进班级时发生错误: {ex.Message}");
+			}
 		}
 	}
 }
-	
\ No newline at end of file
diff --git a/TechHelper.Server/Services/IClassService.cs b/TechHelper.Server/Services/IClassService.cs
index 7ead347..4b2582a 100644
--- a/TechHelper.Server/Services/IClassService.cs
+++ b/TechHelper.Server/Services/IClassService.cs
@@ -8,5 +8,6 @@ namespace TechHelper.Services
 	{
 		public Task<ApiResponse> UserRegister(UserRegistrationToClassDto user);
 		public Task<ApiResponse> GetUserClass(Guid user);
+		public Task<ApiResponse> GetClassStudents(ClassDto classDto);
 	}
 }