@studious-lms/server 1.23.0 → 1.24.0

package/src/services/feesAuthz.ts

@@ -0,0 +1,77 @@
+/**
+ * C7: Fees authorization stubs for ACCOUNTANT (+ ADMIN).
+ *
+ * A2 owns full fee models; this module only provides reusable gates that
+ * fee routers can call once they land.
+ */
+import { SchoolMembershipRole } from "@prisma/client";
+import { TRPCError } from "@trpc/server";
+import { findActiveSchoolMembership } from "../models/school.js";
+
+const FEE_WRITE_ROLES: SchoolMembershipRole[] = ["ADMIN", "ACCOUNTANT"];
+const FEE_READ_ROLES: SchoolMembershipRole[] = [
+  "ADMIN",
+  "ACCOUNTANT",
+  "TEACHER",
+  "PARENT",
+  "STUDENT",
+];
+
+export async function requireSchoolRoles(
+  schoolId: string,
+  userId: string,
+  allowed: SchoolMembershipRole[],
+  message = "You do not have permission for this action"
+) {
+  const membership = await findActiveSchoolMembership(schoolId, userId);
+  if (!membership || !allowed.includes(membership.role)) {
+    throw new TRPCError({ code: "FORBIDDEN", message });
+  }
+  return membership;
+}
+
+/** Admin or accountant may create/update fee structures and record payments. */
+export async function requireFeeWriteAccess(schoolId: string, userId: string) {
+  return requireSchoolRoles(
+    schoolId,
+    userId,
+    FEE_WRITE_ROLES,
+    "Only school admins or accountants can manage fees"
+  );
+}
+
+/** Broad read access stub — parents/students should be scoped to own records by A2. */
+export async function requireFeeReadAccess(schoolId: string, userId: string) {
+  return requireSchoolRoles(
+    schoolId,
+    userId,
+    FEE_READ_ROLES,
+    "You are not a member of this school"
+  );
+}
+
+export function canManageFees(role: SchoolMembershipRole) {
+  return FEE_WRITE_ROLES.includes(role);
+}
+
+/**
+ * Placeholder procedure surface until A2 fee models exist.
+ * Returns capability flags so the client can show/hide fee UI.
+ */
+export async function getFeeCapabilities(userId: string, schoolId: string) {
+  const membership = await findActiveSchoolMembership(schoolId, userId);
+  if (!membership) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "You are not a member of this school",
+    });
+  }
+  return {
+    role: membership.role,
+    canManageFees: canManageFees(membership.role),
+    canViewFees: FEE_READ_ROLES.includes(membership.role),
+    feesImplemented: false as const,
+    message:
+      "Fee models are not implemented on this branch yet (owned by A2). Authz stubs are ready.",
+  };
+}

package/src/services/gradebook.ts

@@ -325,6 +325,76 @@ export async function getComputedGradebook(classId: string, userId: string) {
   };
 }
 
