修复Mysql

2026-07-26 10:19:46 +08:00
parent 634ef69a27
commit 72297aa23f
31 changed files with 1642 additions and 1192 deletions
@@ -369,12 +369,12 @@ public sealed class CourseSelectionsController(
        var source = db.Students.AsNoTracking()
            .Where(x =>
                x.Status == StudentStatus.Active &&
-                (offering.IsOpenToAll ||
-                 offering.ClassIds.Contains(x.AdministrativeClassId)) &&
                !db.CourseEnrollments.Any(enrollment =>
                    enrollment.CourseSelectionOfferingId == id &&
                    enrollment.StudentId == x.Id &&
                    enrollment.Status == CourseEnrollmentStatus.Enrolled));
+        if (!offering.IsOpenToAll)
+            source = source.WhereIn(offering.ClassIds, x => x.AdministrativeClassId);
        if (!string.IsNullOrWhiteSpace(keyword))
        {
            keyword = keyword.Trim();
@@ -415,157 +415,160 @@ public sealed class CourseSelectionsController(
        if (studentIds.Length > 100)
            return ValidationProblem("单次最多可为 100 名学生代选。");

-        await using var transaction = await db.Database.BeginTransactionAsync(
-            IsolationLevel.Serializable,
-            cancellationToken);
-        var offering = await db.CourseSelectionOfferings
-            .Include(x => x.CourseSelectionRound)
-            .Include(x => x.TeachingTask)
-            .ThenInclude(x => x!.Course)
-            .Include(x => x.TeachingTask)
-            .ThenInclude(x => x!.Classes)
-            .FirstOrDefaultAsync(x => x.Id == id, cancellationToken);
-        if (offering is null) return NotFound();
-        var round = offering.CourseSelectionRound!;
-        var task = offering.TeachingTask!;
-        if (!CourseSelectionRules.SupportsProxyEnrollment(task.Course!.Nature))
-            return ConflictProblem("管理员代选仅适用于公共必修课。");
-        if (round.Status == CourseSelectionRoundStatus.Draft)
-            return ConflictProblem("选课批次开放后才能办理管理员代选。");
-        if (task.Status != TeachingTaskStatus.Published)
-            return ConflictProblem("该教学班当前不可办理代选。");
-
-        var students = await db.Students
-            .Include(x => x.AdministrativeClass)
-            .Where(x => studentIds.Contains(x.Id))
-            .OrderBy(x => x.StudentNumber)
-            .ToListAsync(cancellationToken);
-        if (students.Count != studentIds.Length)
-            return ValidationProblem("存在无效的学生档案。");
-        var inactive = students.FirstOrDefault(x => x.Status != StudentStatus.Active);
-        if (inactive is not null)
-            return ConflictProblem($"学生 {inactive.StudentNumber} {inactive.Name} 当前不是在籍状态。");
-        var outOfScope = students.FirstOrDefault(student =>
-            !offering.IsOpenToAll &&
-            !task.Classes.Any(item =>
-                item.AdministrativeClassId == student.AdministrativeClassId));
-        if (outOfScope is not null)
-        {
-            return ConflictProblem(
-                $"学生 {outOfScope.StudentNumber} {outOfScope.Name} 不属于该教学班的选课对象。");
-        }
-
-        var existingEnrollments = await db.CourseEnrollments
-            .Where(x =>
-                x.CourseSelectionOfferingId == id &&
-                studentIds.Contains(x.StudentId))
-            .ToListAsync(cancellationToken);
-        var alreadyEnrolled = existingEnrollments.FirstOrDefault(x =>
-            x.Status == CourseEnrollmentStatus.Enrolled);
-        if (alreadyEnrolled is not null)
-        {
-            var student = students.First(x => x.Id == alreadyEnrolled.StudentId);
-            return ConflictProblem(
-                $"学生 {student.StudentNumber} {student.Name} 已在该教学班名单中。");
-        }
-
-        var enrolledCount = await db.CourseEnrollments.CountAsync(
-            x =>
-                x.CourseSelectionOfferingId == id &&
-                x.Status == CourseEnrollmentStatus.Enrolled,
-            cancellationToken);
-        if (enrolledCount + students.Count > offering.Capacity)
-        {
-            return ConflictProblem(
-                $"教学班仅剩 {Math.Max(0, offering.Capacity - enrolledCount)} 个名额，无法完成本次代选。");
-        }
-
-        var duplicateStudentIds = await db.CourseEnrollments.AsNoTracking()
-            .Where(x =>
-                studentIds.Contains(x.StudentId) &&
-                x.Status == CourseEnrollmentStatus.Enrolled &&
-                x.CourseSelectionOffering!.TeachingTask!.CourseId == task.CourseId &&
-                x.CourseSelectionOffering.CourseSelectionRound!.AcademicTermId ==
-                    round.AcademicTermId)
-            .Select(x => x.StudentId)
-            .Distinct()
-            .ToListAsync(cancellationToken);
-        if (duplicateStudentIds.Count > 0)
-        {
-            var student = students.First(x => duplicateStudentIds.Contains(x.Id));
-            return ConflictProblem(
-                $"学生 {student.StudentNumber} {student.Name} 本学期已选择相同课程。");
-        }
-
-        var candidateEntries = await PublishedScheduleEntries(
-            round.AcademicTermId,
-            [task.Id],
-            cancellationToken);
-        if (CourseSelectionRules.RequiresPublishedSchedule(task.SchedulingMode) &&
-            candidateEntries.Count == 0)
-            return ConflictProblem("该教学班尚未发布课表，暂时不能办理代选。");
-
-        foreach (var student in students)
-        {
-            var selectedCredits = await db.CourseEnrollments
-                .Where(x =>
-                    x.StudentId == student.Id &&
-                    x.Status == CourseEnrollmentStatus.Enrolled &&
-                    x.CourseSelectionOffering!.CourseSelectionRoundId == round.Id)
-                .SumAsync(
-                    x => (decimal?)x.CourseSelectionOffering!.TeachingTask!.Course!.Credits,
-                    cancellationToken) ?? 0;
-            if (selectedCredits + task.Course.Credits > round.MaxCredits)
+        return await db.ExecuteInRetriableTransactionAsync<ActionResult>(
+            async transaction =>
            {
-                return ConflictProblem(
-                    $"学生 {student.StudentNumber} {student.Name} 代选后将超过本轮 {round.MaxCredits:0.#} 学分上限。");
-            }
+                db.ChangeTracker.Clear();
+                var offering = await db.CourseSelectionOfferings
+                    .Include(x => x.CourseSelectionRound)
+                    .Include(x => x.TeachingTask)
+                    .ThenInclude(x => x!.Course)
+                    .Include(x => x.TeachingTask)
+                    .ThenInclude(x => x!.Classes)
+                    .FirstOrDefaultAsync(x => x.Id == id, cancellationToken);
+                if (offering is null) return NotFound();
+                var round = offering.CourseSelectionRound!;
+                var task = offering.TeachingTask!;
+                if (!CourseSelectionRules.SupportsProxyEnrollment(task.Course!.Nature))
+                    return ConflictProblem("管理员代选仅适用于公共必修课。");
+                if (round.Status == CourseSelectionRoundStatus.Draft)
+                    return ConflictProblem("选课批次开放后才能办理管理员代选。");
+                if (task.Status != TeachingTaskStatus.Published)
+                    return ConflictProblem("该教学班当前不可办理代选。");

-            var selectedTaskIds = await db.CourseEnrollments.AsNoTracking()
-                .Where(x =>
-                    x.StudentId == student.Id &&
-                    x.Status == CourseEnrollmentStatus.Enrolled &&
-                    x.CourseSelectionOffering!.CourseSelectionRound!.AcademicTermId ==
-                        round.AcademicTermId)
-                .Select(x => x.CourseSelectionOffering!.TeachingTaskId)
-                .Distinct()
-                .ToArrayAsync(cancellationToken);
-            var selectedEntries = await PublishedScheduleEntries(
-                round.AcademicTermId,
-                selectedTaskIds,
-                cancellationToken);
-            if (CourseSelectionRules.HasScheduleConflict(candidateEntries, selectedEntries))
-            {
-                return ConflictProblem(
-                    $"学生 {student.StudentNumber} {student.Name} 的已选课程与该教学班时间冲突。");
-            }
-        }
-
-        var now = DateTime.UtcNow;
-        foreach (var student in students)
-        {
-            var enrollment = existingEnrollments.FirstOrDefault(x =>
-                x.StudentId == student.Id);
-            if (enrollment is null)
-            {
-                db.CourseEnrollments.Add(new CourseEnrollment
+                var students = await db.Students
+                    .Include(x => x.AdministrativeClass)
+                    .WhereIn(studentIds, x => x.Id)
+                    .OrderBy(x => x.StudentNumber)
+                    .ToListAsync(cancellationToken);
+                if (students.Count != studentIds.Length)
+                    return ValidationProblem("存在无效的学生档案。");
+                var inactive = students.FirstOrDefault(x => x.Status != StudentStatus.Active);
+                if (inactive is not null)
+                    return ConflictProblem($"学生 {inactive.StudentNumber} {inactive.Name} 当前不是在籍状态。");
+                var outOfScope = students.FirstOrDefault(student =>
+                    !offering.IsOpenToAll &&
+                    !task.Classes.Any(item =>
+                        item.AdministrativeClassId == student.AdministrativeClassId));
+                if (outOfScope is not null)
                {
-                    CourseSelectionOfferingId = id,
-                    StudentId = student.Id,
-                    EnrolledAt = now
-                });
-            }
-            else
-            {
-                enrollment.Status = CourseEnrollmentStatus.Enrolled;
-                enrollment.EnrolledAt = now;
-                enrollment.WithdrawnAt = null;
-            }
-        }
+                    return ConflictProblem(
+                        $"学生 {outOfScope.StudentNumber} {outOfScope.Name} 不属于该教学班的选课对象。");
+                }

-        await db.SaveChangesAsync(cancellationToken);
-        await transaction.CommitAsync(cancellationToken);
-        return Ok(new { EnrolledCount = students.Count });
+                var existingEnrollments = await db.CourseEnrollments
+                    .Where(x => x.CourseSelectionOfferingId == id)
+                    .WhereIn(studentIds, x => x.StudentId)
+                    .ToListAsync(cancellationToken);
+                var alreadyEnrolled = existingEnrollments.FirstOrDefault(x =>
+                    x.Status == CourseEnrollmentStatus.Enrolled);
+                if (alreadyEnrolled is not null)
+                {
+                    var student = students.First(x => x.Id == alreadyEnrolled.StudentId);
+                    return ConflictProblem(
+                        $"学生 {student.StudentNumber} {student.Name} 已在该教学班名单中。");
+                }
+
+                var enrolledCount = await db.CourseEnrollments.CountAsync(
+                    x =>
+                        x.CourseSelectionOfferingId == id &&
+                        x.Status == CourseEnrollmentStatus.Enrolled,
+                    cancellationToken);
+                if (enrolledCount + students.Count > offering.Capacity)
+                {
+                    return ConflictProblem(
+                        $"教学班仅剩 {Math.Max(0, offering.Capacity - enrolledCount)} 个名额，无法完成本次代选。");
+                }
+
+                var duplicateStudentIds = await db.CourseEnrollments.AsNoTracking()
+                    .Where(x =>
+                        x.Status == CourseEnrollmentStatus.Enrolled &&
+                        x.CourseSelectionOffering!.TeachingTask!.CourseId == task.CourseId &&
+                        x.CourseSelectionOffering.CourseSelectionRound!.AcademicTermId ==
+                            round.AcademicTermId)
+                    .WhereIn(studentIds, x => x.StudentId)
+                    .Select(x => x.StudentId)
+                    .Distinct()
+                    .ToListAsync(cancellationToken);
+                if (duplicateStudentIds.Count > 0)
+                {
+                    var student = students.First(x => duplicateStudentIds.Contains(x.Id));
+                    return ConflictProblem(
+                        $"学生 {student.StudentNumber} {student.Name} 本学期已选择相同课程。");
+                }
+
+                var candidateEntries = await PublishedScheduleEntries(
+                    round.AcademicTermId,
+                    [task.Id],
+                    cancellationToken);
+                if (CourseSelectionRules.RequiresPublishedSchedule(task.SchedulingMode) &&
+                    candidateEntries.Count == 0)
+                    return ConflictProblem("该教学班尚未发布课表，暂时不能办理代选。");
+
+                foreach (var student in students)
+                {
+                    var selectedCredits = await db.CourseEnrollments
+                        .Where(x =>
+                            x.StudentId == student.Id &&
+                            x.Status == CourseEnrollmentStatus.Enrolled &&
+                            x.CourseSelectionOffering!.CourseSelectionRoundId == round.Id)
+                        .SumAsync(
+                            x => (decimal?)x.CourseSelectionOffering!.TeachingTask!.Course!.Credits,
+                            cancellationToken) ?? 0;
+                    if (selectedCredits + task.Course.Credits > round.MaxCredits)
+                    {
+                        return ConflictProblem(
+                            $"学生 {student.StudentNumber} {student.Name} 代选后将超过本轮 {round.MaxCredits:0.#} 学分上限。");
+                    }
+
+                    var selectedTaskIds = await db.CourseEnrollments.AsNoTracking()
+                        .Where(x =>
+                            x.StudentId == student.Id &&
+                            x.Status == CourseEnrollmentStatus.Enrolled &&
+                            x.CourseSelectionOffering!.CourseSelectionRound!.AcademicTermId ==
+                                round.AcademicTermId)
+                        .Select(x => x.CourseSelectionOffering!.TeachingTaskId)
+                        .Distinct()
+                        .ToArrayAsync(cancellationToken);
+                    var selectedEntries = await PublishedScheduleEntries(
+                        round.AcademicTermId,
+                        selectedTaskIds,
+                        cancellationToken);
+                    if (CourseSelectionRules.HasScheduleConflict(candidateEntries, selectedEntries))
+                    {
+                        return ConflictProblem(
+                            $"学生 {student.StudentNumber} {student.Name} 的已选课程与该教学班时间冲突。");
+                    }
+                }
+
+                var now = DateTime.UtcNow;
+                foreach (var student in students)
+                {
+                    var enrollment = existingEnrollments.FirstOrDefault(x =>
+                        x.StudentId == student.Id);
+                    if (enrollment is null)
+                    {
+                        db.CourseEnrollments.Add(new CourseEnrollment
+                        {
+                            CourseSelectionOfferingId = id,
+                            StudentId = student.Id,
+                            EnrolledAt = now
+                        });
+                    }
+                    else
+                    {
+                        enrollment.Status = CourseEnrollmentStatus.Enrolled;
+                        enrollment.EnrolledAt = now;
+                        enrollment.WithdrawnAt = null;
+                    }
+                }
+
+                await db.SaveChangesAsync(cancellationToken);
+                await transaction.CommitAsync(cancellationToken);
+                return Ok(new { EnrolledCount = students.Count });
+            },
+            cancellationToken,
+            IsolationLevel.Serializable);
    }

    [HttpPost("offerings/{offeringId:guid}/force-enroll")]
