281 lines
9.3 KiB
TypeScript
281 lines
9.3 KiB
TypeScript
import "server-only";
|
|
|
|
import { cache } from "react"
|
|
import { and, asc, desc, eq, inArray, sql, type SQL } from "drizzle-orm"
|
|
|
|
import { db } from "@/shared/db"
|
|
import {
|
|
classes,
|
|
classEnrollments,
|
|
homeworkAssignmentTargets,
|
|
homeworkAssignments,
|
|
homeworkSubmissions,
|
|
subjects,
|
|
exams,
|
|
users,
|
|
} from "@/shared/db/schema"
|
|
import type {
|
|
ClassStudent,
|
|
StudentEnrolledClass,
|
|
} from "./types"
|
|
import {
|
|
compareClassLike,
|
|
getAccessibleClassIdsForTeacher,
|
|
getSessionTeacherId,
|
|
getTeacherSubjectIdsForClass,
|
|
} from "./data-access"
|
|
|
|
export const getStudentsSubjectScores = cache(
|
|
async (studentIds: string[]): Promise<Map<string, Record<string, number | null>>> => {
|
|
if (studentIds.length === 0) return new Map()
|
|
|
|
// 1. Find assignments targeted at these students
|
|
const assignmentTargets = await db
|
|
.select({ assignmentId: homeworkAssignmentTargets.assignmentId })
|
|
.from(homeworkAssignmentTargets)
|
|
.where(inArray(homeworkAssignmentTargets.studentId, studentIds))
|
|
|
|
const assignmentIds = Array.from(new Set(assignmentTargets.map(t => t.assignmentId)))
|
|
if (assignmentIds.length === 0) return new Map()
|
|
|
|
// 2. Get assignment details including subject from linked exam
|
|
const assignments = await db
|
|
.select({
|
|
id: homeworkAssignments.id,
|
|
createdAt: homeworkAssignments.createdAt,
|
|
subjectId: exams.subjectId,
|
|
subjectName: subjects.name
|
|
})
|
|
.from(homeworkAssignments)
|
|
.innerJoin(exams, eq(homeworkAssignments.sourceExamId, exams.id))
|
|
.leftJoin(subjects, eq(exams.subjectId, subjects.id))
|
|
.where(and(
|
|
inArray(homeworkAssignments.id, assignmentIds),
|
|
eq(homeworkAssignments.status, "published")
|
|
))
|
|
.orderBy(desc(homeworkAssignments.createdAt))
|
|
|
|
// 3. Filter subjects (exclude PE, Music, Art)
|
|
const excludeSubjects = ["体育", "音乐", "美术"]
|
|
const subjectAssignments = new Map<string, string>() // subject -> assignmentId (latest)
|
|
|
|
for (const a of assignments) {
|
|
if (!a.subjectName) continue
|
|
if (excludeSubjects.includes(a.subjectName)) continue
|
|
if (!subjectAssignments.has(a.subjectName)) {
|
|
subjectAssignments.set(a.subjectName, a.id)
|
|
}
|
|
}
|
|
|
|
const targetAssignmentIds = Array.from(subjectAssignments.values())
|
|
if (targetAssignmentIds.length === 0) return new Map()
|
|
|
|
// 4. Get submissions for these assignments
|
|
const submissions = await db
|
|
.select({
|
|
studentId: homeworkSubmissions.studentId,
|
|
assignmentId: homeworkSubmissions.assignmentId,
|
|
score: homeworkSubmissions.score,
|
|
createdAt: homeworkSubmissions.createdAt,
|
|
})
|
|
.from(homeworkSubmissions)
|
|
.where(inArray(homeworkSubmissions.assignmentId, targetAssignmentIds))
|
|
.orderBy(desc(homeworkSubmissions.createdAt))
|
|
|
|
// 5. Map back to subject scores per student
|
|
const studentScores = new Map<string, Record<string, number | null>>()
|
|
|
|
// Create reverse map for assignment -> subject
|
|
const assignmentSubjectMap = new Map<string, string>()
|
|
for (const [subject, id] of subjectAssignments.entries()) {
|
|
assignmentSubjectMap.set(id, subject)
|
|
}
|
|
|
|
for (const s of submissions) {
|
|
const subject = assignmentSubjectMap.get(s.assignmentId)
|
|
if (!subject) continue
|
|
|
|
if (!studentScores.has(s.studentId)) {
|
|
studentScores.set(s.studentId, {})
|
|
}
|
|
|
|
const scores = studentScores.get(s.studentId)!
|
|
// Only set if not already set (since we ordered by desc createdAt, first one is latest)
|
|
if (scores[subject] === undefined) {
|
|
scores[subject] = s.score
|
|
}
|
|
}
|
|
|
|
return studentScores
|
|
}
|
|
)
|
|
|
|
export const getClassStudentSubjectScoresV2 = cache(
|
|
async (params: { classId: string; teacherId?: string }): Promise<Map<string, Record<string, number | null>>> => {
|
|
const teacherId = params.teacherId ?? (await getSessionTeacherId())
|
|
if (!teacherId) return new Map()
|
|
const classId = params.classId.trim()
|
|
if (!classId) return new Map()
|
|
|
|
const accessibleIds = await getAccessibleClassIdsForTeacher(teacherId)
|
|
if (accessibleIds.length === 0 || !accessibleIds.includes(classId)) return new Map()
|
|
|
|
const [classRow] = await db
|
|
.select({ id: classes.id, teacherId: classes.teacherId })
|
|
.from(classes)
|
|
.where(eq(classes.id, classId))
|
|
.limit(1)
|
|
if (!classRow) return new Map()
|
|
|
|
const isHomeroomTeacher = classRow.teacherId === teacherId
|
|
const subjectIds = isHomeroomTeacher ? [] : await getTeacherSubjectIdsForClass(teacherId, classId)
|
|
if (!isHomeroomTeacher && subjectIds.length === 0) return new Map()
|
|
|
|
const enrollments = await db
|
|
.select({ studentId: classEnrollments.studentId })
|
|
.from(classEnrollments)
|
|
.where(and(
|
|
eq(classEnrollments.classId, classId),
|
|
eq(classEnrollments.status, "active")
|
|
))
|
|
|
|
const studentIds = enrollments.map((e) => e.studentId)
|
|
const studentScores = await getStudentsSubjectScores(studentIds)
|
|
if (subjectIds.length === 0) return studentScores
|
|
|
|
// Map subjectIds to names for filtering
|
|
const subjectRows = await db
|
|
.select({ id: subjects.id, name: subjects.name })
|
|
.from(subjects)
|
|
.where(inArray(subjects.id, subjectIds))
|
|
const allowed = new Set(subjectRows.map((s) => s.name))
|
|
const filtered = new Map<string, Record<string, number | null>>()
|
|
for (const [studentId, scores] of studentScores.entries()) {
|
|
const nextScores: Record<string, number | null> = {}
|
|
for (const [subject, score] of Object.entries(scores)) {
|
|
if (allowed.has(subject)) nextScores[subject] = score
|
|
}
|
|
filtered.set(studentId, nextScores)
|
|
}
|
|
return filtered
|
|
}
|
|
)
|
|
|
|
export const getStudentClasses = cache(async (studentId: string): Promise<StudentEnrolledClass[]> => {
|
|
const id = studentId.trim()
|
|
if (!id) return []
|
|
|
|
const rows = await (async () => {
|
|
try {
|
|
return await db
|
|
.select({
|
|
id: classes.id,
|
|
schoolName: classes.schoolName,
|
|
name: classes.name,
|
|
grade: classes.grade,
|
|
homeroom: classes.homeroom,
|
|
room: classes.room,
|
|
teacherName: users.name,
|
|
teacherEmail: users.email,
|
|
})
|
|
.from(classEnrollments)
|
|
.innerJoin(classes, eq(classes.id, classEnrollments.classId))
|
|
.leftJoin(users, eq(users.id, classes.teacherId))
|
|
.where(and(eq(classEnrollments.studentId, id), eq(classEnrollments.status, "active")))
|
|
.orderBy(asc(classes.schoolName), asc(classes.grade), asc(classes.name), asc(classes.homeroom), asc(classes.room))
|
|
} catch {
|
|
return await db
|
|
.select({
|
|
id: classes.id,
|
|
schoolName: sql<string | null>`NULL`.as("schoolName"),
|
|
name: classes.name,
|
|
grade: classes.grade,
|
|
homeroom: classes.homeroom,
|
|
room: classes.room,
|
|
teacherName: users.name,
|
|
teacherEmail: users.email,
|
|
})
|
|
.from(classEnrollments)
|
|
.innerJoin(classes, eq(classes.id, classEnrollments.classId))
|
|
.leftJoin(users, eq(users.id, classes.teacherId))
|
|
.where(and(eq(classEnrollments.studentId, id), eq(classEnrollments.status, "active")))
|
|
.orderBy(asc(classes.grade), asc(classes.name), asc(classes.homeroom), asc(classes.room))
|
|
}
|
|
})()
|
|
|
|
const list = rows.map((r) => ({
|
|
id: r.id,
|
|
schoolName: r.schoolName,
|
|
name: r.name,
|
|
grade: r.grade,
|
|
homeroom: r.homeroom,
|
|
room: r.room,
|
|
teacherName: r.teacherName,
|
|
teacherEmail: r.teacherEmail,
|
|
}))
|
|
|
|
list.sort(compareClassLike)
|
|
return list
|
|
})
|
|
|
|
export const getClassStudents = cache(
|
|
async (params?: { classId?: string; q?: string; status?: string; teacherId?: string }): Promise<ClassStudent[]> => {
|
|
const teacherId = params?.teacherId ?? (await getSessionTeacherId())
|
|
if (!teacherId) return []
|
|
|
|
const classId = params?.classId?.trim()
|
|
const q = params?.q?.trim().toLowerCase()
|
|
const status = params?.status?.trim().toLowerCase()
|
|
|
|
const accessibleIds = await getAccessibleClassIdsForTeacher(teacherId)
|
|
if (accessibleIds.length === 0) return []
|
|
|
|
const conditions: SQL[] = [inArray(classes.id, accessibleIds)]
|
|
|
|
if (classId) {
|
|
conditions.push(eq(classes.id, classId))
|
|
}
|
|
|
|
if (status === "active" || status === "inactive") {
|
|
conditions.push(eq(classEnrollments.status, status))
|
|
}
|
|
|
|
if (q && q.length > 0) {
|
|
const needle = `%${q}%`
|
|
conditions.push(
|
|
sql`(LOWER(COALESCE(${users.name}, '')) LIKE ${needle} OR LOWER(${users.email}) LIKE ${needle})`
|
|
)
|
|
}
|
|
|
|
const rows = await db
|
|
.select({
|
|
id: users.id,
|
|
name: users.name,
|
|
email: users.email,
|
|
image: users.image,
|
|
gender: users.gender,
|
|
classId: classes.id,
|
|
className: classes.name,
|
|
status: classEnrollments.status,
|
|
joinedAt: classEnrollments.createdAt,
|
|
})
|
|
.from(classEnrollments)
|
|
.innerJoin(classes, eq(classes.id, classEnrollments.classId))
|
|
.innerJoin(users, eq(users.id, classEnrollments.studentId))
|
|
.where(and(...conditions))
|
|
.orderBy(asc(users.name), asc(users.email))
|
|
|
|
return rows.map((r) => ({
|
|
id: r.id,
|
|
name: r.name ?? "Unnamed",
|
|
email: r.email,
|
|
image: r.image,
|
|
gender: r.gender,
|
|
classId: r.classId,
|
|
className: r.className,
|
|
status: r.status,
|
|
joinedAt: r.joinedAt,
|
|
}))
|
|
}
|
|
)
|