+/**
+ * Compute one student's final grade in a class without teacher-auth filtering.
+ * Used by school-admin transcripts (caller must enforce school admin separately).
+ */
+export async function computeStudentGradeInClass(
+  classId: string,
+  studentId: string
+): Promise<{
+  result: FinalGradeResult;
+  letterGrade: string | null;
+  gradingBoundary: { id: string; name: string | null; structured: string } | null;
+  studentName: string | null;
+} | null> {
+  const [classData, categories, columns] = await Promise.all([
+    findClassForGradebook(classId),
+    findGradeCategoriesByClassId(classId),
+    findCustomGradeColumnsByClassId(classId),
+  ]);
+  if (!classData) return null;
+
+  const student = classData.students.find((s) => s.id === studentId);
+  if (!student) return null;
+
+  const policies = {
+    treatMissingAsZero: classData.treatMissingAsZero,
+    roundingMode: classData.gradeRoundingMode,
+  };
+  const categoryInputs: GradeCategoryInput[] = categories.map((category) => ({
+    id: category.id,
+    name: category.name,
+    weight: category.weight,
+    dropLowest: category.dropLowest,
+  }));
+  const boundary = classData.gradingBoundaries[0] ?? null;
+
+  const scores: ScoreInput[] = [];
+  for (const assignment of classData.assignments) {
+    const submission = assignment.submissions.find(
+      (item) => item.studentId === studentId
+    );
+    scores.push({
+      categoryId: assignment.gradeCategoryId,
+      pointsEarned: submission?.gradeReceived ?? null,
+      maxPoints: assignment.maxGrade ?? 0,
+      weight: assignment.weight,
+    });
+  }
+  for (const column of columns) {
+    const entry = column.entries.find((item) => item.studentId === studentId);
+    scores.push({
+      categoryId: column.gradeCategoryId,
+      pointsEarned: entry?.points ?? null,
+      maxPoints: column.maxPoints,
+    });
+  }
+
+  const result = computeFinalGrade(policies, categoryInputs, scores);
+  const letterGrade =
+    boundary && result.percentage !== null
+      ? resolveLetterGrade(boundary.structured, result.percentage)
+      : null;
+
+  return {
+    result,
+    letterGrade,
+    gradingBoundary: boundary,
+    studentName: student.profile?.displayName || student.username,
+  };
+}
+
 // ===== CSV export =====
 
 function escapeCsvCell(value: string): string {

package/src/services/idCard.ts

@@ -0,0 +1,147 @@
+/**
+ * School admin ID card generation — bulk PDF for selected student members.
+ */
+import { TRPCError } from "@trpc/server";
+import { prisma } from "../lib/prisma.js";
+import {
+  buildIdCardsPdf,
+  DEFAULT_BRAND_COLOR,
+  type IdCardStudent,
+} from "../lib/idCardPdf.js";
+import { findActiveSchoolAdminMembership } from "../models/school.js";
+
+const MAX_STUDENTS = 100;
+
+async function requireSchoolAdmin(schoolId: string, userId: string) {
+  const membership = await findActiveSchoolAdminMembership(schoolId, userId);
+  if (!membership) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Only school admins can generate ID cards",
+    });
+  }
+  return membership;
+}
+
+function formatClassLabel(cls: {
+  name: string;
+  section: string;
+  subject: string;
+}): string {
+  const parts = [cls.name, cls.section].filter(
+    (p) => p && p.trim().length > 0
+  );
+  if (parts.length === 0) return cls.subject || "—";
+  return parts.join(" · ");
+}
+
+export async function generateStudentIdCards(
+  userId: string,
+  input: { schoolId: string; studentUserIds: string[] }
+) {
+  await requireSchoolAdmin(input.schoolId, userId);
+
+  const uniqueIds = [...new Set(input.studentUserIds)].slice(0, MAX_STUDENTS);
+  if (uniqueIds.length === 0) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Select at least one student",
+    });
+  }
+
+  const school = await prisma.school.findUnique({
+    where: { id: input.schoolId },
+    select: {
+      id: true,
+      name: true,
+      logo: { select: { path: true } },
+    },
+  });
+  if (!school) {
+    throw new TRPCError({ code: "NOT_FOUND", message: "School not found" });
+  }
+
+  const memberships = await prisma.schoolMembership.findMany({
+    where: {
+      schoolId: input.schoolId,
+      userId: { in: uniqueIds },
+      role: "STUDENT",
+      status: "ACTIVE",
+    },
+    select: {
+      user: {
+        select: {
+          id: true,
+          username: true,
+          profile: {
+            select: {
+              displayName: true,
+              profilePicture: true,
+            },
+          },
+          studentIn: {
+            where: { schoolId: input.schoolId },
+            select: {
+              name: true,
+              section: true,
+              subject: true,
+              color: true,
+              department: { select: { color: true } },
+            },
+            orderBy: { name: "asc" },
+            take: 1,
+          },
+        },
+      },
+    },
+  });
+
+  if (memberships.length === 0) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "No active student members found for the given IDs",
+    });
+  }
+
+  const byId = new Map(memberships.map((m) => [m.user.id, m.user]));
+  const students: IdCardStudent[] = [];
+  for (const id of uniqueIds) {
+    const user = byId.get(id);
+    if (!user) continue;
+    const primaryClass = user.studentIn[0] ?? null;
+    const brandColor =
+      primaryClass?.color ??
+      primaryClass?.department?.color ??
+      DEFAULT_BRAND_COLOR;
+
+    students.push({
+      displayName: user.profile?.displayName?.trim() || user.username,
+      username: user.username,
+      classLabel: primaryClass ? formatClassLabel(primaryClass) : null,
+      brandColor,
+      profilePictureUrl: user.profile?.profilePicture ?? null,
+    });
+  }
+
+  const pdfBytes = await buildIdCardsPdf(
+    {
+      name: school.name,
+      logoPath: school.logo?.path ?? null,
+    },
+    students
+  );
+
+  const dateStamp = new Date().toISOString().slice(0, 10);
+  const fileName =
+    students.length === 1
+      ? `id-card-${students[0].username}-${dateStamp}.pdf`
+      : `id-cards-${school.name.replace(/[^\w\-]+/g, "_").slice(0, 40)}-${dateStamp}.pdf`;
+
+  return {
+    pdfBase64: Buffer.from(pdfBytes).toString("base64"),
+    fileName,
+    mimeType: "application/pdf" as const,
+    studentCount: students.length,
+    skippedCount: uniqueIds.length - students.length,
+  };
+}