@@ -581,73 +584,77 @@ public sealed class CourseSelectionsController(
        if (studentIds.Length > 100)
            return ValidationProblem("单次最多可为 100 名学生强制选课。");

-        await using var transaction = await db.Database.BeginTransactionAsync(
-            IsolationLevel.Serializable, cancellationToken);
-        var offering = await db.CourseSelectionOfferings
-            .Include(x => x.CourseSelectionRound)
-            .Include(x => x.TeachingTask)
-            .ThenInclude(x => x!.Course)
-            .FirstOrDefaultAsync(x => x.Id == offeringId, cancellationToken);
-        if (offering is null) return NotFound();
-        var round = offering.CourseSelectionRound!;
-        var task = offering.TeachingTask!;
-
-        if (round.Status == CourseSelectionRoundStatus.Draft)
-            return ConflictProblem("选课批次开放后才能办理强制选课。");
-        if (task.Status != TeachingTaskStatus.Published)
-            return ConflictProblem("该教学班当前不可选。");
-
-        var students = await db.Students
-            .Include(x => x.AdministrativeClass)
-            .Where(x => studentIds.Contains(x.Id))
-            .OrderBy(x => x.StudentNumber)
-            .ToListAsync(cancellationToken);
-        if (students.Count != studentIds.Length)
-            return ValidationProblem("存在无效的学生档案。");
-
-        var existingEnrollments = await db.CourseEnrollments
-            .Where(x =>
-                x.CourseSelectionOfferingId == offeringId &&
-                studentIds.Contains(x.StudentId))
-            .ToListAsync(cancellationToken);
-        var alreadyEnrolled = existingEnrollments
-            .FirstOrDefault(x => x.Status == CourseEnrollmentStatus.Enrolled);
-        if (alreadyEnrolled is not null)
-        {
-            var dup = students.First(x => x.Id == alreadyEnrolled.StudentId);
-            return ConflictProblem(
-                $"学生 {dup.StudentNumber} {dup.Name} 已在该教学班名单中。");
-        }
-
-        var now = DateTime.UtcNow;
-        var enrolled = 0;
-        foreach (var student in students)
-        {
-            var enrollment = existingEnrollments
-                .FirstOrDefault(x => x.StudentId == student.Id);
-            if (enrollment is null)
+        return await db.ExecuteInRetriableTransactionAsync<ActionResult>(
+            async transaction =>
            {
-                db.CourseEnrollments.Add(new CourseEnrollment
+                db.ChangeTracker.Clear();
+                var offering = await db.CourseSelectionOfferings
+                    .Include(x => x.CourseSelectionRound)
+                    .Include(x => x.TeachingTask)
+                    .ThenInclude(x => x!.Course)
+                    .FirstOrDefaultAsync(x => x.Id == offeringId, cancellationToken);
+                if (offering is null) return NotFound();
+                var round = offering.CourseSelectionRound!;
+                var task = offering.TeachingTask!;
+
+                if (round.Status == CourseSelectionRoundStatus.Draft)
+                    return ConflictProblem("选课批次开放后才能办理强制选课。");
+                if (task.Status != TeachingTaskStatus.Published)
+                    return ConflictProblem("该教学班当前不可选。");
+
+                var students = await db.Students
+                    .Include(x => x.AdministrativeClass)
+                    .WhereIn(studentIds, x => x.Id)
+                    .OrderBy(x => x.StudentNumber)
+                    .ToListAsync(cancellationToken);
+                if (students.Count != studentIds.Length)
+                    return ValidationProblem("存在无效的学生档案。");
+
+                var existingEnrollments = await db.CourseEnrollments
+                    .Where(x => x.CourseSelectionOfferingId == offeringId)
+                    .WhereIn(studentIds, x => x.StudentId)
+                    .ToListAsync(cancellationToken);
+                var alreadyEnrolled = existingEnrollments
+                    .FirstOrDefault(x => x.Status == CourseEnrollmentStatus.Enrolled);
+                if (alreadyEnrolled is not null)
                {
-                    CourseSelectionOfferingId = offeringId,
-                    StudentId = student.Id,
-                    EnrollmentType = EnrollmentType.Retake,
-                    EnrolledAt = now
-                });
-            }
-            else
-            {
-                enrollment.Status = CourseEnrollmentStatus.Enrolled;
-                enrollment.EnrolledAt = now;
-                enrollment.WithdrawnAt = null;
-                enrollment.EnrollmentType = EnrollmentType.Retake;
-            }
-            enrolled++;
-        }
+                    var dup = students.First(x => x.Id == alreadyEnrolled.StudentId);
+                    return ConflictProblem(
+                        $"学生 {dup.StudentNumber} {dup.Name} 已在该教学班名单中。");
+                }

-        await db.SaveChangesAsync(cancellationToken);
-        await transaction.CommitAsync(cancellationToken);
-        return Ok(new { EnrolledCount = enrolled });
+                var now = DateTime.UtcNow;
+                var enrolled = 0;
+                foreach (var student in students)
+                {
+                    var enrollment = existingEnrollments
+                        .FirstOrDefault(x => x.StudentId == student.Id);
+                    if (enrollment is null)
+                    {
+                        db.CourseEnrollments.Add(new CourseEnrollment
+                        {
+                            CourseSelectionOfferingId = offeringId,
+                            StudentId = student.Id,
+                            EnrollmentType = EnrollmentType.Retake,
+                            EnrolledAt = now
+                        });
+                    }
+                    else
+                    {
+                        enrollment.Status = CourseEnrollmentStatus.Enrolled;
+                        enrollment.EnrolledAt = now;
+                        enrollment.WithdrawnAt = null;
+                        enrollment.EnrollmentType = EnrollmentType.Retake;
+                    }
+                    enrolled++;
+                }
+
+                await db.SaveChangesAsync(cancellationToken);
+                await transaction.CommitAsync(cancellationToken);
+                return Ok(new { EnrolledCount = enrolled });
+            },
+            cancellationToken,
+            IsolationLevel.Serializable);
    }

    [HttpDelete("offerings/{offeringId:guid}/admin-enrollments/{enrollmentId:guid}")]
