466 lines
20 KiB
C#
466 lines
20 KiB
C#
using System.ComponentModel.DataAnnotations;
|
|
using Jiaowu.Api.Contracts;
|
|
using Jiaowu.Api.Domain.Academic;
|
|
using Jiaowu.Api.Domain.Identity;
|
|
using Jiaowu.Api.Infrastructure.Auth;
|
|
using Jiaowu.Api.Infrastructure.Graduation;
|
|
using Jiaowu.Api.Infrastructure.Excel;
|
|
using Jiaowu.Api.Infrastructure.Files;
|
|
using Jiaowu.Api.Infrastructure.BackgroundJobs;
|
|
using Jiaowu.Api.Domain.System;
|
|
using Jiaowu.Api.Infrastructure.Persistence;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.EntityFrameworkCore;
|
|
|
|
namespace Jiaowu.Api.Controllers;
|
|
|
|
[ApiController]
|
|
[Authorize]
|
|
[Route("api/degree-awards")]
|
|
public sealed class DegreeAwardsController(
|
|
AppDbContext db,
|
|
ICurrentUserDataScope currentUserDataScope) : ControllerBase
|
|
{
|
|
private const string Managers =
|
|
SystemRoles.SuperAdmin + "," + SystemRoles.AcademicAdmin;
|
|
private const string Reviewers = Managers + "," + SystemRoles.CollegeAdmin;
|
|
|
|
[HttpGet("batches")]
|
|
[Authorize(Roles = Reviewers)]
|
|
public async Task<ActionResult> GetBatches(CancellationToken token)
|
|
{
|
|
var collegeId = RestrictedCollegeId();
|
|
return Ok(await db.DegreeAwardBatches.AsNoTracking()
|
|
.OrderByDescending(x => x.GraduationYear)
|
|
.ThenByDescending(x => x.CreatedAt)
|
|
.Select(x => new
|
|
{
|
|
x.Id,
|
|
x.Name,
|
|
x.GraduationYear,
|
|
x.EnrollmentYear,
|
|
x.DegreeName,
|
|
x.MinimumGradePoint,
|
|
x.Status,
|
|
x.Notes,
|
|
x.CalculatedAt,
|
|
x.CalculationStatus,
|
|
x.CalculationError,
|
|
x.PublishedAt,
|
|
ResultCount = x.Results.Count(result =>
|
|
!collegeId.HasValue ||
|
|
result.Student!.AdministrativeClass!.Major!.CollegeId == collegeId),
|
|
GrantedCount = x.Results.Count(result =>
|
|
(!collegeId.HasValue ||
|
|
result.Student!.AdministrativeClass!.Major!.CollegeId == collegeId) &&
|
|
result.Conclusion == DegreeAwardConclusion.Granted),
|
|
NotGrantedCount = x.Results.Count(result =>
|
|
(!collegeId.HasValue ||
|
|
result.Student!.AdministrativeClass!.Major!.CollegeId == collegeId) &&
|
|
result.Conclusion == DegreeAwardConclusion.NotGranted),
|
|
OverrideCount = x.Results.Count(result =>
|
|
(!collegeId.HasValue ||
|
|
result.Student!.AdministrativeClass!.Major!.CollegeId == collegeId) &&
|
|
result.IsOverridden)
|
|
}).ToListAsync(token));
|
|
}
|
|
|
|
[HttpGet("batches/{id:guid}")]
|
|
[Authorize(Roles = Reviewers)]
|
|
public async Task<ActionResult> GetBatch(
|
|
Guid id,
|
|
[FromQuery] string? cursor = null,
|
|
[FromQuery] int pageSize = 20,
|
|
[FromQuery] string? keyword = null,
|
|
[FromQuery] DegreeAwardConclusion? conclusion = null,
|
|
[FromQuery] Guid? majorId = null,
|
|
[FromQuery] Guid? administrativeClassId = null,
|
|
CancellationToken token = default)
|
|
{
|
|
pageSize = Math.Clamp(pageSize, 10, 100);
|
|
if (!CursorToken.TryDecode<DegreeResultCursor>(cursor, out var after))
|
|
return BadRequest("学位授予结果游标无效。");
|
|
var batch = await db.DegreeAwardBatches.AsNoTracking()
|
|
.FirstOrDefaultAsync(x => x.Id == id, token);
|
|
if (batch is null) return NotFound();
|
|
var collegeId = RestrictedCollegeId();
|
|
var source = db.DegreeAwardResults.AsNoTracking()
|
|
.Where(x => x.DegreeAwardBatchId == id);
|
|
if (collegeId.HasValue)
|
|
source = source.Where(x =>
|
|
x.Student!.AdministrativeClass!.Major!.CollegeId == collegeId);
|
|
if (majorId.HasValue)
|
|
source = source.Where(x => x.Student!.AdministrativeClass!.MajorId == majorId);
|
|
if (administrativeClassId.HasValue)
|
|
source = source.Where(x => x.Student!.AdministrativeClassId == administrativeClassId);
|
|
|
|
var summary = await source
|
|
.GroupBy(_ => 1)
|
|
.Select(group => new
|
|
{
|
|
ResultCount = group.Count(),
|
|
GrantedCount = group.Count(x =>
|
|
x.Conclusion == DegreeAwardConclusion.Granted),
|
|
NotGrantedCount = group.Count(x =>
|
|
x.Conclusion == DegreeAwardConclusion.NotGranted),
|
|
OverrideCount = group.Count(x => x.IsOverridden)
|
|
})
|
|
.FirstOrDefaultAsync(token);
|
|
|
|
var normalizedKeyword = keyword?.Trim();
|
|
if (!string.IsNullOrWhiteSpace(normalizedKeyword))
|
|
source = source.Where(x =>
|
|
x.Student!.StudentNumber.Contains(normalizedKeyword) ||
|
|
x.Student.Name.Contains(normalizedKeyword) ||
|
|
x.Student.AdministrativeClass!.Name.Contains(normalizedKeyword) ||
|
|
x.Student.AdministrativeClass.Major!.Name.Contains(normalizedKeyword));
|
|
if (conclusion.HasValue)
|
|
source = source.Where(x => x.Conclusion == conclusion.Value);
|
|
|
|
var total = await source.CountAsync(token);
|
|
if (after is not null)
|
|
{
|
|
source = source.Where(x => x.Student!.StudentNumber.CompareTo(after.StudentNumber) > 0 ||
|
|
x.Student.StudentNumber == after.StudentNumber && x.Id.CompareTo(after.Id) > 0);
|
|
}
|
|
var rows = await source.OrderBy(x => x.Student!.StudentNumber).ThenBy(x => x.Id)
|
|
.Take(pageSize + 1)
|
|
.Select(x => new
|
|
{
|
|
x.Id,
|
|
x.StudentId,
|
|
x.Student!.StudentNumber,
|
|
x.Student.Name,
|
|
ClassName = x.Student.AdministrativeClass!.Name,
|
|
MajorName = x.Student.AdministrativeClass.Major!.Name,
|
|
CollegeName = x.Student.AdministrativeClass.Major.College!.Name,
|
|
x.AverageGradePoint,
|
|
x.CalculatedConclusion,
|
|
x.Conclusion,
|
|
x.ExceptionReason,
|
|
x.IsOverridden,
|
|
x.ReviewComment,
|
|
x.ReviewedAt
|
|
}).ToListAsync(token);
|
|
var hasMore = rows.Count > pageSize;
|
|
var items = rows.Take(pageSize).ToArray();
|
|
var last = items.LastOrDefault();
|
|
|
|
return Ok(new
|
|
{
|
|
batch.Id,
|
|
batch.Name,
|
|
batch.GraduationYear,
|
|
batch.EnrollmentYear,
|
|
batch.DegreeName,
|
|
batch.MinimumGradePoint,
|
|
batch.Status,
|
|
batch.Notes,
|
|
batch.CalculatedAt,
|
|
batch.CalculationStatus,
|
|
batch.CalculationError,
|
|
batch.PublishedAt,
|
|
ResultCount = summary?.ResultCount ?? 0,
|
|
GrantedCount = summary?.GrantedCount ?? 0,
|
|
NotGrantedCount = summary?.NotGrantedCount ?? 0,
|
|
OverrideCount = summary?.OverrideCount ?? 0,
|
|
Results = new
|
|
{
|
|
Items = items,
|
|
Total = total,
|
|
HasMore = hasMore,
|
|
NextCursor = hasMore && last is not null
|
|
? CursorToken.Encode(new DegreeResultCursor(last.StudentNumber, last.Id)) : null,
|
|
PageSize = pageSize
|
|
}
|
|
});
|
|
}
|
|
|
|
private sealed record DegreeResultCursor(string StudentNumber, Guid Id);
|
|
|
|
[HttpPost("batches")]
|
|
[Authorize(Roles = Managers)]
|
|
public async Task<ActionResult> Create(
|
|
DegreeAwardBatchRequest request,
|
|
CancellationToken token)
|
|
{
|
|
var batch = new DegreeAwardBatch
|
|
{
|
|
Name = request.Name.Trim(),
|
|
GraduationYear = request.GraduationYear,
|
|
EnrollmentYear = request.EnrollmentYear,
|
|
DegreeName = request.DegreeName.Trim(),
|
|
MinimumGradePoint = request.MinimumGradePoint,
|
|
Notes = request.Notes?.Trim()
|
|
};
|
|
db.DegreeAwardBatches.Add(batch);
|
|
await db.SaveChangesAsync(token);
|
|
return Created(string.Empty, new { batch.Id });
|
|
}
|
|
|
|
[HttpPost("batches/{id:guid}/calculate")]
|
|
[Authorize(Roles = Managers)]
|
|
public async Task<ActionResult> QueueCalculation(Guid id, CancellationToken token)
|
|
{
|
|
var batch = await db.DegreeAwardBatches.FirstOrDefaultAsync(x => x.Id == id, token);
|
|
if (batch is null) return NotFound();
|
|
if (batch.Status != DegreeAwardBatchStatus.Draft) return ConflictProblem("已发布批次不能重新计算。");
|
|
if (batch.CalculationStatus is AuditCalculationStatus.Queued or AuditCalculationStatus.Running)
|
|
return ConflictProblem("该批次正在后台计算，请稍候。");
|
|
batch.CalculationStatus = AuditCalculationStatus.Queued;
|
|
batch.CalculationError = null;
|
|
var outbox = await db.BackgroundJobOutboxMessages.FirstOrDefaultAsync(x =>
|
|
x.JobKind == BackgroundJobKind.DegreeAwardCalculation && x.JobId == id, token);
|
|
if (outbox is null)
|
|
db.BackgroundJobOutboxMessages.Add(BackgroundJobOutboxMessage.Create(BackgroundJobKind.DegreeAwardCalculation, id));
|
|
else
|
|
{
|
|
outbox.State = BackgroundJobOutboxState.Pending;
|
|
outbox.CompletedAt = null;
|
|
outbox.ProcessingToken = null;
|
|
outbox.LeaseExpiresAt = null;
|
|
outbox.LastError = null;
|
|
}
|
|
await db.SaveChangesAsync(token);
|
|
return Accepted(new { batch.Id, batch.CalculationStatus });
|
|
}
|
|
|
|
[NonAction]
|
|
public async Task<ActionResult> CalculateNow(Guid id, CancellationToken token)
|
|
{
|
|
var batch = await db.DegreeAwardBatches
|
|
.FirstOrDefaultAsync(x => x.Id == id, token);
|
|
if (batch is null) return NotFound();
|
|
if (batch.Status != DegreeAwardBatchStatus.Draft)
|
|
return ConflictProblem("已发布批次不能重新计算。");
|
|
|
|
var students = await db.Students.AsNoTracking()
|
|
.Where(x => x.EnrollmentYear == batch.EnrollmentYear &&
|
|
(x.Status == StudentStatus.Active || x.Status == StudentStatus.Suspended ||
|
|
x.Status == StudentStatus.Graduated))
|
|
.OrderBy(x => x.StudentNumber)
|
|
.Select(x => new
|
|
{
|
|
x.Id,
|
|
x.Status
|
|
})
|
|
.ToListAsync(token);
|
|
var auditCandidates = await db.GraduationAuditResults.AsNoTracking()
|
|
.Where(x => x.GraduationAuditBatch!.GraduationYear == batch.GraduationYear &&
|
|
x.GraduationAuditBatch.EnrollmentYear == batch.EnrollmentYear)
|
|
.OrderByDescending(x => x.GraduationAuditBatch!.CalculatedAt)
|
|
.Select(x => new { x.Id, x.StudentId, x.Conclusion, x.MissingCourseNames })
|
|
.ToListAsync(token);
|
|
var auditsByStudent = auditCandidates
|
|
.GroupBy(x => x.StudentId)
|
|
.Select(x => x.First())
|
|
.ToDictionary(x => x.StudentId);
|
|
var gradePoints = await db.GradeRecords.AsNoTracking()
|
|
.Where(x => x.GradeSheet!.Status == GradeSheetStatus.Published &&
|
|
x.GradePoint.HasValue)
|
|
.Where(x => x.Student!.EnrollmentYear == batch.EnrollmentYear)
|
|
.Select(x => new
|
|
{
|
|
x.StudentId,
|
|
GradePoint = x.GradePoint!.Value,
|
|
x.GradeSheet!.TeachingTask!.Course!.Credits
|
|
}).ToListAsync(token);
|
|
|
|
var gradePointsByStudent = gradePoints
|
|
.GroupBy(x => x.StudentId)
|
|
.ToDictionary(group => group.Key, group => group.ToList());
|
|
|
|
await db.DegreeAwardResults
|
|
.Where(x => x.DegreeAwardBatchId == id)
|
|
.ExecuteDeleteAsync(token);
|
|
|
|
foreach (var student in students)
|
|
{
|
|
var audit = auditsByStudent.GetValueOrDefault(student.Id);
|
|
var grades = gradePointsByStudent.GetValueOrDefault(student.Id) ?? [];
|
|
var credits = grades.Sum(x => x.Credits);
|
|
var average = credits == 0
|
|
? 0
|
|
: Math.Round(
|
|
grades.Sum(x => x.GradePoint * x.Credits) / credits,
|
|
2,
|
|
MidpointRounding.AwayFromZero);
|
|
var conclusion = DegreeAwardRules.Evaluate(
|
|
audit?.Conclusion == GraduationAuditConclusion.Eligible,
|
|
average, batch.MinimumGradePoint);
|
|
var reason = audit is null
|
|
? "尚未生成对应的毕业资格审核结果"
|
|
: audit.Conclusion != GraduationAuditConclusion.Eligible
|
|
? $"毕业资格审核暂不符合：{audit.MissingCourseNames ?? "请核对毕业审核结果"}"
|
|
: average < batch.MinimumGradePoint
|
|
? $"平均绩点 {average:0.00}，低于批次要求 {batch.MinimumGradePoint:0.00}"
|
|
: string.Empty;
|
|
db.DegreeAwardResults.Add(new DegreeAwardResult
|
|
{
|
|
DegreeAwardBatchId = batch.Id,
|
|
StudentId = student.Id,
|
|
GraduationAuditResultId = audit?.Id,
|
|
AverageGradePoint = average,
|
|
CalculatedConclusion = conclusion,
|
|
Conclusion = conclusion,
|
|
ExceptionReason = reason
|
|
});
|
|
}
|
|
batch.CalculatedAt = DateTime.UtcNow;
|
|
await db.SaveChangesAsync(token);
|
|
return Ok(new { ResultCount = students.Count });
|
|
}
|
|
|
|
[HttpPut("results/{id:guid}")]
|
|
[Authorize(Roles = Reviewers)]
|
|
public async Task<ActionResult> Review(
|
|
Guid id,
|
|
DegreeAwardDecisionRequest request,
|
|
CancellationToken token)
|
|
{
|
|
var result = await db.DegreeAwardResults
|
|
.Include(x => x.DegreeAwardBatch)
|
|
.Include(x => x.Student)
|
|
.ThenInclude(x => x!.AdministrativeClass)
|
|
.ThenInclude(x => x!.Major)
|
|
.FirstOrDefaultAsync(x => x.Id == id, token);
|
|
if (result is null) return NotFound();
|
|
if (result.DegreeAwardBatch!.Status != DegreeAwardBatchStatus.Draft)
|
|
return ConflictProblem("已发布的授予结果不能修改。");
|
|
var collegeId = RestrictedCollegeId();
|
|
if (collegeId.HasValue &&
|
|
result.Student!.AdministrativeClass!.Major!.CollegeId != collegeId)
|
|
return Forbid();
|
|
|
|
result.Conclusion = request.Conclusion;
|
|
result.IsOverridden = request.Conclusion != result.CalculatedConclusion;
|
|
result.ReviewComment = request.Comment.Trim();
|
|
result.ReviewedAt = DateTime.UtcNow;
|
|
await db.SaveChangesAsync(token);
|
|
return NoContent();
|
|
}
|
|
|
|
[HttpPost("batches/{id:guid}/publish")]
|
|
[Authorize(Roles = Managers)]
|
|
public async Task<ActionResult> Publish(Guid id, CancellationToken token)
|
|
{
|
|
var batch = await db.DegreeAwardBatches.Include(x => x.Results)
|
|
.FirstOrDefaultAsync(x => x.Id == id, token);
|
|
if (batch is null) return NotFound();
|
|
if (batch.Status != DegreeAwardBatchStatus.Draft)
|
|
return ConflictProblem("该批次已经发布。");
|
|
if (batch.Results.Count == 0)
|
|
return ConflictProblem("没有可发布的学位授予审核结果。");
|
|
batch.Status = DegreeAwardBatchStatus.Published;
|
|
batch.PublishedAt = DateTime.UtcNow;
|
|
await db.SaveChangesAsync(token);
|
|
return NoContent();
|
|
}
|
|
|
|
[HttpDelete("batches/{id:guid}")]
|
|
[Authorize(Roles = Managers)]
|
|
public async Task<ActionResult> Delete(Guid id, CancellationToken token)
|
|
{
|
|
var batch = await db.DegreeAwardBatches.FirstOrDefaultAsync(x => x.Id == id, token);
|
|
if (batch is null) return NotFound();
|
|
if (batch.Status != DegreeAwardBatchStatus.Draft)
|
|
return ConflictProblem("已发布批次不能删除。");
|
|
db.DegreeAwardBatches.Remove(batch);
|
|
await db.SaveChangesAsync(token);
|
|
return NoContent();
|
|
}
|
|
|
|
[HttpGet("batches/{id:guid}/export.xlsx")]
|
|
[Authorize(Roles = Reviewers)]
|
|
public async Task<ActionResult> Export(
|
|
Guid id,
|
|
[FromQuery] string? keyword,
|
|
[FromQuery] DegreeAwardConclusion? conclusion,
|
|
[FromQuery] Guid? majorId,
|
|
[FromQuery] Guid? administrativeClassId,
|
|
CancellationToken token)
|
|
{
|
|
var batch = await db.DegreeAwardBatches.AsNoTracking().FirstOrDefaultAsync(x => x.Id == id, token);
|
|
if (batch is null) return NotFound();
|
|
var results = db.DegreeAwardResults.AsNoTracking().Where(x => x.DegreeAwardBatchId == id);
|
|
var collegeId = RestrictedCollegeId();
|
|
if (collegeId.HasValue) results = results.Where(x => x.Student!.AdministrativeClass!.Major!.CollegeId == collegeId);
|
|
if (majorId.HasValue) results = results.Where(x => x.Student!.AdministrativeClass!.MajorId == majorId);
|
|
if (administrativeClassId.HasValue) results = results.Where(x => x.Student!.AdministrativeClassId == administrativeClassId);
|
|
var normalizedKeyword = keyword?.Trim();
|
|
if (!string.IsNullOrWhiteSpace(normalizedKeyword)) results = results.Where(x => x.Student!.StudentNumber.Contains(normalizedKeyword) || x.Student.Name.Contains(normalizedKeyword));
|
|
if (conclusion.HasValue) results = results.Where(x => x.Conclusion == conclusion.Value);
|
|
var rows = await results.OrderBy(x => x.Student!.StudentNumber).Select(x => new
|
|
{
|
|
x.Student!.StudentNumber, x.Student.Name,
|
|
College = x.Student.AdministrativeClass!.Major!.College!.Name,
|
|
Major = x.Student.AdministrativeClass.Major!.Name, Class = x.Student.AdministrativeClass.Name,
|
|
x.AverageGradePoint, x.ExceptionReason, x.Conclusion, x.IsOverridden, x.ReviewComment
|
|
}).ToListAsync(token);
|
|
var bytes = ExcelWorkbookHelper.Create("学位授予审核",
|
|
["学号", "姓名", "学院", "专业", "班级", "平均绩点", "结论", "规则说明", "人工复核", "复核意见"],
|
|
rows.Select(x => (IReadOnlyList<object?>)[x.StudentNumber, x.Name, x.College, x.Major, x.Class,
|
|
x.AverageGradePoint, x.Conclusion == DegreeAwardConclusion.Granted ? "建议授予" : "暂不授予",
|
|
x.ExceptionReason, x.IsOverridden ? "是" : "否", x.ReviewComment]).ToList());
|
|
return File(bytes, ExcelWorkbookHelper.ContentType, DownloadFileName.Export("学位授予审核", ".xlsx", batch.GraduationYear.ToString(), batch.EnrollmentYear.ToString()));
|
|
}
|
|
|
|
[HttpGet("my-result")]
|
|
[Authorize(Roles = SystemRoles.Student)]
|
|
public async Task<ActionResult> GetMyResult(CancellationToken token)
|
|
{
|
|
var userId = currentUserDataScope.Current.UserId;
|
|
var result = await db.DegreeAwardResults.AsNoTracking()
|
|
.Where(x => x.Student!.UserId == userId &&
|
|
x.DegreeAwardBatch!.Status == DegreeAwardBatchStatus.Published)
|
|
.OrderByDescending(x => x.DegreeAwardBatch!.GraduationYear)
|
|
.ThenByDescending(x => x.DegreeAwardBatch!.PublishedAt)
|
|
.Select(x => new
|
|
{
|
|
x.Id,
|
|
BatchName = x.DegreeAwardBatch!.Name,
|
|
x.DegreeAwardBatch.GraduationYear,
|
|
x.DegreeAwardBatch.DegreeName,
|
|
x.DegreeAwardBatch.MinimumGradePoint,
|
|
x.Student!.StudentNumber,
|
|
x.Student.Name,
|
|
MajorName = x.Student.AdministrativeClass!.Major!.Name,
|
|
x.AverageGradePoint,
|
|
x.Conclusion,
|
|
x.ExceptionReason,
|
|
x.IsOverridden,
|
|
x.ReviewComment,
|
|
x.DegreeAwardBatch.PublishedAt
|
|
}).FirstOrDefaultAsync(token);
|
|
return Ok(result);
|
|
}
|
|
|
|
private Guid? RestrictedCollegeId()
|
|
{
|
|
var scope = currentUserDataScope.Current;
|
|
return scope.IsInRole(SystemRoles.CollegeAdmin)
|
|
? scope.CollegeId ?? Guid.Empty
|
|
: null;
|
|
}
|
|
|
|
private ActionResult ConflictProblem(string detail) => Conflict(new ProblemDetails
|
|
{
|
|
Title = "无法完成学位授予操作",
|
|
Detail = detail,
|
|
Status = StatusCodes.Status409Conflict
|
|
});
|
|
}
|
|
|
|
public sealed record DegreeAwardBatchRequest(
|
|
[Required, MinLength(3), MaxLength(120)] string Name,
|
|
[Range(2000, 2200)] int GraduationYear,
|
|
[Range(2000, 2200)] int EnrollmentYear,
|
|
[Required, MinLength(2), MaxLength(80)] string DegreeName,
|
|
[Range(typeof(decimal), "0", "5")] decimal MinimumGradePoint,
|
|
[MaxLength(500)] string? Notes);
|
|
|
|
public sealed record DegreeAwardDecisionRequest(
|
|
DegreeAwardConclusion Conclusion,
|
|
[Required, MinLength(5), MaxLength(500)] string Comment);
|