补考系统

2026-07-25 19:16:11 +08:00
parent 376bc0d0a1
commit 44e90ae35f
12 changed files with 1765 additions and 2 deletions
@@ -0,0 +1,217 @@
+using Jiaowu.Api.Domain.Academic;
+using Jiaowu.Api.Infrastructure.Persistence;
+using Microsoft.EntityFrameworkCore;
+
+namespace Jiaowu.Api.Infrastructure.Exams;
+
+public sealed class MakeupExamArrangementService(AppDbContext db)
+{
+    private sealed record RoomOccupancy(Guid ClassroomId, DateTime StartsAt, DateTime EndsAt);
+    private sealed record InvigilatorOccupancy(Guid TeacherId, DateTime StartsAt, DateTime EndsAt);
+
+    public async Task<ExamArrangementResult> ArrangeAsync(
+        Guid planId,
+        CancellationToken cancellationToken)
+    {
+        var plan = await db.MakeupExamPlans
+            .Include(x => x.AcademicTerm)
+            .Include(x => x.Sessions)
+                .ThenInclude(x => x.Invigilators)
+            .Include(x => x.Sessions)
+                .ThenInclude(x => x.TeachingTask)
+                    .ThenInclude(x => x!.Teachers)
+            .FirstOrDefaultAsync(x => x.Id == planId, cancellationToken);
+
+        if (plan is null)
+            return ExamArrangementResult.Fail("补考计划不存在。");
+        if (plan.Status != MakeupExamPlanStatus.Draft)
+            return ExamArrangementResult.Fail("只有草稿状态的补考计划可以自动编排。");
+
+        var sessions = plan.Sessions.ToList();
+        if (sessions.Count == 0)
+            return ExamArrangementResult.Fail("补考计划中没有场次。");
+
+        var termId = plan.AcademicTermId;
+        var timeSlots = await db.ScheduleTimeSlots.AsNoTracking()
+            .Where(x => x.AcademicTermId == termId && x.IsEnabled)
+            .OrderBy(x => x.PeriodNumber)
+            .ToListAsync(cancellationToken);
+
+        if (timeSlots.Count == 0)
+            return ExamArrangementResult.Fail("当前学期未配置上课时间表，无法计算考试时间段。");
+
+        var timeSlotLookup = timeSlots.ToDictionary(x => x.PeriodNumber);
+
+        int assignedRooms = 0;
+        int assignedInvigilators = 0;
+        int skippedRooms = 0;
+        int skippedInvigilators = 0;
+        var messages = new List<string>();
+
+        var occupiedRooms = sessions
+            .Where(x => x.ClassroomId.HasValue)
+            .Select(x => new RoomOccupancy(x.ClassroomId!.Value, x.StartsAt, x.EndsAt))
+            .ToList();
+
+        var occupiedInvigilators = sessions
+            .SelectMany(x => x.Invigilators.Select(i =>
+                new InvigilatorOccupancy(i.TeacherId, x.StartsAt, x.EndsAt)))
+            .ToList();
+
+        foreach (var session in sessions)
+        {
+            ComputeTimesFromSlots(session, timeSlotLookup);
+
+            var enrolledCount = await db.MakeupExamEnrollments
+                .CountAsync(x => x.MakeupExamSessionId == session.Id, cancellationToken);
+
+            // Auto-assign classroom
+            if (!session.ClassroomId.HasValue)
+            {
+                var room = await FindBestClassroomAsync(
+                    session, enrolledCount, occupiedRooms, cancellationToken);
+                if (room is not null)
+                {
+                    session.ClassroomId = room.Id;
+                    occupiedRooms.Add(new RoomOccupancy(room.Id, session.StartsAt, session.EndsAt));
+                    assignedRooms++;
+                    messages.Add(
+                        $"\"{session.TeachingTask!.Course!.Name}\"→{room.Name}({room.Capacity}座)");
+                }
+                else
+                {
+                    skippedRooms++;
+                    messages.Add(
+                        $"\"{session.TeachingTask!.Course!.Name}\"：无可用考场（需≥{enrolledCount}座）");
+                }
+            }
+            else
+            {
+                skippedRooms++;
+            }
+
+            // Auto-assign invigilators
+            var currentInvigilatorCount = session.Invigilators.Count;
+            var needed = session.RequiredInvigilatorCount - currentInvigilatorCount;
+            if (needed > 0)
+            {
+                var courseTeacherIds = session.TeachingTask!.Teachers
+                    .Select(x => x.TeacherId).ToHashSet();
+                var newlyAssigned = await FindInvigilatorsAsync(
+                    session, needed, courseTeacherIds,
+                    occupiedInvigilators, cancellationToken);
+                foreach (var teacher in newlyAssigned)
+                {
+                    session.Invigilators.Add(new MakeupExamSessionInvigilator
+                    {
+                        MakeupExamSessionId = session.Id,
+                        TeacherId = teacher.Id
+                    });
+                    occupiedInvigilators.Add(new InvigilatorOccupancy(
+                        teacher.Id, session.StartsAt, session.EndsAt));
+                    assignedInvigilators++;
+                }
+
+                if (newlyAssigned.Count < needed)
+                    messages.Add(
+                        $"\"{session.TeachingTask!.Course!.Name}\"：仅找到{newlyAssigned.Count}/{needed}名监考教师");
+            }
+            else
+            {
+                skippedInvigilators++;
+            }
+        }
+
+        await db.SaveChangesAsync(cancellationToken);
+
+        return new ExamArrangementResult(
+            true,
+            $"{assignedRooms}个考场、{assignedInvigilators}名监考已分配。" +
+            (skippedRooms > 0 ? $" {skippedRooms}个场次无可用考场。" : "") +
+            (messages.Count > 0 ? $" 详情：{string.Join("；", messages.Take(10))}" : ""));
+    }
+
+    private static void ComputeTimesFromSlots(
+        MakeupExamSession session,
+        Dictionary<int, ScheduleTimeSlot> timeSlotLookup)
+    {
+        var startSlot = timeSlotLookup.GetValueOrDefault(session.StartPeriod);
+        var endSlot = timeSlotLookup.GetValueOrDefault(
+            session.StartPeriod + session.PeriodCount - 1);
+        if (startSlot is null || endSlot is null) return;
+
+        var examDate = session.ExamDate;
+        session.StartsAt = examDate.ToDateTime(startSlot.StartsAt, DateTimeKind.Utc);
+        session.EndsAt = examDate.ToDateTime(endSlot.EndsAt, DateTimeKind.Utc);
+    }
+
+    private async Task<Classroom?> FindBestClassroomAsync(
+        MakeupExamSession session,
+        int enrolledCount,
+        List<RoomOccupancy> occupied,
+        CancellationToken cancellationToken)
+    {
+        var query = db.Classrooms.AsNoTracking()
+            .Where(x => x.IsEnabled && x.Capacity >= enrolledCount);
+
+        if (session.RequiredBuildingId.HasValue)
+            query = query.Where(x => x.BuildingId == session.RequiredBuildingId.Value);
+
+        var occupiedRoomIds = occupied
+            .Where(x => ExamConflictRules.TimeOverlaps(
+                x.StartsAt, x.EndsAt, session.StartsAt, session.EndsAt))
+            .Select(x => x.ClassroomId)
+            .ToHashSet();
+
+        if (occupiedRoomIds.Count > 0)
+            query = query.Where(x => !occupiedRoomIds.Contains(x.Id));
+
+        var dbOccupiedRooms = await db.MakeupExamSessions.AsNoTracking()
+            .Where(x => x.MakeupExamPlanId == session.MakeupExamPlanId &&
+                        x.Id != session.Id &&
+                        x.ClassroomId != null &&
+                        x.StartsAt < session.EndsAt &&
+                        session.StartsAt < x.EndsAt)
+            .Select(x => x.ClassroomId!.Value)
+            .ToListAsync(cancellationToken);
+
+        if (dbOccupiedRooms.Count > 0)
+            query = query.Where(x => !dbOccupiedRooms.Contains(x.Id));
+
+        return await query
+            .OrderBy(x => x.Capacity)
+            .FirstOrDefaultAsync(cancellationToken);
+    }
+
+    private async Task<List<Teacher>> FindInvigilatorsAsync(
+        MakeupExamSession session,
+        int needed,
+        HashSet<Guid> excludeTeacherIds,
+        List<InvigilatorOccupancy> occupied,
+        CancellationToken cancellationToken)
+    {
+        var busyTeacherIds = occupied
+            .Where(x => ExamConflictRules.TimeOverlaps(
+                x.StartsAt, x.EndsAt, session.StartsAt, session.EndsAt))
+            .Select(x => x.TeacherId)
+            .ToHashSet();
+
+        var dbBusyIds = await db.MakeupExamSessionInvigilators.AsNoTracking()
+            .Where(x => x.MakeupExamSession!.MakeupExamPlanId == session.MakeupExamPlanId &&
+                        x.MakeupExamSessionId != session.Id &&
+                        x.MakeupExamSession!.StartsAt < session.EndsAt &&
+                        session.StartsAt < x.MakeupExamSession.EndsAt)
+            .Select(x => x.TeacherId)
+            .ToListAsync(cancellationToken);
+
+        foreach (var id in dbBusyIds) busyTeacherIds.Add(id);
+        foreach (var id in excludeTeacherIds) busyTeacherIds.Add(id);
+
+        return await db.Teachers.AsNoTracking()
+            .Where(x => x.Status == TeacherStatus.Active &&
+                        !busyTeacherIds.Contains(x.Id))
+            .OrderBy(x => Guid.NewGuid())
+            .Take(needed)
+            .ToListAsync(cancellationToken);
+    }
+}
@@ -0,0 +1,125 @@
+using Jiaowu.Api.Domain.Academic;
+using Jiaowu.Api.Infrastructure.Persistence;
+using Microsoft.EntityFrameworkCore;
+
+namespace Jiaowu.Api.Infrastructure.Exams;
+
+public sealed class MakeupExamEligibilityService(AppDbContext db)
+{
+    public async Task<List<EligibleStudent>> GetEligibleStudentsAsync(
+        Guid teachingTaskId,
+        CancellationToken cancellationToken)
+    {
+        var gradeSheet = await db.GradeSheets.AsNoTracking()
+            .Where(x => x.TeachingTaskId == teachingTaskId)
+            .Select(x => new { x.Id, x.TeachingTask!.AcademicTermId })
+            .FirstOrDefaultAsync(cancellationToken);
+
+        if (gradeSheet is null)
+            return [];
+
+        // Find students already enrolled in any makeup session for this teaching task
+        var alreadyEnrolledIds = await db.MakeupExamEnrollments.AsNoTracking()
+            .Where(x => x.MakeupExamSession!.TeachingTaskId == teachingTaskId &&
+                        x.MakeupExamSession!.MakeupExamPlan!.Status != MakeupExamPlanStatus.Archived)
+            .Select(x => x.StudentId)
+            .Distinct()
+            .ToListAsync(cancellationToken);
+
+        var enrolledSet = alreadyEnrolledIds.ToHashSet();
+        var results = new Dictionary<Guid, EligibleStudent>();
+
+        // 1. Approved deferred exams (highest priority)
+        var deferredStudents = await db.DeferredExams.AsNoTracking()
+            .Where(x => x.TeachingTaskId == teachingTaskId &&
+                        x.Status == ApprovalStatus.Approved &&
+                        !enrolledSet.Contains(x.StudentId))
+            .Select(x => new
+            {
+                x.StudentId,
+                x.Student!.StudentNumber,
+                x.Student.Name,
+                ClassName = x.Student.AdministrativeClass!.Name,
+                x.Id
+            })
+            .ToListAsync(cancellationToken);
+
+        foreach (var s in deferredStudents)
+        {
+            if (!results.ContainsKey(s.StudentId))
+            {
+                results[s.StudentId] = new EligibleStudent(
+                    s.StudentId, s.StudentNumber, s.Name, s.ClassName,
+                    MakeupReason.DeferredApproved, null,
+                    SourceDeferredExamId: s.Id);
+            }
+        }
+
+        // 2. Absent students
+        var absentStudents = await db.GradeRecords.AsNoTracking()
+            .Where(x => x.GradeSheetId == gradeSheet.Id &&
+                        x.ExamStatus == GradeExamStatus.Absent &&
+                        !enrolledSet.Contains(x.StudentId))
+            .Select(x => new
+            {
+                x.StudentId,
+                x.Student!.StudentNumber,
+                x.Student.Name,
+                ClassName = x.Student.AdministrativeClass!.Name,
+                GradeRecordId = (Guid?)x.Id
+            })
+            .ToListAsync(cancellationToken);
+
+        foreach (var s in absentStudents)
+        {
+            if (!results.ContainsKey(s.StudentId))
+            {
+                results[s.StudentId] = new EligibleStudent(
+                    s.StudentId, s.StudentNumber, s.Name, s.ClassName,
+                    MakeupReason.Absent, null,
+                    SourceGradeRecordId: s.GradeRecordId);
+            }
+        }
+
+        // 3. Failed students (TotalScore < 60, Normal status)
+        var failedStudents = await db.GradeRecords.AsNoTracking()
+            .Where(x => x.GradeSheetId == gradeSheet.Id &&
+                        x.ExamStatus == GradeExamStatus.Normal &&
+                        x.TotalScore < 60 &&
+                        !enrolledSet.Contains(x.StudentId))
+            .Select(x => new
+            {
+                x.StudentId,
+                x.Student!.StudentNumber,
+                x.Student.Name,
+                ClassName = x.Student.AdministrativeClass!.Name,
+                x.TotalScore,
+                GradeRecordId = (Guid?)x.Id
+            })
+            .ToListAsync(cancellationToken);
+
+        foreach (var s in failedStudents)
+        {
+            if (!results.ContainsKey(s.StudentId))
+            {
+                results[s.StudentId] = new EligibleStudent(
+                    s.StudentId, s.StudentNumber, s.Name, s.ClassName,
+                    MakeupReason.Failed, s.TotalScore,
+                    SourceGradeRecordId: s.GradeRecordId);
+            }
+        }
+
+        return [.. results.Values.OrderBy(x => x.StudentNumber)];
+    }
+}
+
+public sealed record EligibleStudent(
+    Guid StudentId,
+    string StudentNumber,
+    string Name,
+    string ClassName,
+    MakeupReason Reason,
+    decimal? TotalScore = null,
+    Guid? SourceGradeRecordId = null,
+    Guid? SourceDeferredExamId = null,
+    string? Detail = null);