@@ -824,145 +831,149 @@ public sealed class CourseSelectionsController(
        StudentEnrollmentRequest request,
        CancellationToken cancellationToken)
    {
-        var student = await CurrentStudentAsync(cancellationToken);
-        if (student is null) return ProfileNotFound();
-        if (student.Status != StudentStatus.Active)
-            return ConflictProblem("只有在籍学生可以选课。");
-
-        await using var transaction = await db.Database.BeginTransactionAsync(
-            IsolationLevel.Serializable,
-            cancellationToken);
-        var offering = await db.CourseSelectionOfferings
-            .Include(x => x.CourseSelectionRound)
-            .Include(x => x.TeachingTask)
-            .ThenInclude(x => x!.Course)
-            .Include(x => x.TeachingTask)
-            .ThenInclude(x => x!.Classes)
-            .FirstOrDefaultAsync(x => x.Id == request.OfferingId, cancellationToken);
-        if (offering is null) return NotFound();
-        var round = offering.CourseSelectionRound!;
-        var task = offering.TeachingTask!;
-        var now = DateTime.UtcNow;
-        if (!CourseSelectionRules.IsSelectionOpen(round, now))
-            return ConflictProblem("当前不在该选课批次的开放时间内。");
-        if (task.Status != TeachingTaskStatus.Published)
-            return ConflictProblem("该教学班当前不可选。");
-        if (!offering.IsOpenToAll &&
-            !task.Classes.Any(x =>
-                x.AdministrativeClassId == student.AdministrativeClassId))
-            return Forbid();
-
-        // Detect retake: student previously took the same course in any term
-        var isRetake = await db.CourseEnrollments.AnyAsync(
-            x =>
-                x.StudentId == student.Id &&
-                x.CourseSelectionOffering!.TeachingTask!.CourseId == task.CourseId &&
-                x.CourseSelectionOffering.CourseSelectionRound!.AcademicTermId !=
-                    round.AcademicTermId,
-            cancellationToken);
-
-        var existing = await db.CourseEnrollments.FirstOrDefaultAsync(
-            x =>
-                x.CourseSelectionOfferingId == offering.Id &&
-                x.StudentId == student.Id,
-            cancellationToken);
-        if (existing?.Status == CourseEnrollmentStatus.Enrolled)
-            return ConflictProblem("你已经选择了该教学班。");
-
-        var enrolledCount = await db.CourseEnrollments.CountAsync(
-            x =>
-                x.CourseSelectionOfferingId == offering.Id &&
-                x.Status == CourseEnrollmentStatus.Enrolled,
-            cancellationToken);
-        var effectiveCapacity = isRetake
-            ? CourseSelectionRules.RetakeCapacity(offering.Capacity)
-            : offering.Capacity;
-        if (enrolledCount >= effectiveCapacity)
-            return ConflictProblem("该教学班名额已满。");
-
-        // Normal enrollment: no duplicate course in same term
-        if (!isRetake)
-        {
-            var duplicateCourse = await db.CourseEnrollments.AnyAsync(
-                x =>
-                    x.StudentId == student.Id &&
-                    x.Status == CourseEnrollmentStatus.Enrolled &&
-                    x.CourseSelectionOffering!.TeachingTask!.CourseId == task.CourseId &&
-                    x.CourseSelectionOffering.CourseSelectionRound!.AcademicTermId ==
-                        round.AcademicTermId,
-                cancellationToken);
-            if (duplicateCourse)
-                return ConflictProblem("同一学期不能重复选择相同课程。");
-        }
-
-        // Credit limit check
-        var selectedCredits = await db.CourseEnrollments
-            .Where(x =>
-                x.StudentId == student.Id &&
-                x.Status == CourseEnrollmentStatus.Enrolled &&
-                x.CourseSelectionOffering!.CourseSelectionRoundId == round.Id)
-            .SumAsync(
-                x => (decimal?)x.CourseSelectionOffering!.TeachingTask!.Course!.Credits,
-                cancellationToken) ?? 0;
-        if (selectedCredits + task.Course!.Credits > round.MaxCredits)
-        {
-            return ConflictProblem(
-                $"选课后将达到 {selectedCredits + task.Course.Credits:0.#} 学分，" +
-                $"超过本轮 {round.MaxCredits:0.#} 学分上限。");
-        }
-
-        // Schedule conflict check
-        var candidateEntries = await PublishedScheduleEntries(
-            round.AcademicTermId, [task.Id], cancellationToken);
-        if (CourseSelectionRules.RequiresPublishedSchedule(task.SchedulingMode) &&
-            candidateEntries.Count == 0)
-            return ConflictProblem("该教学班尚未发布课表，暂时不能选课。");
-
-        var selectedTaskIds = await db.CourseEnrollments
-            .Where(x =>
-                x.StudentId == student.Id &&
-                x.Status == CourseEnrollmentStatus.Enrolled &&
-                x.CourseSelectionOffering!.CourseSelectionRound!.AcademicTermId ==
-                    round.AcademicTermId)
-            .Select(x => x.CourseSelectionOffering!.TeachingTaskId)
-            .Distinct()
-            .ToArrayAsync(cancellationToken);
-        var selectedEntries = await PublishedScheduleEntries(
-            round.AcademicTermId, selectedTaskIds, cancellationToken);
-
-        if (CourseSelectionRules.HasScheduleConflict(candidateEntries, selectedEntries))
-        {
-            if (!isRetake)
-                return ConflictProblem("该教学班与已选课程的上课时间冲突。");
-
-            // Retake: allow ≤50% overlap
-            var overlap = CourseSelectionRules.CalculateScheduleOverlap(
-                candidateEntries, selectedEntries);
-            if (overlap > 50)
-                return ConflictProblem(
-                    $"重修课程时间冲突 {overlap:F0}%，超过 50% 上限，无法选课。");
-        }
-
-        if (existing is null)
-        {
-            existing = new CourseEnrollment
+        return await db.ExecuteInRetriableTransactionAsync<ActionResult>(
+            async transaction =>
            {
-                CourseSelectionOfferingId = offering.Id,
-                StudentId = student.Id,
-                EnrollmentType = isRetake ? EnrollmentType.Retake : EnrollmentType.Normal
-            };
-            db.CourseEnrollments.Add(existing);
-        }
-        else
-        {
-            existing.Status = CourseEnrollmentStatus.Enrolled;
-            existing.EnrolledAt = now;
-            existing.WithdrawnAt = null;
-            existing.EnrollmentType = isRetake ? EnrollmentType.Retake : EnrollmentType.Normal;
-        }
-        await db.SaveChangesAsync(cancellationToken);
-        await transaction.CommitAsync(cancellationToken);
-        return Created(string.Empty, new { existing.Id, IsRetake = isRetake });
+                db.ChangeTracker.Clear();
+                var student = await CurrentStudentAsync(cancellationToken);
+                if (student is null) return ProfileNotFound();
+                if (student.Status != StudentStatus.Active)
+                    return ConflictProblem("只有在籍学生可以选课。");
+
+                var offering = await db.CourseSelectionOfferings
+                    .Include(x => x.CourseSelectionRound)
+                    .Include(x => x.TeachingTask)
+                    .ThenInclude(x => x!.Course)
+                    .Include(x => x.TeachingTask)
+                    .ThenInclude(x => x!.Classes)
+                    .FirstOrDefaultAsync(x => x.Id == request.OfferingId, cancellationToken);
+                if (offering is null) return NotFound();
+                var round = offering.CourseSelectionRound!;
+                var task = offering.TeachingTask!;
+                var now = DateTime.UtcNow;
+                if (!CourseSelectionRules.IsSelectionOpen(round, now))
+                    return ConflictProblem("当前不在该选课批次的开放时间内。");
+                if (task.Status != TeachingTaskStatus.Published)
+                    return ConflictProblem("该教学班当前不可选。");
+                if (!offering.IsOpenToAll &&
+                    !task.Classes.Any(x =>
+                        x.AdministrativeClassId == student.AdministrativeClassId))
+                    return Forbid();
+
+                // Detect retake: student previously took the same course in any term
+                var isRetake = await db.CourseEnrollments.AnyAsync(
+                    x =>
+                        x.StudentId == student.Id &&
+                        x.CourseSelectionOffering!.TeachingTask!.CourseId == task.CourseId &&
+                        x.CourseSelectionOffering.CourseSelectionRound!.AcademicTermId !=
+                            round.AcademicTermId,
+                    cancellationToken);
+
+                var existing = await db.CourseEnrollments.FirstOrDefaultAsync(
+                    x =>
+                        x.CourseSelectionOfferingId == offering.Id &&
+                        x.StudentId == student.Id,
+                    cancellationToken);
+                if (existing?.Status == CourseEnrollmentStatus.Enrolled)
+                    return ConflictProblem("你已经选择了该教学班。");
+
+                var enrolledCount = await db.CourseEnrollments.CountAsync(
+                    x =>
+                        x.CourseSelectionOfferingId == offering.Id &&
+                        x.Status == CourseEnrollmentStatus.Enrolled,
+                    cancellationToken);
+                var effectiveCapacity = isRetake
+                    ? CourseSelectionRules.RetakeCapacity(offering.Capacity)
+                    : offering.Capacity;
+                if (enrolledCount >= effectiveCapacity)
+                    return ConflictProblem("该教学班名额已满。");
+
+                // Normal enrollment: no duplicate course in same term
+                if (!isRetake)
+                {
+                    var duplicateCourse = await db.CourseEnrollments.AnyAsync(
+                        x =>
+                            x.StudentId == student.Id &&
+                            x.Status == CourseEnrollmentStatus.Enrolled &&
+                            x.CourseSelectionOffering!.TeachingTask!.CourseId == task.CourseId &&
+                            x.CourseSelectionOffering.CourseSelectionRound!.AcademicTermId ==
+                                round.AcademicTermId,
+                        cancellationToken);
+                    if (duplicateCourse)
+                        return ConflictProblem("同一学期不能重复选择相同课程。");
+                }
+
+                // Credit limit check
+                var selectedCredits = await db.CourseEnrollments
+                    .Where(x =>
+                        x.StudentId == student.Id &&
+                        x.Status == CourseEnrollmentStatus.Enrolled &&
+                        x.CourseSelectionOffering!.CourseSelectionRoundId == round.Id)
+                    .SumAsync(
+                        x => (decimal?)x.CourseSelectionOffering!.TeachingTask!.Course!.Credits,
+                        cancellationToken) ?? 0;
+                if (selectedCredits + task.Course!.Credits > round.MaxCredits)
+                {
+                    return ConflictProblem(
+                        $"选课后将达到 {selectedCredits + task.Course.Credits:0.#} 学分，" +
+                        $"超过本轮 {round.MaxCredits:0.#} 学分上限。");
+                }
+
+                // Schedule conflict check
+                var candidateEntries = await PublishedScheduleEntries(
+                    round.AcademicTermId, [task.Id], cancellationToken);
+                if (CourseSelectionRules.RequiresPublishedSchedule(task.SchedulingMode) &&
+                    candidateEntries.Count == 0)
+                    return ConflictProblem("该教学班尚未发布课表，暂时不能选课。");
+
+                var selectedTaskIds = await db.CourseEnrollments
+                    .Where(x =>
+                        x.StudentId == student.Id &&
+                        x.Status == CourseEnrollmentStatus.Enrolled &&
+                        x.CourseSelectionOffering!.CourseSelectionRound!.AcademicTermId ==
+                            round.AcademicTermId)
+                    .Select(x => x.CourseSelectionOffering!.TeachingTaskId)
+                    .Distinct()
+                    .ToArrayAsync(cancellationToken);
+                var selectedEntries = await PublishedScheduleEntries(
+                    round.AcademicTermId, selectedTaskIds, cancellationToken);
+
+                if (CourseSelectionRules.HasScheduleConflict(candidateEntries, selectedEntries))
+                {
+                    if (!isRetake)
+                        return ConflictProblem("该教学班与已选课程的上课时间冲突。");
+
+                    // Retake: allow ≤50% overlap
+                    var overlap = CourseSelectionRules.CalculateScheduleOverlap(
+                        candidateEntries, selectedEntries);
+                    if (overlap > 50)
+                        return ConflictProblem(
+                            $"重修课程时间冲突 {overlap:F0}%，超过 50% 上限，无法选课。");
+                }
+
+                if (existing is null)
+                {
+                    existing = new CourseEnrollment
+                    {
+                        CourseSelectionOfferingId = offering.Id,
+                        StudentId = student.Id,
+                        EnrollmentType = isRetake ? EnrollmentType.Retake : EnrollmentType.Normal
+                    };
+                    db.CourseEnrollments.Add(existing);
+                }
+                else
+                {
+                    existing.Status = CourseEnrollmentStatus.Enrolled;
+                    existing.EnrolledAt = now;
+                    existing.WithdrawnAt = null;
+                    existing.EnrollmentType = isRetake ? EnrollmentType.Retake : EnrollmentType.Normal;
+                }
+                await db.SaveChangesAsync(cancellationToken);
+                await transaction.CommitAsync(cancellationToken);
+                return Created(string.Empty, new { existing.Id, IsRetake = isRetake });
+            },
+            cancellationToken,
+            IsolationLevel.Serializable);
    }

    [HttpDelete("student/enrollments/{id:guid}")]
@@ -1159,9 +1170,9 @@ public sealed class CourseSelectionsController(
        if (taskIds.Count == 0) return [];
        return await db.ScheduleEntries.AsNoTracking()
            .Where(x =>
-                taskIds.Contains(x.TeachingTaskId) &&
                x.SchedulePlan!.AcademicTermId == academicTermId &&
                x.SchedulePlan.Status == SchedulePlanStatus.Published)
+            .WhereIn(taskIds, x => x.TeachingTaskId)
            .ToListAsync(cancellationToken);
    }