1110 lines
48 KiB
C#
1110 lines
48 KiB
C#
using Jiaowu.Api.Domain.Academic;
|
|
using Jiaowu.Api.Domain.Identity;
|
|
using Jiaowu.Api.Domain.System;
|
|
using Jiaowu.Api.Infrastructure.Auth;
|
|
using Jiaowu.Api.Infrastructure.Caching;
|
|
using Jiaowu.Api.Infrastructure.Grades;
|
|
using Jiaowu.Api.Infrastructure.Files;
|
|
using Jiaowu.Api.Infrastructure.OfficialDocuments;
|
|
using Jiaowu.Api.Infrastructure.Persistence;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.EntityFrameworkCore;
|
|
|
|
namespace Jiaowu.Api.Controllers;
|
|
|
|
[ApiController]
|
|
[Authorize(Roles = AnalyticsUsers)]
|
|
[Route("api/grade-analytics")]
|
|
public sealed class GradeAnalyticsController(
|
|
AppDbContext db,
|
|
ICurrentUserDataScope currentUserDataScope,
|
|
OfficialDocumentOptions officialDocumentOptions,
|
|
IAppCache? cache = null) : ControllerBase
|
|
{
|
|
private const string AnalyticsUsers =
|
|
SystemRoles.SuperAdmin + "," +
|
|
SystemRoles.AcademicAdmin + "," +
|
|
SystemRoles.CollegeAdmin + "," +
|
|
SystemRoles.Leader + "," +
|
|
SystemRoles.Teacher;
|
|
private const string ScheduleManagers =
|
|
SystemRoles.SuperAdmin + "," + SystemRoles.AcademicAdmin;
|
|
private const string OverallAnalyticsUsers =
|
|
SystemRoles.SuperAdmin + "," +
|
|
SystemRoles.AcademicAdmin + "," +
|
|
SystemRoles.CollegeAdmin + "," +
|
|
SystemRoles.Leader;
|
|
|
|
[HttpGet("courses/{courseId:guid}/comments")]
|
|
public async Task<ActionResult> GetComments(
|
|
Guid courseId,
|
|
DateTime? beforeCreatedAt,
|
|
Guid? beforeId,
|
|
int pageSize = 30,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
if (!await CanAccessCommentCourseAsync(courseId, cancellationToken)) return NotFound();
|
|
if (beforeCreatedAt.HasValue != beforeId.HasValue)
|
|
return BadRequest("评论游标不完整。");
|
|
|
|
pageSize = Math.Clamp(pageSize, 1, 50);
|
|
var currentUserId = currentUserDataScope.Current.UserId;
|
|
var canModerate = CanModerateComments();
|
|
var source = db.GradeAnalyticsComments.AsNoTracking()
|
|
.Where(x => x.CourseId == courseId && x.ParentCommentId == null);
|
|
if (beforeCreatedAt.HasValue)
|
|
{
|
|
var cursorAt = beforeCreatedAt.Value;
|
|
var cursorId = beforeId!.Value;
|
|
source = source.Where(x => x.CreatedAt < cursorAt ||
|
|
x.CreatedAt == cursorAt && x.Id.CompareTo(cursorId) < 0);
|
|
}
|
|
|
|
var rows = await source
|
|
.OrderByDescending(x => x.CreatedAt)
|
|
.ThenByDescending(x => x.Id)
|
|
.Take(pageSize + 1)
|
|
.Join(db.Users.AsNoTracking(), comment => comment.AuthorUserId, user => user.Id,
|
|
(comment, user) => new
|
|
{
|
|
comment.Id,
|
|
comment.Content,
|
|
comment.IsAnonymous,
|
|
comment.CreatedAt,
|
|
AuthorName = comment.IsAnonymous ? "匿名用户" : user.DisplayName,
|
|
CanDelete = comment.AuthorUserId == currentUserId || canModerate,
|
|
ReplyCount = db.GradeAnalyticsComments.Count(reply => reply.ParentCommentId == comment.Id),
|
|
LikeCount = db.GradeAnalyticsCommentReactions.Count(reaction => reaction.CommentId == comment.Id && reaction.Type == GradeAnalyticsCommentReactionType.Like),
|
|
InsightfulCount = db.GradeAnalyticsCommentReactions.Count(reaction => reaction.CommentId == comment.Id && reaction.Type == GradeAnalyticsCommentReactionType.Insightful),
|
|
AgreeCount = db.GradeAnalyticsCommentReactions.Count(reaction => reaction.CommentId == comment.Id && reaction.Type == GradeAnalyticsCommentReactionType.Agree),
|
|
HoorayCount = db.GradeAnalyticsCommentReactions.Count(reaction => reaction.CommentId == comment.Id && reaction.Type == GradeAnalyticsCommentReactionType.Hooray),
|
|
HeartCount = db.GradeAnalyticsCommentReactions.Count(reaction => reaction.CommentId == comment.Id && reaction.Type == GradeAnalyticsCommentReactionType.Heart),
|
|
RocketCount = db.GradeAnalyticsCommentReactions.Count(reaction => reaction.CommentId == comment.Id && reaction.Type == GradeAnalyticsCommentReactionType.Rocket),
|
|
EyesCount = db.GradeAnalyticsCommentReactions.Count(reaction => reaction.CommentId == comment.Id && reaction.Type == GradeAnalyticsCommentReactionType.Eyes),
|
|
LaughCount = db.GradeAnalyticsCommentReactions.Count(reaction => reaction.CommentId == comment.Id && reaction.Type == GradeAnalyticsCommentReactionType.Laugh),
|
|
HasLiked = db.GradeAnalyticsCommentReactions.Any(reaction => reaction.CommentId == comment.Id && reaction.UserId == currentUserId && reaction.Type == GradeAnalyticsCommentReactionType.Like),
|
|
HasInsightful = db.GradeAnalyticsCommentReactions.Any(reaction => reaction.CommentId == comment.Id && reaction.UserId == currentUserId && reaction.Type == GradeAnalyticsCommentReactionType.Insightful),
|
|
HasAgreed = db.GradeAnalyticsCommentReactions.Any(reaction => reaction.CommentId == comment.Id && reaction.UserId == currentUserId && reaction.Type == GradeAnalyticsCommentReactionType.Agree),
|
|
HasHoorayed = db.GradeAnalyticsCommentReactions.Any(reaction => reaction.CommentId == comment.Id && reaction.UserId == currentUserId && reaction.Type == GradeAnalyticsCommentReactionType.Hooray),
|
|
HasHearted = db.GradeAnalyticsCommentReactions.Any(reaction => reaction.CommentId == comment.Id && reaction.UserId == currentUserId && reaction.Type == GradeAnalyticsCommentReactionType.Heart),
|
|
HasRocketed = db.GradeAnalyticsCommentReactions.Any(reaction => reaction.CommentId == comment.Id && reaction.UserId == currentUserId && reaction.Type == GradeAnalyticsCommentReactionType.Rocket),
|
|
HasEyed = db.GradeAnalyticsCommentReactions.Any(reaction => reaction.CommentId == comment.Id && reaction.UserId == currentUserId && reaction.Type == GradeAnalyticsCommentReactionType.Eyes),
|
|
HasLaughed = db.GradeAnalyticsCommentReactions.Any(reaction => reaction.CommentId == comment.Id && reaction.UserId == currentUserId && reaction.Type == GradeAnalyticsCommentReactionType.Laugh)
|
|
})
|
|
.ToListAsync(cancellationToken);
|
|
var hasMore = rows.Count > pageSize;
|
|
var items = rows.Take(pageSize).ToArray();
|
|
var last = items.LastOrDefault();
|
|
return Ok(new
|
|
{
|
|
Items = items,
|
|
HasMore = hasMore,
|
|
NextCursor = hasMore && last is not null
|
|
? new { last.CreatedAt, last.Id }
|
|
: null
|
|
});
|
|
}
|
|
|
|
[HttpPost("courses/{courseId:guid}/comments")]
|
|
public async Task<ActionResult> CreateComment(
|
|
Guid courseId,
|
|
CreateGradeAnalyticsCommentRequest request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (!await CanAccessCommentCourseAsync(courseId, cancellationToken)) return NotFound();
|
|
var content = request.Content?.Trim();
|
|
if (string.IsNullOrWhiteSpace(content))
|
|
return ValidationProblem("评论内容不能为空。");
|
|
if (content.Length > 1000)
|
|
return ValidationProblem("评论不能超过 1000 个字符。");
|
|
|
|
var userId = currentUserDataScope.Current.UserId;
|
|
if (userId == Guid.Empty) return Forbid();
|
|
|
|
var comment = new GradeAnalyticsComment
|
|
{
|
|
CourseId = courseId,
|
|
AuthorUserId = userId,
|
|
IsAnonymous = request.IsAnonymous,
|
|
Content = content
|
|
};
|
|
db.GradeAnalyticsComments.Add(comment);
|
|
await db.SaveChangesAsync(cancellationToken);
|
|
return CreatedAtAction(nameof(GetComments), new { courseId });
|
|
}
|
|
|
|
[HttpGet("courses/{courseId:guid}/comments/{commentId:guid}/replies")]
|
|
public async Task<ActionResult> GetReplies(Guid courseId, Guid commentId, CancellationToken cancellationToken)
|
|
{
|
|
if (!await CanAccessCommentCourseAsync(courseId, cancellationToken)) return NotFound();
|
|
var currentUserId = currentUserDataScope.Current.UserId;
|
|
var canModerate = CanModerateComments();
|
|
var items = await db.GradeAnalyticsComments.AsNoTracking()
|
|
.Where(x => x.CourseId == courseId && x.ParentCommentId == commentId)
|
|
.OrderBy(x => x.CreatedAt).ThenBy(x => x.Id).Take(100)
|
|
.Join(db.Users.AsNoTracking(), comment => comment.AuthorUserId, user => user.Id,
|
|
(comment, user) => new { comment.Id, comment.Content, comment.IsAnonymous, comment.CreatedAt,
|
|
AuthorName = comment.IsAnonymous ? "匿名用户" : user.DisplayName,
|
|
CanDelete = comment.AuthorUserId == currentUserId || canModerate })
|
|
.ToListAsync(cancellationToken);
|
|
return Ok(new { Items = items });
|
|
}
|
|
|
|
[HttpPost("courses/{courseId:guid}/comments/{commentId:guid}/replies")]
|
|
public async Task<ActionResult> CreateReply(Guid courseId, Guid commentId,
|
|
CreateGradeAnalyticsCommentRequest request, CancellationToken cancellationToken)
|
|
{
|
|
if (!await CanAccessCommentCourseAsync(courseId, cancellationToken)) return NotFound();
|
|
if (!await db.GradeAnalyticsComments.AnyAsync(x => x.Id == commentId && x.CourseId == courseId && x.ParentCommentId == null, cancellationToken)) return NotFound();
|
|
var content = request.Content?.Trim();
|
|
if (string.IsNullOrWhiteSpace(content) || content.Length > 1000) return ValidationProblem("回复内容应为 1 到 1000 个字符。");
|
|
var userId = currentUserDataScope.Current.UserId;
|
|
if (userId == Guid.Empty) return Forbid();
|
|
db.GradeAnalyticsComments.Add(new GradeAnalyticsComment { CourseId = courseId, ParentCommentId = commentId, AuthorUserId = userId, IsAnonymous = request.IsAnonymous, Content = content });
|
|
await db.SaveChangesAsync(cancellationToken);
|
|
return NoContent();
|
|
}
|
|
|
|
[HttpPost("courses/{courseId:guid}/comments/{commentId:guid}/reactions/{reaction}")]
|
|
public async Task<ActionResult> ToggleReaction(Guid courseId, Guid commentId, string reaction, CancellationToken cancellationToken)
|
|
{
|
|
if (!Enum.TryParse<GradeAnalyticsCommentReactionType>(reaction, true, out var type)) return BadRequest("不支持的 reaction。");
|
|
if (!await CanAccessCommentCourseAsync(courseId, cancellationToken)) return NotFound();
|
|
if (!await db.GradeAnalyticsComments.AnyAsync(x => x.Id == commentId && x.CourseId == courseId, cancellationToken)) return NotFound();
|
|
var userId = currentUserDataScope.Current.UserId;
|
|
var existing = await db.GradeAnalyticsCommentReactions.SingleOrDefaultAsync(x => x.CommentId == commentId && x.UserId == userId && x.Type == type, cancellationToken);
|
|
if (existing is null) db.GradeAnalyticsCommentReactions.Add(new GradeAnalyticsCommentReaction { CommentId = commentId, UserId = userId, Type = type }); else db.GradeAnalyticsCommentReactions.Remove(existing);
|
|
await db.SaveChangesAsync(cancellationToken);
|
|
return NoContent();
|
|
}
|
|
|
|
[HttpDelete("comments/{id:guid}")]
|
|
public async Task<ActionResult> DeleteComment(Guid id, CancellationToken cancellationToken)
|
|
{
|
|
var comment = await db.GradeAnalyticsComments
|
|
.SingleOrDefaultAsync(x => x.Id == id, cancellationToken);
|
|
if (comment is null) return NotFound();
|
|
if (comment.AuthorUserId != currentUserDataScope.Current.UserId && !CanModerateComments())
|
|
return Forbid();
|
|
|
|
db.GradeAnalyticsComments.Remove(comment);
|
|
await db.SaveChangesAsync(cancellationToken);
|
|
return NoContent();
|
|
}
|
|
|
|
private bool CanModerateComments() =>
|
|
currentUserDataScope.Current.IsInRole(SystemRoles.SuperAdmin) ||
|
|
currentUserDataScope.Current.IsInRole(SystemRoles.AcademicAdmin);
|
|
|
|
private Task<bool> CanAccessCommentCourseAsync(
|
|
Guid courseId,
|
|
CancellationToken cancellationToken) =>
|
|
db.TeachingTaskGradeStatistics.AsNoTracking().AnyAsync(x =>
|
|
x.CourseId == courseId &&
|
|
VisibleTeachingTasks().Any(task => task.Id == x.TeachingTaskId),
|
|
cancellationToken);
|
|
|
|
[HttpGet("refresh-schedule")]
|
|
[Authorize(Roles = ScheduleManagers)]
|
|
public async Task<ActionResult> GetRefreshSchedule(CancellationToken cancellationToken)
|
|
{
|
|
var setting = await db.CourseGradeStatisticsRefreshSettings.AsNoTracking()
|
|
.SingleOrDefaultAsync(
|
|
x => x.Key == CourseGradeStatisticsRefreshSetting.DefaultKey,
|
|
cancellationToken);
|
|
var defaults = new CourseGradeStatisticsRefreshSetting();
|
|
var enabled = setting?.IsEnabled ?? defaults.IsEnabled;
|
|
var intervalSeconds = setting?.IntervalSeconds ?? defaults.IntervalSeconds;
|
|
var batchSize = setting?.BatchSize ?? defaults.BatchSize;
|
|
var lastRunAt = setting?.LastRunAt;
|
|
return Ok(new
|
|
{
|
|
IsEnabled = enabled,
|
|
IntervalSeconds = intervalSeconds,
|
|
BatchSize = batchSize,
|
|
LastRunAt = lastRunAt,
|
|
NextRunAt = enabled && lastRunAt.HasValue
|
|
? lastRunAt.Value.AddSeconds(intervalSeconds)
|
|
: null as DateTime?
|
|
});
|
|
}
|
|
|
|
[HttpPut("refresh-schedule")]
|
|
[Authorize(Roles = ScheduleManagers)]
|
|
public async Task<ActionResult> SaveRefreshSchedule(
|
|
SaveGradeStatisticsRefreshScheduleRequest request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (request.IntervalSeconds is < 10 or > 86400)
|
|
return BadRequest(new ProblemDetails
|
|
{
|
|
Title = "刷新间隔应在 10 秒到 24 小时之间。",
|
|
Status = StatusCodes.Status400BadRequest
|
|
});
|
|
if (request.BatchSize is < 1 or > 5000)
|
|
return BadRequest(new ProblemDetails
|
|
{
|
|
Title = "单次刷新批量应在 1 到 5000 之间。",
|
|
Status = StatusCodes.Status400BadRequest
|
|
});
|
|
|
|
var setting = await db.CourseGradeStatisticsRefreshSettings
|
|
.SingleOrDefaultAsync(
|
|
x => x.Key == CourseGradeStatisticsRefreshSetting.DefaultKey,
|
|
cancellationToken);
|
|
if (setting is null)
|
|
{
|
|
setting = new CourseGradeStatisticsRefreshSetting();
|
|
db.CourseGradeStatisticsRefreshSettings.Add(setting);
|
|
}
|
|
|
|
setting.IsEnabled = request.IsEnabled;
|
|
setting.IntervalSeconds = request.IntervalSeconds;
|
|
setting.BatchSize = request.BatchSize;
|
|
await db.SaveChangesAsync(cancellationToken);
|
|
return NoContent();
|
|
}
|
|
|
|
[HttpGet("courses")]
|
|
[Authorize(Roles = OverallAnalyticsUsers)]
|
|
public async Task<ActionResult> GetCourseOverviews(
|
|
Guid? academicTermId,
|
|
string? keyword,
|
|
Guid? collegeId = null,
|
|
bool? riskOnly = null,
|
|
int page = 1,
|
|
int pageSize = 20,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
page = Math.Max(1, page);
|
|
pageSize = Math.Clamp(pageSize, 1, 100);
|
|
keyword = string.IsNullOrWhiteSpace(keyword) ? null : keyword.Trim();
|
|
|
|
var source = db.TeachingTaskGradeStatistics.AsNoTracking()
|
|
.Where(x => VisibleTeachingTasks().Any(task => task.Id == x.TeachingTaskId));
|
|
if (academicTermId.HasValue)
|
|
source = source.Where(x => x.AcademicTermId == academicTermId.Value);
|
|
if (collegeId.HasValue)
|
|
source = source.Where(x => x.TeachingTask!.Course!.CollegeId == collegeId.Value);
|
|
if (keyword is not null)
|
|
source = source.Where(x =>
|
|
x.TeachingTask!.Course!.Code.Contains(keyword) ||
|
|
x.TeachingTask.Course.Name.Contains(keyword));
|
|
|
|
var rows = await source.Select(x => new CourseOverviewSourceRow(
|
|
x.CourseId,
|
|
x.TeachingTask!.Course!.Code,
|
|
x.TeachingTask.Course.Name,
|
|
x.TeachingTask.Course.CollegeId,
|
|
x.TeachingTask.Course.College!.Name,
|
|
x.AcademicTermId,
|
|
x.StudentCount,
|
|
x.PassedCount,
|
|
x.ExcellentCount,
|
|
x.HighestScore,
|
|
x.AverageScore,
|
|
x.LowestScore,
|
|
x.CalculatedAt))
|
|
.ToListAsync(cancellationToken);
|
|
|
|
var overviews = rows.GroupBy(x => new
|
|
{ x.CourseId, x.CourseCode, x.CourseName, x.CollegeId, x.CollegeName })
|
|
.Select(group => BuildCourseOverview(group.Key.CourseId, group.Key.CourseCode,
|
|
group.Key.CourseName, group.Key.CollegeId, group.Key.CollegeName, group))
|
|
.Where(x => riskOnly != true || x.PassRate < 60m || x.AverageScore < 60m)
|
|
.OrderBy(x => x.PassRate < 60m || x.AverageScore < 60m ? 0 : 1)
|
|
.ThenBy(x => x.CourseCode)
|
|
.ToArray();
|
|
var total = overviews.Length;
|
|
var items = overviews.Skip((page - 1) * pageSize).Take(pageSize).ToArray();
|
|
return Ok(new { Items = items, Total = total, Page = page, PageSize = pageSize });
|
|
}
|
|
|
|
[HttpGet("courses/{courseId:guid}")]
|
|
[Authorize(Roles = OverallAnalyticsUsers)]
|
|
public async Task<ActionResult> GetCourseOverview(
|
|
Guid courseId,
|
|
Guid? academicTermId,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var report = await BuildCourseOverallAnalysisReportAsync(
|
|
courseId, academicTermId, cancellationToken);
|
|
return report is null ? NotFound() : Ok(report);
|
|
}
|
|
|
|
[HttpGet("courses/{courseId:guid}/report.docx")]
|
|
[Authorize(Roles = OverallAnalyticsUsers)]
|
|
public async Task<ActionResult> ExportCourseOverallAnalysisReport(
|
|
Guid courseId,
|
|
Guid? academicTermId,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var report = await BuildCourseOverallAnalysisReportAsync(
|
|
courseId, academicTermId, cancellationToken);
|
|
if (report is null) return NotFound();
|
|
|
|
var content = GradeAnalysisWordReportGenerator.Generate(
|
|
report, DateTime.Now, officialDocumentOptions.FontPath);
|
|
var fileName = DownloadFileName.Export("科目总体成绩分析报告", ".docx",
|
|
report.Summary.CourseCode, academicTermId.HasValue ? "指定学期" : "全部学期");
|
|
return File(content,
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
|
|
fileName);
|
|
}
|
|
|
|
private async Task<CourseOverallAnalysisReport?> BuildCourseOverallAnalysisReportAsync(
|
|
Guid courseId,
|
|
Guid? academicTermId,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var source = db.TeachingTaskGradeStatistics.AsNoTracking()
|
|
.Where(x => x.CourseId == courseId &&
|
|
VisibleTeachingTasks().Any(task => task.Id == x.TeachingTaskId));
|
|
if (academicTermId.HasValue)
|
|
source = source.Where(x => x.AcademicTermId == academicTermId.Value);
|
|
|
|
var rows = await source.Select(x => new CourseDetailSourceRow(
|
|
x.GradeSheetId,
|
|
x.TeachingTaskId,
|
|
x.CourseId,
|
|
x.TeachingTask!.Course!.Code,
|
|
x.TeachingTask.Course.Name,
|
|
x.TeachingTask.Course.CollegeId,
|
|
x.TeachingTask.Course.College!.Name,
|
|
x.AcademicTermId,
|
|
x.TeachingTask.AcademicTerm!.Name,
|
|
x.TeachingTask.AcademicTerm.StartDate,
|
|
x.TeachingTask.TaskNumber,
|
|
x.TeachingTask.Name,
|
|
x.TeachingTask.Teachers.OrderByDescending(item => item.IsPrimary)
|
|
.Select(item => item.Teacher!.Name).ToArray(),
|
|
x.StudentCount,
|
|
x.PassedCount,
|
|
x.ExcellentCount,
|
|
x.HighestScore,
|
|
x.AverageScore,
|
|
x.MedianScore,
|
|
x.LowestScore,
|
|
x.StandardDeviation,
|
|
x.PassRate,
|
|
x.ExcellentRate,
|
|
x.CalculatedAt,
|
|
x.ScoreBands.OrderBy(band => band.SortOrder)
|
|
.Select(band => new ScoreBand(band.Label, band.LowerBound,
|
|
band.UpperBound, band.StudentCount)).ToArray()))
|
|
.ToListAsync(cancellationToken);
|
|
if (rows.Count == 0) return null;
|
|
|
|
var first = rows[0];
|
|
var summary = BuildCourseOverview(first.CourseId, first.CourseCode, first.CourseName,
|
|
first.CollegeId, first.CollegeName, rows.Select(x => new CourseOverviewSourceRow(
|
|
x.CourseId, x.CourseCode, x.CourseName, x.CollegeId, x.CollegeName,
|
|
x.AcademicTermId, x.StudentCount, x.PassedCount, x.ExcellentCount,
|
|
x.HighestScore, x.AverageScore, x.LowestScore, x.CalculatedAt)));
|
|
var termIds = rows.Select(x => x.AcademicTermId).Distinct().ToArray();
|
|
var originRows = await db.CourseGradeStatistics.AsNoTracking()
|
|
.Where(x => x.CourseId == courseId &&
|
|
termIds.Contains(x.AcademicTermId) &&
|
|
x.Scope == CourseGradeStatisticScope.College)
|
|
.Join(db.Colleges.AsNoTracking(), x => x.ScopeEntityId, x => x.Id,
|
|
(statistic, college) => new { college.Name, statistic.StudentCount,
|
|
statistic.PassedCount, statistic.From90To100Count, statistic.AverageScore })
|
|
.ToListAsync(cancellationToken);
|
|
|
|
var distribution = rows.SelectMany(x => x.ScoreBands)
|
|
.GroupBy(x => new { x.Label, x.LowerBound, x.UpperBound })
|
|
.OrderBy(x => x.Key.LowerBound)
|
|
.Select(x => new ScoreBand(x.Key.Label, x.Key.LowerBound, x.Key.UpperBound,
|
|
x.Sum(item => item.StudentCount))).ToArray();
|
|
var terms = rows.GroupBy(x => new { x.AcademicTermId, x.TermName, x.StartDate })
|
|
.OrderBy(x => x.Key.StartDate)
|
|
.Select(x => BuildCourseTermOverview(x.Key.AcademicTermId, x.Key.TermName,
|
|
x.Select(item => new CourseOverviewSourceRow(item.CourseId, item.CourseCode,
|
|
item.CourseName, item.CollegeId, item.CollegeName, item.AcademicTermId,
|
|
item.StudentCount, item.PassedCount, item.ExcellentCount,
|
|
item.HighestScore, item.AverageScore, item.LowestScore, item.CalculatedAt))))
|
|
.ToArray();
|
|
var studentOrigins = originRows.GroupBy(x => x.Name)
|
|
.Select(x => new CourseStudentOrigin(
|
|
x.Key,
|
|
x.Sum(item => item.StudentCount),
|
|
WeightedAverage(x.Select(item => (item.AverageScore, item.StudentCount))),
|
|
Percentage(x.Sum(item => item.PassedCount), x.Sum(item => item.StudentCount)),
|
|
Percentage(x.Sum(item => item.From90To100Count), x.Sum(item => item.StudentCount))))
|
|
.OrderByDescending(x => x.StudentCount).ToArray();
|
|
var teachingClasses = rows.OrderByDescending(x => x.AverageScore)
|
|
.Select(x => new CourseTeachingClassOverview(x.GradeSheetId, x.TeachingTaskId,
|
|
x.TermName, x.TaskNumber, x.TaskName, string.Join("、", x.TeacherNames),
|
|
x.StudentCount, x.HighestScore, x.AverageScore, x.MedianScore, x.LowestScore,
|
|
x.StandardDeviation, x.PassRate, x.ExcellentRate)).ToArray();
|
|
return new CourseOverallAnalysisReport(summary, distribution, terms,
|
|
studentOrigins, teachingClasses);
|
|
}
|
|
|
|
private static CourseOverview BuildCourseOverview(
|
|
Guid courseId,
|
|
string courseCode,
|
|
string courseName,
|
|
Guid collegeId,
|
|
string collegeName,
|
|
IEnumerable<CourseOverviewSourceRow> source)
|
|
{
|
|
var rows = source.ToArray();
|
|
var studentCount = rows.Sum(x => x.StudentCount);
|
|
return new CourseOverview(courseId, courseCode, courseName, collegeId, collegeName,
|
|
rows.Select(x => x.AcademicTermId).Distinct().Count(), rows.Length, studentCount,
|
|
rows.Sum(x => x.PassedCount), rows.Sum(x => x.ExcellentCount),
|
|
rows.Max(x => x.HighestScore), WeightedAverage(rows.Select(x => (x.AverageScore, x.StudentCount))),
|
|
rows.Min(x => x.LowestScore), Percentage(rows.Sum(x => x.PassedCount), studentCount),
|
|
Percentage(rows.Sum(x => x.ExcellentCount), studentCount), rows.Max(x => x.CalculatedAt));
|
|
}
|
|
|
|
private static CourseTermOverview BuildCourseTermOverview(
|
|
Guid academicTermId,
|
|
string termName,
|
|
IEnumerable<CourseOverviewSourceRow> source)
|
|
{
|
|
var rows = source.ToArray();
|
|
var studentCount = rows.Sum(x => x.StudentCount);
|
|
return new CourseTermOverview(academicTermId, termName, rows.Length, studentCount,
|
|
WeightedAverage(rows.Select(x => (x.AverageScore, x.StudentCount))),
|
|
Percentage(rows.Sum(x => x.PassedCount), studentCount),
|
|
Percentage(rows.Sum(x => x.ExcellentCount), studentCount));
|
|
}
|
|
|
|
private static decimal WeightedAverage(IEnumerable<(decimal Value, int Weight)> source)
|
|
{
|
|
var values = source.ToArray();
|
|
var weight = values.Sum(x => x.Weight);
|
|
return weight == 0 ? 0m : Math.Round(values.Sum(x => x.Value * x.Weight) / weight, 1);
|
|
}
|
|
|
|
private static decimal Percentage(int numerator, int denominator) => denominator == 0
|
|
? 0m
|
|
: Math.Round((decimal)numerator / denominator * 100m, 2);
|
|
|
|
[HttpGet("teaching-classes")]
|
|
public async Task<ActionResult> GetTeachingClasses(
|
|
Guid? academicTermId,
|
|
string? keyword,
|
|
Guid? collegeId = null,
|
|
string? teacherKeyword = null,
|
|
bool? riskOnly = null,
|
|
int page = 1,
|
|
int pageSize = 20,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
page = Math.Max(1, page);
|
|
pageSize = Math.Clamp(pageSize, 1, 100);
|
|
keyword = string.IsNullOrWhiteSpace(keyword) ? null : keyword.Trim();
|
|
|
|
var source = db.TeachingTaskGradeStatistics.AsNoTracking()
|
|
.Where(x => VisibleTeachingTasks().Any(task => task.Id == x.TeachingTaskId));
|
|
if (academicTermId.HasValue)
|
|
source = source.Where(x => x.AcademicTermId == academicTermId);
|
|
if (collegeId.HasValue)
|
|
source = source.Where(x => x.TeachingTask!.Course!.CollegeId == collegeId.Value);
|
|
if (keyword is not null)
|
|
source = source.Where(x =>
|
|
x.TeachingTask!.TaskNumber.Contains(keyword) ||
|
|
x.TeachingTask.Name.Contains(keyword) ||
|
|
x.TeachingTask.Course!.Code.Contains(keyword) ||
|
|
x.TeachingTask.Course.Name.Contains(keyword));
|
|
if (!string.IsNullOrWhiteSpace(teacherKeyword))
|
|
{
|
|
teacherKeyword = teacherKeyword.Trim();
|
|
source = source.Where(x => x.TeachingTask!.Teachers.Any(item =>
|
|
item.Teacher!.Name.Contains(teacherKeyword) ||
|
|
item.Teacher.TeacherNumber.Contains(teacherKeyword)));
|
|
}
|
|
if (riskOnly == true)
|
|
source = source.Where(x => x.PassRate < 60 || x.AverageScore < 60);
|
|
|
|
var total = await source.CountAsync(cancellationToken);
|
|
var items = await source
|
|
.OrderByDescending(x => x.TeachingTask!.AcademicTerm!.StartDate)
|
|
.ThenBy(x => x.TeachingTask!.Course!.Code)
|
|
.ThenBy(x => x.TeachingTask!.TaskNumber)
|
|
.Skip((page - 1) * pageSize)
|
|
.Take(pageSize)
|
|
.Select(x => new
|
|
{
|
|
x.GradeSheetId,
|
|
x.TeachingTaskId,
|
|
x.TeachingTask!.TaskNumber,
|
|
TaskName = x.TeachingTask.Name,
|
|
CourseCode = x.TeachingTask.Course!.Code,
|
|
CourseName = x.TeachingTask.Course.Name,
|
|
TermName = x.TeachingTask.AcademicTerm!.Name,
|
|
x.AcademicTermId,
|
|
TeacherNames = x.TeachingTask.Teachers
|
|
.OrderByDescending(item => item.IsPrimary)
|
|
.Select(item => item.Teacher!.Name),
|
|
ClassNames = x.TeachingTask.Classes
|
|
.Select(item => item.AdministrativeClass!.Name),
|
|
x.StudentCount,
|
|
x.AverageScore,
|
|
x.PassRate,
|
|
x.ExcellentRate,
|
|
x.CalculatedAt
|
|
})
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Ok(new { Items = items, Total = total, Page = page, PageSize = pageSize });
|
|
}
|
|
|
|
[HttpGet("teaching-classes/{gradeSheetId:guid}")]
|
|
public async Task<ActionResult> GetTeachingClassAnalysis(
|
|
Guid gradeSheetId,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var sheet = await db.GradeSheets.AsNoTracking()
|
|
.Where(x => x.Id == gradeSheetId &&
|
|
VisibleTeachingTasks().Any(task => task.Id == x.TeachingTaskId))
|
|
.Select(x => new AnalysisTarget(
|
|
x.Id,
|
|
x.TeachingTaskId,
|
|
x.TeachingTask!.CourseId,
|
|
x.TeachingTask.AcademicTermId,
|
|
x.TeachingTask.Course!.CollegeId,
|
|
x.TeachingTask.TaskNumber,
|
|
x.TeachingTask.Name,
|
|
x.TeachingTask.Course.Code,
|
|
x.TeachingTask.Course.Name,
|
|
x.TeachingTask.AcademicTerm!.Name))
|
|
.FirstOrDefaultAsync(cancellationToken);
|
|
if (sheet is null) return NotFound();
|
|
|
|
var report = await (cache ?? NoOpAppCache.Instance).GetOrCreateAsync(
|
|
AppCacheKeys.TeachingTaskGradeAnalytics(gradeSheetId),
|
|
token => BuildReportAsync(sheet, token),
|
|
AppCacheProfile.Analytics,
|
|
[AppCacheTags.CourseGradeStatistics],
|
|
cancellationToken);
|
|
return Ok(report);
|
|
}
|
|
|
|
[HttpGet("teaching-classes/{gradeSheetId:guid}/report.docx")]
|
|
public async Task<ActionResult> ExportTeachingClassAnalysisReport(
|
|
Guid gradeSheetId,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var sheet = await db.GradeSheets.AsNoTracking()
|
|
.Where(x => x.Id == gradeSheetId &&
|
|
VisibleTeachingTasks().Any(task => task.Id == x.TeachingTaskId))
|
|
.Select(x => new AnalysisTarget(
|
|
x.Id,
|
|
x.TeachingTaskId,
|
|
x.TeachingTask!.CourseId,
|
|
x.TeachingTask.AcademicTermId,
|
|
x.TeachingTask.Course!.CollegeId,
|
|
x.TeachingTask.TaskNumber,
|
|
x.TeachingTask.Name,
|
|
x.TeachingTask.Course.Code,
|
|
x.TeachingTask.Course.Name,
|
|
x.TeachingTask.AcademicTerm!.Name))
|
|
.FirstOrDefaultAsync(cancellationToken);
|
|
if (sheet is null) return NotFound();
|
|
|
|
var report = await (cache ?? NoOpAppCache.Instance).GetOrCreateAsync(
|
|
AppCacheKeys.TeachingTaskGradeAnalytics(gradeSheetId),
|
|
token => BuildReportAsync(sheet, token),
|
|
AppCacheProfile.Analytics,
|
|
[AppCacheTags.CourseGradeStatistics],
|
|
cancellationToken);
|
|
if (report.IsRefreshing || report.Summary is null)
|
|
return Conflict(new ProblemDetails
|
|
{
|
|
Title = "成绩统计尚未生成",
|
|
Detail = "请先重新计算当前教学班，待统计完成后再导出。",
|
|
Status = StatusCodes.Status409Conflict
|
|
});
|
|
|
|
var content = GradeAnalysisWordReportGenerator.Generate(
|
|
report, DateTime.Now, officialDocumentOptions.FontPath);
|
|
var fileName = DownloadFileName.Export("成绩分析报告", ".docx", report.CourseCode, report.TaskNumber);
|
|
return File(
|
|
content,
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
|
|
fileName);
|
|
}
|
|
|
|
[HttpPost("teaching-classes/{gradeSheetId:guid}/refresh")]
|
|
public async Task<ActionResult> RefreshTeachingClassAnalysis(
|
|
Guid gradeSheetId,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var exists = await db.GradeSheets.AsNoTracking()
|
|
.AnyAsync(x => x.Id == gradeSheetId &&
|
|
VisibleTeachingTasks().Any(task => task.Id == x.TeachingTaskId),
|
|
cancellationToken);
|
|
if (!exists) return NotFound();
|
|
|
|
var job = new CourseGradeStatisticsRefreshJob { GradeSheetId = gradeSheetId };
|
|
db.CourseGradeStatisticsRefreshJobs.Add(job);
|
|
db.BackgroundJobOutboxMessages.Add(BackgroundJobOutboxMessage.Create(
|
|
BackgroundJobKind.CourseGradeStatisticsRefresh,
|
|
job.Id));
|
|
await db.SaveChangesAsync(cancellationToken);
|
|
return Accepted(new { job.Id });
|
|
}
|
|
|
|
private async Task<TeachingClassAnalysisReport> BuildReportAsync(
|
|
AnalysisTarget target,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var statistic = await db.TeachingTaskGradeStatistics.AsNoTracking()
|
|
.Where(x => x.GradeSheetId == target.GradeSheetId)
|
|
.Select(x => new TeachingClassMetrics(
|
|
x.StudentCount,
|
|
x.PassedCount,
|
|
x.ExcellentCount,
|
|
x.HighestScore,
|
|
x.AverageScore,
|
|
x.MedianScore,
|
|
x.LowestScore,
|
|
x.StandardDeviation,
|
|
x.PassRate,
|
|
x.ExcellentRate,
|
|
x.CalculatedAt,
|
|
x.ScoreBands.OrderBy(band => band.SortOrder)
|
|
.Select(band => new ScoreBand(
|
|
band.Label,
|
|
band.LowerBound,
|
|
band.UpperBound,
|
|
band.StudentCount))
|
|
.ToArray()))
|
|
.FirstOrDefaultAsync(cancellationToken);
|
|
|
|
if (statistic is null)
|
|
return new TeachingClassAnalysisReport(
|
|
true,
|
|
target.GradeSheetId,
|
|
target.TeachingTaskId,
|
|
target.TaskNumber,
|
|
target.TaskName,
|
|
target.CourseCode,
|
|
target.CourseName,
|
|
target.TermName,
|
|
null,
|
|
[],
|
|
[],
|
|
[],
|
|
null);
|
|
|
|
var peerRows = await db.TeachingTaskGradeStatistics.AsNoTracking()
|
|
.Where(x => x.CourseId == target.CourseId &&
|
|
x.AcademicTermId == target.AcademicTermId)
|
|
.OrderByDescending(x => x.AverageScore)
|
|
.Select(x => new
|
|
{
|
|
x.GradeSheetId,
|
|
x.TeachingTaskId,
|
|
x.TeachingTask!.TaskNumber,
|
|
TaskName = x.TeachingTask.Name,
|
|
TeacherNames = x.TeachingTask.Teachers
|
|
.OrderByDescending(item => item.IsPrimary)
|
|
.Select(item => item.Teacher!.Name).ToArray(),
|
|
ClassNames = x.TeachingTask.Classes
|
|
.Select(item => item.AdministrativeClass!.Name).ToArray(),
|
|
x.StudentCount,
|
|
x.HighestScore,
|
|
x.AverageScore,
|
|
x.MedianScore,
|
|
x.LowestScore,
|
|
x.StandardDeviation,
|
|
x.PassRate,
|
|
x.ExcellentRate
|
|
})
|
|
.ToListAsync(cancellationToken);
|
|
var peers = peerRows.Select(x => new TeachingClassComparison(
|
|
x.GradeSheetId,
|
|
x.TeachingTaskId,
|
|
x.TaskNumber,
|
|
x.TaskName,
|
|
string.Join("、", x.TeacherNames),
|
|
string.Join("、", x.ClassNames),
|
|
x.StudentCount,
|
|
x.HighestScore,
|
|
x.AverageScore,
|
|
x.MedianScore,
|
|
x.LowestScore,
|
|
x.StandardDeviation,
|
|
x.PassRate,
|
|
x.ExcellentRate,
|
|
x.GradeSheetId == target.GradeSheetId)).ToArray();
|
|
|
|
var classProfiles = await db.GradeRecords.AsNoTracking()
|
|
.Where(x => x.GradeSheetId == target.GradeSheetId)
|
|
.Select(x => new ClassProfile(
|
|
x.Student!.AdministrativeClassId,
|
|
x.Student.AdministrativeClass!.Name,
|
|
x.Student.AdministrativeClass.MajorId,
|
|
x.Student.AdministrativeClass.Major!.Name,
|
|
x.Student.AdministrativeClass.Major.CollegeId,
|
|
x.Student.AdministrativeClass.Major.College!.Name))
|
|
.Distinct()
|
|
.ToListAsync(cancellationToken);
|
|
var scopeStatistics = await db.CourseGradeStatistics.AsNoTracking()
|
|
.Where(x => x.CourseId == target.CourseId &&
|
|
x.AcademicTermId == target.AcademicTermId)
|
|
.ToListAsync(cancellationToken);
|
|
var benchmarks = BuildBenchmarks(classProfiles, scopeStatistics);
|
|
|
|
var selectedTeacherIds = await db.TeachingTaskTeachers.AsNoTracking()
|
|
.Where(x => x.TeachingTaskId == target.TeachingTaskId)
|
|
.Select(x => x.TeacherId)
|
|
.ToListAsync(cancellationToken);
|
|
var historicalTaskRows = await db.TeachingTaskGradeStatistics.AsNoTracking()
|
|
.Where(x => x.CourseId == target.CourseId &&
|
|
x.TeachingTask!.Teachers.Any(link =>
|
|
selectedTeacherIds.Contains(link.TeacherId)))
|
|
.Select(x => new
|
|
{
|
|
x.AcademicTermId,
|
|
TermName = x.TeachingTask!.AcademicTerm!.Name,
|
|
x.TeachingTask.AcademicTerm.StartDate,
|
|
x.StudentCount,
|
|
x.PassedCount,
|
|
x.ExcellentCount,
|
|
x.AverageScore
|
|
})
|
|
.ToListAsync(cancellationToken);
|
|
var courseHistory = await db.CourseGradeStatistics.AsNoTracking()
|
|
.Where(x => x.CourseId == target.CourseId &&
|
|
x.Scope == CourseGradeStatisticScope.University)
|
|
.Select(x => new
|
|
{
|
|
x.AcademicTermId,
|
|
TermName = db.AcademicTerms.Where(term => term.Id == x.AcademicTermId)
|
|
.Select(term => term.Name).First(),
|
|
StartDate = db.AcademicTerms.Where(term => term.Id == x.AcademicTermId)
|
|
.Select(term => term.StartDate).First(),
|
|
x.StudentCount,
|
|
x.AverageScore,
|
|
x.PassRate,
|
|
ExcellentRate = x.StudentCount == 0 ? 0m :
|
|
Math.Round((decimal)x.From90To100Count / x.StudentCount * 100m, 2)
|
|
})
|
|
.ToListAsync(cancellationToken);
|
|
|
|
var teacherByTerm = historicalTaskRows
|
|
.GroupBy(x => new { x.AcademicTermId, x.TermName, x.StartDate })
|
|
.ToDictionary(group => group.Key.AcademicTermId, group =>
|
|
{
|
|
var count = group.Sum(x => x.StudentCount);
|
|
return new HistoricalSeriesValue(
|
|
count,
|
|
count == 0 ? 0m : Math.Round(
|
|
group.Sum(x => x.AverageScore * x.StudentCount) / count, 1),
|
|
count == 0 ? 0m : Math.Round(
|
|
(decimal)group.Sum(x => x.PassedCount) / count * 100m, 2),
|
|
count == 0 ? 0m : Math.Round(
|
|
(decimal)group.Sum(x => x.ExcellentCount) / count * 100m, 2));
|
|
});
|
|
var history = courseHistory
|
|
.OrderBy(x => x.StartDate)
|
|
.Select(x => new HistoricalComparison(
|
|
x.AcademicTermId,
|
|
x.TermName,
|
|
x.StudentCount,
|
|
x.AverageScore,
|
|
x.PassRate,
|
|
x.ExcellentRate,
|
|
teacherByTerm.GetValueOrDefault(x.AcademicTermId)))
|
|
.ToArray();
|
|
|
|
var university = scopeStatistics.FirstOrDefault(x =>
|
|
x.Scope == CourseGradeStatisticScope.University);
|
|
return new TeachingClassAnalysisReport(
|
|
false,
|
|
target.GradeSheetId,
|
|
target.TeachingTaskId,
|
|
target.TaskNumber,
|
|
target.TaskName,
|
|
target.CourseCode,
|
|
target.CourseName,
|
|
target.TermName,
|
|
statistic,
|
|
peers,
|
|
benchmarks,
|
|
history,
|
|
university is null ? null : new ComparisonDelta(
|
|
Math.Round(statistic.AverageScore - university.AverageScore, 1),
|
|
Math.Round(statistic.PassRate - university.PassRate, 2),
|
|
university.AverageScore,
|
|
university.PassRate));
|
|
}
|
|
|
|
private static ScopeBenchmark[] BuildBenchmarks(
|
|
IEnumerable<ClassProfile> classProfiles,
|
|
IReadOnlyCollection<CourseGradeStatistic> statistics)
|
|
{
|
|
var profiles = classProfiles.ToArray();
|
|
var rows = new List<ScopeBenchmark>();
|
|
foreach (var profile in profiles)
|
|
AddBenchmark(rows, statistics, CourseGradeStatisticScope.AdministrativeClass,
|
|
profile.ClassId, "行政班", profile.ClassName);
|
|
foreach (var profile in profiles.GroupBy(x => x.MajorId).Select(x => x.First()))
|
|
AddBenchmark(rows, statistics, CourseGradeStatisticScope.Major,
|
|
profile.MajorId, "专业", profile.MajorName);
|
|
foreach (var profile in profiles.GroupBy(x => x.CollegeId).Select(x => x.First()))
|
|
AddBenchmark(rows, statistics, CourseGradeStatisticScope.College,
|
|
profile.CollegeId, "学院", profile.CollegeName);
|
|
AddBenchmark(rows, statistics, CourseGradeStatisticScope.University,
|
|
null, "全校", "全校同课程");
|
|
return rows.ToArray();
|
|
}
|
|
|
|
private static void AddBenchmark(
|
|
ICollection<ScopeBenchmark> target,
|
|
IEnumerable<CourseGradeStatistic> source,
|
|
CourseGradeStatisticScope scope,
|
|
Guid? entityId,
|
|
string scopeLabel,
|
|
string name)
|
|
{
|
|
var item = source.FirstOrDefault(x =>
|
|
x.Scope == scope && x.ScopeEntityId == entityId);
|
|
if (item is null || target.Any(x => x.Scope == scopeLabel && x.Name == name)) return;
|
|
target.Add(new ScopeBenchmark(
|
|
scopeLabel,
|
|
name,
|
|
item.StudentCount,
|
|
item.HighestScore,
|
|
item.AverageScore,
|
|
item.LowestScore,
|
|
item.PassRate));
|
|
}
|
|
|
|
private IQueryable<TeachingTask> VisibleTeachingTasks()
|
|
{
|
|
var scope = currentUserDataScope.Current;
|
|
var source = db.TeachingTasks.AsQueryable();
|
|
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(link => link.Teacher!.UserId == scope.UserId));
|
|
return source.Where(_ => false);
|
|
}
|
|
|
|
private static string SanitizeFileName(string value)
|
|
{
|
|
var invalid = Path.GetInvalidFileNameChars();
|
|
return string.Concat(value.Select(character => invalid.Contains(character) ? '_' : character));
|
|
}
|
|
|
|
private sealed record AnalysisTarget(
|
|
Guid GradeSheetId,
|
|
Guid TeachingTaskId,
|
|
Guid CourseId,
|
|
Guid AcademicTermId,
|
|
Guid CourseCollegeId,
|
|
string TaskNumber,
|
|
string TaskName,
|
|
string CourseCode,
|
|
string CourseName,
|
|
string TermName);
|
|
|
|
private sealed record ClassProfile(
|
|
Guid ClassId,
|
|
string ClassName,
|
|
Guid MajorId,
|
|
string MajorName,
|
|
Guid CollegeId,
|
|
string CollegeName);
|
|
|
|
private sealed record CourseOverviewSourceRow(
|
|
Guid CourseId,
|
|
string CourseCode,
|
|
string CourseName,
|
|
Guid CollegeId,
|
|
string CollegeName,
|
|
Guid AcademicTermId,
|
|
int StudentCount,
|
|
int PassedCount,
|
|
int ExcellentCount,
|
|
decimal HighestScore,
|
|
decimal AverageScore,
|
|
decimal LowestScore,
|
|
DateTime CalculatedAt);
|
|
|
|
private sealed record CourseDetailSourceRow(
|
|
Guid GradeSheetId,
|
|
Guid TeachingTaskId,
|
|
Guid CourseId,
|
|
string CourseCode,
|
|
string CourseName,
|
|
Guid CollegeId,
|
|
string CollegeName,
|
|
Guid AcademicTermId,
|
|
string TermName,
|
|
DateOnly StartDate,
|
|
string TaskNumber,
|
|
string TaskName,
|
|
string[] TeacherNames,
|
|
int StudentCount,
|
|
int PassedCount,
|
|
int ExcellentCount,
|
|
decimal HighestScore,
|
|
decimal AverageScore,
|
|
decimal MedianScore,
|
|
decimal LowestScore,
|
|
decimal StandardDeviation,
|
|
decimal PassRate,
|
|
decimal ExcellentRate,
|
|
DateTime CalculatedAt,
|
|
ScoreBand[] ScoreBands);
|
|
|
|
public sealed record CourseOverview(
|
|
Guid CourseId,
|
|
string CourseCode,
|
|
string CourseName,
|
|
Guid CollegeId,
|
|
string CollegeName,
|
|
int TermCount,
|
|
int TeachingClassCount,
|
|
int StudentCount,
|
|
int PassedCount,
|
|
int ExcellentCount,
|
|
decimal HighestScore,
|
|
decimal AverageScore,
|
|
decimal LowestScore,
|
|
decimal PassRate,
|
|
decimal ExcellentRate,
|
|
DateTime CalculatedAt);
|
|
|
|
public sealed record CourseTermOverview(
|
|
Guid AcademicTermId,
|
|
string TermName,
|
|
int TeachingClassCount,
|
|
int StudentCount,
|
|
decimal AverageScore,
|
|
decimal PassRate,
|
|
decimal ExcellentRate);
|
|
|
|
public sealed record CourseStudentOrigin(
|
|
string CollegeName,
|
|
int StudentCount,
|
|
decimal AverageScore,
|
|
decimal PassRate,
|
|
decimal ExcellentRate);
|
|
|
|
public sealed record CourseTeachingClassOverview(
|
|
Guid GradeSheetId,
|
|
Guid TeachingTaskId,
|
|
string TermName,
|
|
string TaskNumber,
|
|
string TaskName,
|
|
string TeacherNames,
|
|
int StudentCount,
|
|
decimal HighestScore,
|
|
decimal AverageScore,
|
|
decimal MedianScore,
|
|
decimal LowestScore,
|
|
decimal StandardDeviation,
|
|
decimal PassRate,
|
|
decimal ExcellentRate);
|
|
|
|
public sealed record CourseOverallAnalysisReport(
|
|
CourseOverview Summary,
|
|
IReadOnlyList<ScoreBand> Distribution,
|
|
IReadOnlyList<CourseTermOverview> Terms,
|
|
IReadOnlyList<CourseStudentOrigin> StudentOrigins,
|
|
IReadOnlyList<CourseTeachingClassOverview> TeachingClasses);
|
|
|
|
public sealed record ScoreBand(
|
|
string Label,
|
|
decimal LowerBound,
|
|
decimal? UpperBound,
|
|
int StudentCount);
|
|
|
|
public sealed record TeachingClassMetrics(
|
|
int StudentCount,
|
|
int PassedCount,
|
|
int ExcellentCount,
|
|
decimal HighestScore,
|
|
decimal AverageScore,
|
|
decimal MedianScore,
|
|
decimal LowestScore,
|
|
decimal StandardDeviation,
|
|
decimal PassRate,
|
|
decimal ExcellentRate,
|
|
DateTime CalculatedAt,
|
|
IReadOnlyList<ScoreBand> ScoreBands);
|
|
|
|
public sealed record TeachingClassComparison(
|
|
Guid GradeSheetId,
|
|
Guid TeachingTaskId,
|
|
string TaskNumber,
|
|
string TaskName,
|
|
string TeacherNames,
|
|
string ClassNames,
|
|
int StudentCount,
|
|
decimal HighestScore,
|
|
decimal AverageScore,
|
|
decimal MedianScore,
|
|
decimal LowestScore,
|
|
decimal StandardDeviation,
|
|
decimal PassRate,
|
|
decimal ExcellentRate,
|
|
bool IsSelected);
|
|
|
|
public sealed record ScopeBenchmark(
|
|
string Scope,
|
|
string Name,
|
|
int StudentCount,
|
|
decimal HighestScore,
|
|
decimal AverageScore,
|
|
decimal LowestScore,
|
|
decimal PassRate);
|
|
|
|
public sealed record HistoricalSeriesValue(
|
|
int StudentCount,
|
|
decimal AverageScore,
|
|
decimal PassRate,
|
|
decimal ExcellentRate);
|
|
|
|
public sealed record HistoricalComparison(
|
|
Guid AcademicTermId,
|
|
string TermName,
|
|
int CourseStudentCount,
|
|
decimal CourseAverageScore,
|
|
decimal CoursePassRate,
|
|
decimal CourseExcellentRate,
|
|
HistoricalSeriesValue? Instructor);
|
|
|
|
public sealed record ComparisonDelta(
|
|
decimal AverageScoreDifference,
|
|
decimal PassRateDifference,
|
|
decimal UniversityAverageScore,
|
|
decimal UniversityPassRate);
|
|
|
|
public sealed record TeachingClassAnalysisReport(
|
|
bool IsRefreshing,
|
|
Guid GradeSheetId,
|
|
Guid TeachingTaskId,
|
|
string TaskNumber,
|
|
string TaskName,
|
|
string CourseCode,
|
|
string CourseName,
|
|
string TermName,
|
|
TeachingClassMetrics? Summary,
|
|
IReadOnlyList<TeachingClassComparison> PeerTeachingClasses,
|
|
IReadOnlyList<ScopeBenchmark> ScopeBenchmarks,
|
|
IReadOnlyList<HistoricalComparison> History,
|
|
ComparisonDelta? UniversityDelta);
|
|
}
|
|
|
|
public sealed record SaveGradeStatisticsRefreshScheduleRequest(
|
|
bool IsEnabled,
|
|
int IntervalSeconds,
|
|
int BatchSize);
|
|
|
|
public sealed record CreateGradeAnalyticsCommentRequest(
|
|
string? Content,
|
|
bool IsAnonymous);
|