872 lines
34 KiB
C#
872 lines
34 KiB
C#
using System.ComponentModel.DataAnnotations;
|
|
using Jiaowu.Api.Domain.Academic;
|
|
using Jiaowu.Api.Domain.Identity;
|
|
using Jiaowu.Api.Infrastructure.Auth;
|
|
using Jiaowu.Api.Infrastructure.Persistence;
|
|
using Jiaowu.Api.Infrastructure.Scheduling;
|
|
using Jiaowu.Api.Infrastructure.Teaching;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.EntityFrameworkCore;
|
|
|
|
namespace Jiaowu.Api.Controllers;
|
|
|
|
[ApiController]
|
|
[Authorize]
|
|
[Route("api/course-adjustments")]
|
|
public sealed class CourseAdjustmentsController(
|
|
AppDbContext db,
|
|
ICurrentUserDataScope currentUserDataScope) : ControllerBase
|
|
{
|
|
private const string Applicants =
|
|
SystemRoles.SuperAdmin + "," +
|
|
SystemRoles.AcademicAdmin + "," +
|
|
SystemRoles.CollegeAdmin + "," +
|
|
SystemRoles.Teacher;
|
|
|
|
private const string Reviewers =
|
|
SystemRoles.SuperAdmin + "," +
|
|
SystemRoles.AcademicAdmin + "," +
|
|
SystemRoles.CollegeAdmin;
|
|
|
|
[HttpGet("task-options")]
|
|
[Authorize(Roles = Applicants)]
|
|
public async Task<ActionResult> GetTaskOptions(
|
|
Guid? academicTermId,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var source = AccessibleTeachingTasks().AsNoTracking()
|
|
.Where(x => x.Status == TeachingTaskStatus.Published);
|
|
if (academicTermId.HasValue)
|
|
source = source.Where(x => x.AcademicTermId == academicTermId);
|
|
|
|
return Ok(await source
|
|
.OrderByDescending(x => x.AcademicTerm!.StartDate)
|
|
.ThenBy(x => x.Course!.Code)
|
|
.ThenBy(x => x.TaskNumber)
|
|
.Select(x => new
|
|
{
|
|
x.Id,
|
|
x.TaskNumber,
|
|
x.Name,
|
|
x.AcademicTermId,
|
|
TermName = x.AcademicTerm!.Name,
|
|
CourseCode = x.Course!.Code,
|
|
CourseName = x.Course.Name,
|
|
ClassNames = x.Classes
|
|
.OrderBy(item => item.AdministrativeClass!.Code)
|
|
.Select(item => item.AdministrativeClass!.Name)
|
|
})
|
|
.ToListAsync(cancellationToken));
|
|
}
|
|
|
|
[HttpGet("tasks/{teachingTaskId:guid}/session-options")]
|
|
[Authorize(Roles = Applicants)]
|
|
public async Task<ActionResult> GetSessionOptions(
|
|
Guid teachingTaskId,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var task = await AccessibleTeachingTasks().AsNoTracking()
|
|
.Where(x =>
|
|
x.Id == teachingTaskId &&
|
|
x.Status == TeachingTaskStatus.Published)
|
|
.Select(x => new
|
|
{
|
|
x.Id,
|
|
x.TaskNumber,
|
|
CourseName = x.Course!.Name,
|
|
x.AcademicTermId,
|
|
TermStartDate = x.AcademicTerm!.StartDate,
|
|
TermEndDate = x.AcademicTerm.EndDate
|
|
})
|
|
.FirstOrDefaultAsync(cancellationToken);
|
|
if (task is null) return NotFound();
|
|
|
|
var entries = await db.ScheduleEntries.AsNoTracking()
|
|
.Where(x =>
|
|
x.TeachingTaskId == teachingTaskId &&
|
|
x.SchedulePlan!.Status == SchedulePlanStatus.Published)
|
|
.OrderBy(x => x.DayOfWeek)
|
|
.ThenBy(x => x.StartPeriod)
|
|
.Select(x => new
|
|
{
|
|
x.Id,
|
|
x.DayOfWeek,
|
|
x.StartPeriod,
|
|
x.PeriodCount,
|
|
x.StartWeek,
|
|
x.EndWeek,
|
|
x.WeekPattern,
|
|
x.ClassroomId,
|
|
ClassroomName = x.Classroom != null ? x.Classroom.Name : null,
|
|
BuildingName = x.Classroom != null ? x.Classroom.Building!.Name : null
|
|
})
|
|
.ToListAsync(cancellationToken);
|
|
|
|
var occupied = await db.CourseAdjustments.AsNoTracking()
|
|
.Where(x =>
|
|
x.TeachingTaskId == teachingTaskId &&
|
|
x.SourceScheduleEntryId != null &&
|
|
x.SourceWeek != null &&
|
|
(x.Status == CourseAdjustmentStatus.Submitted ||
|
|
x.Status == CourseAdjustmentStatus.Approved))
|
|
.Select(x => new { x.SourceScheduleEntryId, x.SourceWeek })
|
|
.ToListAsync(cancellationToken);
|
|
var occupiedOccurrences = occupied
|
|
.Select(x => (x.SourceScheduleEntryId!.Value, x.SourceWeek!.Value))
|
|
.ToHashSet();
|
|
|
|
var sessions = entries
|
|
.SelectMany(entry => Enumerable.Range(
|
|
entry.StartWeek,
|
|
entry.EndWeek - entry.StartWeek + 1)
|
|
.Where(week => IncludesWeek(entry.WeekPattern, week))
|
|
.Select(week => new
|
|
{
|
|
ScheduleEntryId = entry.Id,
|
|
Week = week,
|
|
Date = ResolveDate(task.TermStartDate, week, entry.DayOfWeek),
|
|
entry.DayOfWeek,
|
|
entry.StartPeriod,
|
|
entry.PeriodCount,
|
|
entry.ClassroomId,
|
|
entry.ClassroomName,
|
|
entry.BuildingName,
|
|
HasExistingAdjustment = occupiedOccurrences.Contains((entry.Id, week))
|
|
}))
|
|
.Where(x => x.Date >= task.TermStartDate && x.Date <= task.TermEndDate)
|
|
.OrderBy(x => x.Date)
|
|
.ThenBy(x => x.StartPeriod)
|
|
.ToList();
|
|
|
|
var classrooms = await db.Classrooms.AsNoTracking()
|
|
.Where(x => x.IsEnabled)
|
|
.OrderBy(x => x.Building!.Campus!.SortOrder)
|
|
.ThenBy(x => x.Building!.SortOrder)
|
|
.ThenBy(x => x.SortOrder)
|
|
.Select(x => new
|
|
{
|
|
x.Id,
|
|
x.Name,
|
|
BuildingName = x.Building!.Name,
|
|
CampusName = x.Building.Campus!.Name,
|
|
x.Capacity
|
|
})
|
|
.ToListAsync(cancellationToken);
|
|
var periods = await db.ScheduleTimeSlots.AsNoTracking()
|
|
.Where(x => x.AcademicTermId == task.AcademicTermId && x.IsEnabled)
|
|
.OrderBy(x => x.PeriodNumber)
|
|
.Select(x => new
|
|
{
|
|
x.PeriodNumber,
|
|
x.Name,
|
|
StartsAt = x.StartsAt.ToString("HH:mm"),
|
|
EndsAt = x.EndsAt.ToString("HH:mm")
|
|
})
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Ok(new { Task = task, Sessions = sessions, Classrooms = classrooms, Periods = periods });
|
|
}
|
|
|
|
// ═══════════════ My adjustments ═══════════════
|
|
|
|
[HttpGet("mine")]
|
|
[Authorize(Roles = Applicants)]
|
|
public async Task<ActionResult> GetMine(
|
|
Guid? academicTermId,
|
|
CourseAdjustmentStatus? status,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var userId = currentUserDataScope.Current.UserId;
|
|
var source = db.CourseAdjustments.AsNoTracking()
|
|
.Where(x => x.ApplicantUserId == userId);
|
|
if (academicTermId.HasValue)
|
|
source = source.Where(x =>
|
|
x.TeachingTask!.AcademicTermId == academicTermId);
|
|
if (status.HasValue)
|
|
source = source.Where(x => x.Status == status);
|
|
|
|
return Ok(await source
|
|
.OrderByDescending(x => x.CreatedAt)
|
|
.Select(AdjustmentProjection())
|
|
.ToListAsync(cancellationToken));
|
|
}
|
|
|
|
// ═══════════════ Pending reviews ═══════════════
|
|
|
|
[HttpGet("pending-reviews")]
|
|
[Authorize(Roles = Reviewers)]
|
|
public async Task<ActionResult> GetPendingReviews(
|
|
Guid? academicTermId,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var scope = currentUserDataScope.Current;
|
|
var source = db.CourseAdjustments.AsNoTracking()
|
|
.Where(x => x.Status == CourseAdjustmentStatus.Submitted);
|
|
if (scope.Scope == DataScope.College)
|
|
source = source.Where(x =>
|
|
x.TeachingTask!.Course!.CollegeId == scope.RestrictedCollegeId);
|
|
if (academicTermId.HasValue)
|
|
source = source.Where(x =>
|
|
x.TeachingTask!.AcademicTermId == academicTermId);
|
|
|
|
return Ok(await source
|
|
.OrderByDescending(x => x.SubmittedAt)
|
|
.Select(AdjustmentProjection())
|
|
.ToListAsync(cancellationToken));
|
|
}
|
|
|
|
// ═══════════════ Detail ═══════════════
|
|
|
|
[HttpGet("{id:guid}")]
|
|
[Authorize(Roles = Applicants)]
|
|
public async Task<ActionResult> GetDetail(Guid id, CancellationToken cancellationToken)
|
|
{
|
|
var adj = await db.CourseAdjustments.AsNoTracking()
|
|
.Where(x => x.Id == id)
|
|
.Select(AdjustmentProjection())
|
|
.FirstOrDefaultAsync(cancellationToken);
|
|
return adj is null ? NotFound() : Ok(adj);
|
|
}
|
|
|
|
// ═══════════════ Create ═══════════════
|
|
|
|
[HttpPost]
|
|
[Authorize(Roles = Applicants)]
|
|
public async Task<ActionResult> Create(
|
|
CourseAdjustmentRequest request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var userId = currentUserDataScope.Current.UserId;
|
|
var validation = await ValidateRequestAsync(request, cancellationToken);
|
|
if (validation is not null) return validation;
|
|
|
|
var source = RequiresSourceOccurrence(request.Type)
|
|
? await LoadSourceOccurrenceAsync(
|
|
request.TeachingTaskId,
|
|
request.SourceScheduleEntryId,
|
|
request.SourceWeek,
|
|
cancellationToken)
|
|
: null;
|
|
var targetDayOfWeek = request.TargetDate.HasValue
|
|
? ToIsoDayOfWeek(request.TargetDate.Value.DayOfWeek)
|
|
: request.DayOfWeek;
|
|
|
|
var adj = new CourseAdjustment
|
|
{
|
|
TeachingTaskId = request.TeachingTaskId,
|
|
Type = request.Type,
|
|
ApplicantUserId = userId,
|
|
Reason = request.Reason.Trim(),
|
|
SourceScheduleEntryId = source?.Entry.Id,
|
|
SourceWeek = source?.Week,
|
|
SourceDate = source?.Date,
|
|
SourceStartPeriod = source?.Entry.StartPeriod,
|
|
SourcePeriodCount = source?.Entry.PeriodCount,
|
|
SourceClassroomId = source?.Entry.ClassroomId,
|
|
TargetDate = request.TargetDate,
|
|
DayOfWeek = targetDayOfWeek,
|
|
StartPeriod = request.StartPeriod,
|
|
PeriodCount = source?.Entry.PeriodCount ?? request.PeriodCount,
|
|
ClassroomId = request.ClassroomId,
|
|
SubstituteTeacherId = request.SubstituteTeacherId,
|
|
CancelWeek = request.Type == CourseAdjustmentType.Cancel
|
|
? source?.Week
|
|
: request.CancelWeek,
|
|
CancelDate = request.Type == CourseAdjustmentType.Cancel
|
|
? source?.Date
|
|
: request.CancelDate
|
|
};
|
|
|
|
if (request.Submit)
|
|
{
|
|
adj.Status = CourseAdjustmentStatus.Submitted;
|
|
adj.SubmittedAt = DateTime.UtcNow;
|
|
}
|
|
|
|
db.CourseAdjustments.Add(adj);
|
|
await db.SaveChangesAsync(cancellationToken);
|
|
|
|
if (request.Submit)
|
|
{
|
|
var taskInfo = await db.TeachingTasks
|
|
.Where(x => x.Id == request.TeachingTaskId)
|
|
.Select(x => new { x.Course!.Name, x.Course.CollegeId })
|
|
.FirstOrDefaultAsync(cancellationToken);
|
|
if (taskInfo is not null)
|
|
{
|
|
var tl = TypeLabel(request.Type);
|
|
await NotificationService.SendToRoleAsync(db,
|
|
SystemRoles.CollegeAdmin,
|
|
$"新的{tl}申请",
|
|
$"《{taskInfo.Name}》提交了{tl}申请，请及时审核。",
|
|
taskInfo.CollegeId, "/course-adjustments", cancellationToken,
|
|
NotificationCategory.Schedule);
|
|
}
|
|
}
|
|
|
|
return Created(string.Empty, new { adj.Id });
|
|
}
|
|
|
|
// ═══════════════ Submit ═══════════════
|
|
|
|
[HttpPost("{id:guid}/submit")]
|
|
[Authorize(Roles = Applicants)]
|
|
public async Task<ActionResult> Submit(Guid id, CancellationToken cancellationToken)
|
|
{
|
|
var userId = currentUserDataScope.Current.UserId;
|
|
var adj = await db.CourseAdjustments
|
|
.Include(x => x.TeachingTask)
|
|
.ThenInclude(x => x!.Course)
|
|
.FirstOrDefaultAsync(x =>
|
|
x.Id == id && x.ApplicantUserId == userId, cancellationToken);
|
|
if (adj is null) return NotFound();
|
|
if (adj.Status != CourseAdjustmentStatus.Draft)
|
|
return ConflictProblem("只有草稿可以提交。");
|
|
|
|
var validation = await ValidateRequestAsync(
|
|
new CourseAdjustmentRequest(
|
|
adj.TeachingTaskId,
|
|
adj.Type,
|
|
adj.Reason,
|
|
true,
|
|
adj.TargetDate,
|
|
adj.DayOfWeek,
|
|
adj.StartPeriod,
|
|
adj.PeriodCount,
|
|
adj.ClassroomId,
|
|
adj.SubstituteTeacherId,
|
|
adj.CancelWeek,
|
|
adj.CancelDate,
|
|
adj.SourceScheduleEntryId,
|
|
adj.SourceWeek),
|
|
cancellationToken);
|
|
if (validation is not null) return validation;
|
|
|
|
adj.Status = CourseAdjustmentStatus.Submitted;
|
|
adj.SubmittedAt = DateTime.UtcNow;
|
|
await db.SaveChangesAsync(cancellationToken);
|
|
|
|
var courseName = adj.TeachingTask!.Course!.Name;
|
|
await NotificationService.SendToRoleAsync(db,
|
|
SystemRoles.CollegeAdmin,
|
|
$"新的{TypeLabel(adj.Type)}申请",
|
|
$"《{courseName}》提交了{TypeLabel(adj.Type)}申请，请及时审核。",
|
|
adj.TeachingTask.Course.CollegeId,
|
|
"/course-adjustments", cancellationToken,
|
|
NotificationCategory.Schedule);
|
|
await NotificationService.SendToRoleAsync(db,
|
|
SystemRoles.AcademicAdmin,
|
|
$"新的{TypeLabel(adj.Type)}申请",
|
|
$"《{courseName}》提交了{TypeLabel(adj.Type)}申请。",
|
|
null, "/course-adjustments", cancellationToken,
|
|
NotificationCategory.Schedule);
|
|
return NoContent();
|
|
}
|
|
|
|
// ═══════════════ Approve ═══════════════
|
|
|
|
[HttpPost("{id:guid}/approve")]
|
|
[Authorize(Roles = Reviewers)]
|
|
public async Task<ActionResult> Approve(Guid id, CancellationToken cancellationToken)
|
|
{
|
|
var adj = await db.CourseAdjustments
|
|
.Include(x => x.TeachingTask)
|
|
.ThenInclude(x => x!.Course)
|
|
.ThenInclude(x => x!.College)
|
|
.Include(x => x.TeachingTask)
|
|
.ThenInclude(x => x!.Teachers)
|
|
.Include(x => x.TeachingTask)
|
|
.ThenInclude(x => x!.Classes)
|
|
.Include(x => x.TeachingTask)
|
|
.ThenInclude(x => x!.AcademicTerm)
|
|
.FirstOrDefaultAsync(x => x.Id == id, cancellationToken);
|
|
if (adj is null) return NotFound();
|
|
|
|
var scope = currentUserDataScope.Current;
|
|
if (scope.Scope == DataScope.College &&
|
|
adj.TeachingTask!.Course!.CollegeId != scope.RestrictedCollegeId)
|
|
return ConflictProblem("只能审核本学院课程的调停课申请。");
|
|
if (adj.Status != CourseAdjustmentStatus.Submitted)
|
|
return ConflictProblem("只有待审核的申请可以审批。");
|
|
|
|
var scheduleProblem = await ValidateApprovalScheduleAsync(
|
|
adj,
|
|
cancellationToken);
|
|
if (scheduleProblem is not null)
|
|
return ConflictProblem(scheduleProblem);
|
|
|
|
adj.Status = CourseAdjustmentStatus.Approved;
|
|
adj.ReviewedAt = DateTime.UtcNow;
|
|
adj.ReviewedByUserId = currentUserDataScope.Current.UserId;
|
|
|
|
// Apply schedule changes
|
|
await ApplyScheduleChangesAsync(adj, cancellationToken);
|
|
|
|
await db.SaveChangesAsync(cancellationToken);
|
|
|
|
// Notify applicant
|
|
await NotificationService.SendAsync(db, adj.ApplicantUserId,
|
|
"调停课申请已通过",
|
|
$"您的{TypeLabel(adj.Type)}申请（{adj.TeachingTask!.Course!.Name}）已通过审核。",
|
|
"/course-adjustments", cancellationToken,
|
|
NotificationCategory.Schedule);
|
|
|
|
// Notify affected students
|
|
var studentUserIds = await TeachingTaskRosterQuery
|
|
.ForTask(db, adj.TeachingTaskId)
|
|
.Select(x => x.UserId)
|
|
.Where(uid => uid != null)
|
|
.Select(uid => uid!.Value)
|
|
.Distinct()
|
|
.ToListAsync(cancellationToken);
|
|
if (studentUserIds.Count > 0)
|
|
{
|
|
await NotificationService.SendToUserIdsAsync(db, studentUserIds,
|
|
"课程变动通知",
|
|
$"《{adj.TeachingTask.Course.Name}》有{TypeLabel(adj.Type)}变动，请查看课表。",
|
|
"/my-timetable", cancellationToken,
|
|
NotificationCategory.Schedule);
|
|
}
|
|
|
|
return NoContent();
|
|
}
|
|
|
|
private async Task ApplyScheduleChangesAsync(
|
|
CourseAdjustment adj, CancellationToken ct)
|
|
{
|
|
switch (adj.Type)
|
|
{
|
|
case CourseAdjustmentType.Reschedule:
|
|
var rescheduleSource = await LoadSourceEntryAsync(adj, ct);
|
|
ExcludeWeek(rescheduleSource, adj.SourceWeek!.Value);
|
|
db.ScheduleEntries.Add(CreateTargetEntry(adj, rescheduleSource.SchedulePlanId));
|
|
break;
|
|
|
|
case CourseAdjustmentType.Cancel:
|
|
var cancelSource = await LoadSourceEntryAsync(adj, ct);
|
|
ExcludeWeek(cancelSource, adj.SourceWeek!.Value);
|
|
break;
|
|
|
|
case CourseAdjustmentType.Makeup:
|
|
var makeupSource = await LoadSourceEntryAsync(adj, ct);
|
|
db.ScheduleEntries.Add(CreateTargetEntry(adj, makeupSource.SchedulePlanId));
|
|
break;
|
|
|
|
case CourseAdjustmentType.Substitute:
|
|
// Substitute: add substitute teacher to the teaching task
|
|
if (adj.SubstituteTeacherId.HasValue)
|
|
{
|
|
var alreadyExists = await db.TeachingTaskTeachers
|
|
.AnyAsync(x =>
|
|
x.TeachingTaskId == adj.TeachingTaskId &&
|
|
x.TeacherId == adj.SubstituteTeacherId.Value, ct);
|
|
if (!alreadyExists)
|
|
{
|
|
db.TeachingTaskTeachers.Add(new TeachingTaskTeacher
|
|
{
|
|
TeachingTaskId = adj.TeachingTaskId,
|
|
TeacherId = adj.SubstituteTeacherId.Value,
|
|
IsPrimary = false
|
|
});
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
private static string TypeLabel(CourseAdjustmentType type) => type switch
|
|
{
|
|
CourseAdjustmentType.Reschedule => "调课",
|
|
CourseAdjustmentType.Cancel => "停课",
|
|
CourseAdjustmentType.Makeup => "补课",
|
|
CourseAdjustmentType.Substitute => "代课",
|
|
_ => "调停课"
|
|
};
|
|
|
|
// ═══════════════ Reject ═══════════════
|
|
|
|
[HttpPost("{id:guid}/reject")]
|
|
[Authorize(Roles = Reviewers)]
|
|
public async Task<ActionResult> Reject(
|
|
Guid id,
|
|
RejectionRequest request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var adj = await db.CourseAdjustments
|
|
.Include(x => x.TeachingTask)
|
|
.ThenInclude(x => x!.Course)
|
|
.FirstOrDefaultAsync(x => x.Id == id, cancellationToken);
|
|
if (adj is null) return NotFound();
|
|
|
|
var scope = currentUserDataScope.Current;
|
|
if (scope.Scope == DataScope.College &&
|
|
adj.TeachingTask!.Course!.CollegeId != scope.RestrictedCollegeId)
|
|
return ConflictProblem("只能审核本学院课程的调停课申请。");
|
|
if (adj.Status != CourseAdjustmentStatus.Submitted)
|
|
return ConflictProblem("只有待审核的申请可以退回。");
|
|
|
|
adj.Status = CourseAdjustmentStatus.Rejected;
|
|
adj.ReviewComment = request.Comment?.Trim();
|
|
adj.ReviewedAt = DateTime.UtcNow;
|
|
adj.ReviewedByUserId = currentUserDataScope.Current.UserId;
|
|
await db.SaveChangesAsync(cancellationToken);
|
|
|
|
var msg = adj.ReviewComment is not null
|
|
? $"您的{TypeLabel(adj.Type)}申请已退回。审核意见：{adj.ReviewComment}"
|
|
: $"您的{TypeLabel(adj.Type)}申请已退回。";
|
|
await NotificationService.SendAsync(db, adj.ApplicantUserId,
|
|
$"{TypeLabel(adj.Type)}申请已退回", msg,
|
|
"/course-adjustments", cancellationToken,
|
|
NotificationCategory.Schedule);
|
|
return NoContent();
|
|
}
|
|
|
|
// ═══════════════ Helpers ═══════════════
|
|
|
|
private async Task<ActionResult?> ValidateRequestAsync(
|
|
CourseAdjustmentRequest request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var task = await AccessibleTeachingTasks().AsNoTracking()
|
|
.Include(x => x.Course)
|
|
.FirstOrDefaultAsync(x =>
|
|
x.Id == request.TeachingTaskId &&
|
|
x.Status == TeachingTaskStatus.Published,
|
|
cancellationToken);
|
|
if (task is null) return ValidationProblem("教学班不存在或未发布。");
|
|
|
|
switch (request.Type)
|
|
{
|
|
case CourseAdjustmentType.Reschedule:
|
|
case CourseAdjustmentType.Makeup:
|
|
if (!request.TargetDate.HasValue)
|
|
return ValidationProblem(
|
|
request.Type == CourseAdjustmentType.Reschedule
|
|
? "请选择调课后的日期。"
|
|
: "请选择补课日期。");
|
|
if (!request.StartPeriod.HasValue || request.StartPeriod < 1)
|
|
return ValidationProblem("请选择起始节次。");
|
|
break;
|
|
case CourseAdjustmentType.Substitute:
|
|
if (!request.SubstituteTeacherId.HasValue)
|
|
return ValidationProblem("请选择代课教师。");
|
|
if (!await db.Teachers.AnyAsync(x =>
|
|
x.Id == request.SubstituteTeacherId &&
|
|
x.Status == TeacherStatus.Active, cancellationToken))
|
|
return ValidationProblem("代课教师不存在或已离职。");
|
|
break;
|
|
case CourseAdjustmentType.Cancel:
|
|
break;
|
|
}
|
|
|
|
if (RequiresSourceOccurrence(request.Type))
|
|
{
|
|
var source = await LoadSourceOccurrenceAsync(
|
|
request.TeachingTaskId,
|
|
request.SourceScheduleEntryId,
|
|
request.SourceWeek,
|
|
cancellationToken);
|
|
if (source is null)
|
|
return ValidationProblem("请选择当前已发布课表中的具体原课次。");
|
|
|
|
var duplicate = await db.CourseAdjustments.AsNoTracking().AnyAsync(x =>
|
|
x.SourceScheduleEntryId == source.Entry.Id &&
|
|
x.SourceWeek == source.Week &&
|
|
(x.Status == CourseAdjustmentStatus.Submitted ||
|
|
x.Status == CourseAdjustmentStatus.Approved),
|
|
cancellationToken);
|
|
if (duplicate)
|
|
return ConflictProblem("该课次已有待审核或已通过的调停课记录。");
|
|
|
|
if (request.TargetDate.HasValue &&
|
|
(request.TargetDate < source.Term.StartDate ||
|
|
request.TargetDate > source.Term.EndDate))
|
|
return ValidationProblem("目标日期必须在本学期起止日期内。");
|
|
}
|
|
|
|
if (request.ClassroomId.HasValue &&
|
|
!await db.Classrooms.AsNoTracking().AnyAsync(x =>
|
|
x.Id == request.ClassroomId && x.IsEnabled,
|
|
cancellationToken))
|
|
return ValidationProblem("目标教室不存在或已停用。");
|
|
|
|
return null;
|
|
}
|
|
|
|
private async Task<string?> ValidateApprovalScheduleAsync(
|
|
CourseAdjustment adjustment,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (!RequiresSourceOccurrence(adjustment.Type)) return null;
|
|
|
|
var source = await LoadSourceOccurrenceAsync(
|
|
adjustment.TeachingTaskId,
|
|
adjustment.SourceScheduleEntryId,
|
|
adjustment.SourceWeek,
|
|
cancellationToken);
|
|
if (source is null)
|
|
return "原课次已不在当前发布课表中，请退回后重新选择。";
|
|
if (adjustment.Type == CourseAdjustmentType.Cancel) return null;
|
|
if (!adjustment.TargetDate.HasValue || !adjustment.StartPeriod.HasValue)
|
|
return "目标上课日期或节次不完整。";
|
|
|
|
var targetWeek = ResolveWeek(source.Term.StartDate, adjustment.TargetDate.Value);
|
|
var targetDay = ToIsoDayOfWeek(adjustment.TargetDate.Value.DayOfWeek);
|
|
var target = new ScheduleEntry
|
|
{
|
|
TeachingTaskId = adjustment.TeachingTaskId,
|
|
TeachingTask = adjustment.TeachingTask,
|
|
ClassroomId = adjustment.ClassroomId ?? adjustment.SourceClassroomId,
|
|
DayOfWeek = targetDay,
|
|
StartPeriod = adjustment.StartPeriod.Value,
|
|
PeriodCount = adjustment.SourcePeriodCount ?? source.Entry.PeriodCount,
|
|
StartWeek = targetWeek,
|
|
EndWeek = targetWeek,
|
|
WeekPattern = WeekPattern.All
|
|
};
|
|
var possibleConflicts = await db.ScheduleEntries.AsNoTracking()
|
|
.Include(x => x.TeachingTask)
|
|
.ThenInclude(x => x!.Teachers)
|
|
.Include(x => x.TeachingTask)
|
|
.ThenInclude(x => x!.Classes)
|
|
.Where(x =>
|
|
x.SchedulePlan!.Status == SchedulePlanStatus.Published &&
|
|
x.Id != adjustment.SourceScheduleEntryId &&
|
|
x.DayOfWeek == targetDay &&
|
|
x.StartWeek <= targetWeek &&
|
|
x.EndWeek >= targetWeek &&
|
|
x.StartPeriod < target.StartPeriod + target.PeriodCount &&
|
|
target.StartPeriod < x.StartPeriod + x.PeriodCount)
|
|
.ToListAsync(cancellationToken);
|
|
foreach (var existing in possibleConflicts.Where(x =>
|
|
IncludesWeek(x.WeekPattern, targetWeek)))
|
|
{
|
|
var reason = ScheduleConflictDetector.ConflictReason(target, existing);
|
|
if (reason is not null)
|
|
return $"目标时间存在{reason}冲突：{existing.TeachingTask!.Name}。";
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private async Task<SourceOccurrence?> LoadSourceOccurrenceAsync(
|
|
Guid teachingTaskId,
|
|
Guid? scheduleEntryId,
|
|
int? week,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (!scheduleEntryId.HasValue || !week.HasValue) return null;
|
|
var entry = await db.ScheduleEntries.AsNoTracking()
|
|
.Include(x => x.TeachingTask)
|
|
.ThenInclude(x => x!.AcademicTerm)
|
|
.FirstOrDefaultAsync(x =>
|
|
x.Id == scheduleEntryId.Value &&
|
|
x.TeachingTaskId == teachingTaskId &&
|
|
x.SchedulePlan!.Status == SchedulePlanStatus.Published,
|
|
cancellationToken);
|
|
if (entry?.TeachingTask?.AcademicTerm is null ||
|
|
week < entry.StartWeek || week > entry.EndWeek ||
|
|
!IncludesWeek(entry.WeekPattern, week.Value))
|
|
return null;
|
|
var date = ResolveDate(
|
|
entry.TeachingTask.AcademicTerm.StartDate,
|
|
week.Value,
|
|
entry.DayOfWeek);
|
|
if (date < entry.TeachingTask.AcademicTerm.StartDate ||
|
|
date > entry.TeachingTask.AcademicTerm.EndDate)
|
|
return null;
|
|
return new SourceOccurrence(
|
|
entry,
|
|
entry.TeachingTask.AcademicTerm,
|
|
week.Value,
|
|
date);
|
|
}
|
|
|
|
private Task<ScheduleEntry> LoadSourceEntryAsync(
|
|
CourseAdjustment adjustment,
|
|
CancellationToken cancellationToken) =>
|
|
db.ScheduleEntries.SingleAsync(x =>
|
|
x.Id == adjustment.SourceScheduleEntryId &&
|
|
x.TeachingTaskId == adjustment.TeachingTaskId &&
|
|
x.SchedulePlan!.Status == SchedulePlanStatus.Published,
|
|
cancellationToken);
|
|
|
|
private void ExcludeWeek(ScheduleEntry entry, int week)
|
|
{
|
|
db.ScheduleEntries.Remove(entry);
|
|
if (entry.StartWeek <= week - 1 &&
|
|
HasIncludedWeek(entry.WeekPattern, entry.StartWeek, week - 1))
|
|
db.ScheduleEntries.Add(CloneEntry(entry, entry.StartWeek, week - 1));
|
|
if (week + 1 <= entry.EndWeek &&
|
|
HasIncludedWeek(entry.WeekPattern, week + 1, entry.EndWeek))
|
|
db.ScheduleEntries.Add(CloneEntry(entry, week + 1, entry.EndWeek));
|
|
}
|
|
|
|
private ScheduleEntry CreateTargetEntry(
|
|
CourseAdjustment adjustment,
|
|
Guid schedulePlanId)
|
|
{
|
|
var targetWeek = ResolveWeek(
|
|
adjustment.TeachingTask!.AcademicTerm!.StartDate,
|
|
adjustment.TargetDate!.Value);
|
|
return new ScheduleEntry
|
|
{
|
|
SchedulePlanId = schedulePlanId,
|
|
TeachingTaskId = adjustment.TeachingTaskId,
|
|
ClassroomId = adjustment.ClassroomId ?? adjustment.SourceClassroomId,
|
|
DayOfWeek = ToIsoDayOfWeek(adjustment.TargetDate.Value.DayOfWeek),
|
|
StartPeriod = adjustment.StartPeriod!.Value,
|
|
PeriodCount = adjustment.SourcePeriodCount!.Value,
|
|
StartWeek = targetWeek,
|
|
EndWeek = targetWeek,
|
|
WeekPattern = WeekPattern.All,
|
|
Notes = adjustment.Type == CourseAdjustmentType.Reschedule
|
|
? $"调课（原第 {adjustment.SourceWeek} 周）"
|
|
: $"补课（对应原第 {adjustment.SourceWeek} 周课次）"
|
|
};
|
|
}
|
|
|
|
private static ScheduleEntry CloneEntry(
|
|
ScheduleEntry source,
|
|
int startWeek,
|
|
int endWeek) => new()
|
|
{
|
|
SchedulePlanId = source.SchedulePlanId,
|
|
TeachingTaskId = source.TeachingTaskId,
|
|
ClassroomId = source.ClassroomId,
|
|
DayOfWeek = source.DayOfWeek,
|
|
StartPeriod = source.StartPeriod,
|
|
PeriodCount = source.PeriodCount,
|
|
StartWeek = startWeek,
|
|
EndWeek = endWeek,
|
|
WeekPattern = source.WeekPattern,
|
|
Notes = source.Notes
|
|
};
|
|
|
|
private static bool RequiresSourceOccurrence(CourseAdjustmentType type) =>
|
|
type is CourseAdjustmentType.Reschedule or
|
|
CourseAdjustmentType.Cancel or
|
|
CourseAdjustmentType.Makeup;
|
|
|
|
private static bool IncludesWeek(WeekPattern pattern, int week) =>
|
|
pattern == WeekPattern.All ||
|
|
pattern == WeekPattern.Odd && week % 2 == 1 ||
|
|
pattern == WeekPattern.Even && week % 2 == 0;
|
|
|
|
private static bool HasIncludedWeek(WeekPattern pattern, int startWeek, int endWeek) =>
|
|
Enumerable.Range(startWeek, endWeek - startWeek + 1)
|
|
.Any(week => IncludesWeek(pattern, week));
|
|
|
|
private static DateOnly ResolveDate(DateOnly termStartDate, int week, int dayOfWeek)
|
|
{
|
|
var startDay = (int)termStartDate.DayOfWeek;
|
|
var daysSinceMonday = (startDay + 6) % 7;
|
|
var firstWeekMonday = termStartDate.AddDays(-daysSinceMonday);
|
|
return firstWeekMonday.AddDays((week - 1) * 7 + dayOfWeek - 1);
|
|
}
|
|
|
|
private static int ResolveWeek(DateOnly termStartDate, DateOnly date)
|
|
{
|
|
var startDay = (int)termStartDate.DayOfWeek;
|
|
var daysSinceMonday = (startDay + 6) % 7;
|
|
var firstWeekMonday = termStartDate.AddDays(-daysSinceMonday);
|
|
return (date.DayNumber - firstWeekMonday.DayNumber) / 7 + 1;
|
|
}
|
|
|
|
private static int ToIsoDayOfWeek(DayOfWeek dayOfWeek) =>
|
|
dayOfWeek == System.DayOfWeek.Sunday ? 7 : (int)dayOfWeek;
|
|
|
|
private IQueryable<TeachingTask> AccessibleTeachingTasks()
|
|
{
|
|
var source = db.TeachingTasks.AsQueryable();
|
|
var scope = currentUserDataScope.Current;
|
|
if (scope.Scope == DataScope.All) return source;
|
|
if (scope.Scope == DataScope.College)
|
|
return source.Where(x =>
|
|
x.Course!.CollegeId == scope.RestrictedCollegeId);
|
|
if (scope.IsInRole(SystemRoles.Teacher))
|
|
return source.Where(x =>
|
|
x.Teachers.Any(item => item.Teacher!.UserId == scope.UserId));
|
|
return source.Where(_ => false);
|
|
}
|
|
|
|
private System.Linq.Expressions.Expression<
|
|
Func<CourseAdjustment, object>> AdjustmentProjection() => x => new
|
|
{
|
|
x.Id,
|
|
x.TeachingTaskId,
|
|
x.TeachingTask!.TaskNumber,
|
|
TaskName = x.TeachingTask.Name,
|
|
CourseCode = x.TeachingTask.Course!.Code,
|
|
CourseName = x.TeachingTask.Course.Name,
|
|
CollegeName = x.TeachingTask.Course.College!.Name,
|
|
TeacherNames = x.TeachingTask.Teachers
|
|
.OrderByDescending(t => t.IsPrimary)
|
|
.Select(t => t.Teacher!.Name),
|
|
x.Type,
|
|
x.Status,
|
|
x.Reason,
|
|
x.ReviewComment,
|
|
x.SourceScheduleEntryId,
|
|
x.SourceWeek,
|
|
x.SourceDate,
|
|
x.SourceStartPeriod,
|
|
x.SourcePeriodCount,
|
|
SourceClassroomName = x.SourceClassroomId == null
|
|
? null
|
|
: db.Classrooms
|
|
.Where(room => room.Id == x.SourceClassroomId)
|
|
.Select(room => room.Building!.Name + " " + room.Name)
|
|
.FirstOrDefault(),
|
|
x.TargetDate,
|
|
x.DayOfWeek,
|
|
x.StartPeriod,
|
|
x.PeriodCount,
|
|
ClassroomName = x.Classroom != null ? x.Classroom.Name : null,
|
|
BuildingName = x.Classroom != null ? x.Classroom.Building!.Name : null,
|
|
SubstituteTeacherName = x.SubstituteTeacher != null ? x.SubstituteTeacher.Name : null,
|
|
x.CancelWeek,
|
|
x.CancelDate,
|
|
x.ApplicantUserId,
|
|
x.SubmittedAt,
|
|
x.ReviewedAt,
|
|
x.CreatedAt
|
|
};
|
|
|
|
private sealed record SourceOccurrence(
|
|
ScheduleEntry Entry,
|
|
AcademicTerm Term,
|
|
int Week,
|
|
DateOnly Date);
|
|
|
|
private ActionResult ConflictProblem(string detail) =>
|
|
Conflict(new ProblemDetails
|
|
{
|
|
Title = "无法完成操作",
|
|
Detail = detail,
|
|
Status = StatusCodes.Status409Conflict
|
|
});
|
|
}
|
|
|
|
// ═══════════════ Request records ═══════════════
|
|
|
|
public sealed record CourseAdjustmentRequest(
|
|
Guid TeachingTaskId,
|
|
CourseAdjustmentType Type,
|
|
[Required, MaxLength(500)] string Reason,
|
|
bool Submit,
|
|
DateOnly? TargetDate,
|
|
[Range(1, 7)] int? DayOfWeek,
|
|
[Range(1, 30)] int? StartPeriod,
|
|
[Range(1, 6)] int? PeriodCount,
|
|
Guid? ClassroomId,
|
|
Guid? SubstituteTeacherId,
|
|
int? CancelWeek,
|
|
DateOnly? CancelDate,
|
|
Guid? SourceScheduleEntryId = null,
|
|
int? SourceWeek = null);
|
|
|
|
public sealed record RejectionRequest(
|
|
[MaxLength(500)] string? Comment);
|