@studious-lms/server 1.22.0 → 1.24.0

package/src/services/moduleItem.ts

@@ -0,0 +1,274 @@
+/**
+ * ModuleItem service – Canvas-style class content (pages, file packs, videos).
+ */
+import { TRPCError } from "@trpc/server";
+import type { ModuleItemType } from "@prisma/client";
+import { prisma } from "../lib/prisma.js";
+import {
+  attachFilesToModuleItem,
+  createModuleItem,
+  deleteModuleItem,
+  findModuleItemByIdForMember,
+  findModuleItemByIdForTeacher,
+  findModuleItemsByClassId,
+  findModuleItemsBySectionId,
+  updateModuleItem,
+} from "../models/moduleItem.js";
+import { classTeacherOrSchoolAdminWhere } from "../models/access.js";
+import { createDirectUploadFiles } from "../lib/fileUpload.js";
+
+const VIDEO_MIME_PREFIX = "video/";
+
+function assertVideoFiles(
+  type: ModuleItemType,
+  files?: { type: string }[]
+) {
+  if (type !== "VIDEO" || !files?.length) return;
+  const invalid = files.filter((f) => !f.type.startsWith(VIDEO_MIME_PREFIX));
+  if (invalid.length > 0) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "VIDEO module items only accept video MIME types",
+    });
+  }
+}
+
+async function assertTeacherOwnsSection(sectionId: string, userId: string) {
+  const section = await prisma.section.findFirst({
+    where: {
+      id: sectionId,
+      class: classTeacherOrSchoolAdminWhere(userId),
+    },
+    select: { id: true, classId: true },
+  });
+  if (!section) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Only class teachers can manage module items",
+    });
+  }
+  return section;
+}
+
+export async function listModuleItemsForClass(classId: string, userId: string) {
+  const membership = await prisma.class.findFirst({
+    where: {
+      id: classId,
+      OR: [
+        { teachers: { some: { id: userId } } },
+        { students: { some: { id: userId } } },
+      ],
+    },
+    select: { id: true },
+  });
+  if (!membership) {
+    throw new TRPCError({ code: "FORBIDDEN", message: "Not a class member" });
+  }
+  const items = await findModuleItemsByClassId(classId);
+  const isTeacher = await prisma.class.findFirst({
+    where: { id: classId, ...classTeacherOrSchoolAdminWhere(userId) },
+    select: { id: true },
+  });
+  if (isTeacher) return items;
+  return items.filter((item) => item.published);
+}
+
+export async function listModuleItemsForSection(
+  sectionId: string,
+  userId: string
+) {
+  const section = await prisma.section.findFirst({
+    where: {
+      id: sectionId,
+      class: {
+        OR: [
+          { teachers: { some: { id: userId } } },
+          { students: { some: { id: userId } } },
+        ],
+      },
+    },
+    select: { id: true, classId: true },
+  });
+  if (!section) {
+    throw new TRPCError({ code: "FORBIDDEN", message: "Not a class member" });
+  }
+  const items = await findModuleItemsBySectionId(sectionId);
+  const isTeacher = await prisma.class.findFirst({
+    where: {
+      id: section.classId,
+      ...classTeacherOrSchoolAdminWhere(userId),
+    },
+    select: { id: true },
+  });
+  if (isTeacher) return items;
+  return items.filter((item) => item.published);
+}
+
+export async function getModuleItem(id: string, userId: string) {
+  const item = await findModuleItemByIdForMember(id, userId);
+  if (!item) {
+    throw new TRPCError({ code: "NOT_FOUND", message: "Module item not found" });
+  }
+  const isTeacher = await findModuleItemByIdForTeacher(id, userId);
+  if (!item.published && !isTeacher) {
+    throw new TRPCError({ code: "NOT_FOUND", message: "Module item not found" });
+  }
+  return item;
+}
+
+export async function createModuleItemRecord(
+  userId: string,
+  input: {
+    sectionId: string;
+    title: string;
+    type: ModuleItemType;
+    body?: string | null;
+    published?: boolean;
+    files?: { name: string; type: string; size: number }[];
+    existingFileIds?: string[];
+  }
+) {
+  await assertTeacherOwnsSection(input.sectionId, userId);
+
+  if (input.type === "PAGE" && !input.body && !input.files?.length) {
+    // Allow empty page draft; body can be filled later.
+  }
+  if (
+    (input.type === "FILES" || input.type === "VIDEO") &&
+    !input.files?.length &&
+    !input.existingFileIds?.length
+  ) {
+    // Allow empty collection; files attach later via upload URLs.
+  }
+
+  assertVideoFiles(input.type, input.files);
+
+  const maxOrder = await prisma.moduleItem.aggregate({
+    where: { sectionId: input.sectionId },
+    _max: { order: true },
+  });
+  const order = (maxOrder._max.order ?? 0) + 1;
+
+  const created = await createModuleItem({
+    sectionId: input.sectionId,
+    title: input.title,
+    type: input.type,
+    body: input.type === "PAGE" ? input.body ?? "" : input.body,
+    order,
+    published: input.published ?? true,
+  });
+
+  if (input.existingFileIds?.length) {
+    await attachFilesToModuleItem(created.id, input.existingFileIds);
+  }
+
+  let uploadFiles: Awaited<ReturnType<typeof createDirectUploadFiles>> = [];
+  if (input.files?.length) {
+    uploadFiles = await createDirectUploadFiles(
+      input.files,
+      userId,
+      undefined,
+      undefined,
+      undefined
+    );
+    await attachFilesToModuleItem(
+      created.id,
+      uploadFiles.map((f) => f.id)
+    );
+  }
+
+  const refreshed = await findModuleItemByIdForTeacher(created.id, userId);
+  return { item: refreshed ?? created, uploadFiles };
+}
+
+export async function updateModuleItemRecord(
+  userId: string,
+  input: {
+    id: string;
+    title?: string;
+    body?: string | null;
+    published?: boolean;
+    type?: ModuleItemType;
+    sectionId?: string;
+    order?: number | null;
+    existingFileIds?: string[];
+    files?: { name: string; type: string; size: number }[];
+  }
+) {
+  const existing = await findModuleItemByIdForTeacher(input.id, userId);
+  if (!existing) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Only class teachers can update module items",
+    });
+  }
+
+  const nextType = input.type ?? existing.type;
+  assertVideoFiles(nextType, input.files);
+
+  if (input.sectionId && input.sectionId !== existing.sectionId) {
+    await assertTeacherOwnsSection(input.sectionId, userId);
+  }
+
+  const updated = await updateModuleItem(input.id, {
+    title: input.title,
+    body: input.body,
+    published: input.published,
+    type: input.type,
+    sectionId: input.sectionId,
+    order: input.order,
+  });
+
+  if (input.existingFileIds?.length) {
+    await attachFilesToModuleItem(input.id, input.existingFileIds);
+  }
+
+  let uploadFiles: Awaited<ReturnType<typeof createDirectUploadFiles>> = [];
+  if (input.files?.length) {
+    uploadFiles = await createDirectUploadFiles(
+      input.files,
+      userId,
+      undefined,
+      undefined,
+      undefined
+    );
+    await attachFilesToModuleItem(
+      input.id,
+      uploadFiles.map((f) => f.id)
+    );
+  }
+
+  const refreshed = await findModuleItemByIdForTeacher(input.id, userId);
+  return { item: refreshed ?? updated, uploadFiles };
+}
+
+export async function deleteModuleItemRecord(userId: string, id: string) {
+  const existing = await findModuleItemByIdForTeacher(id, userId);
+  if (!existing) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Only class teachers can delete module items",
+    });
+  }
+  await deleteModuleItem(id);
+  return { success: true };
+}
+
+export async function reorderModuleItems(
+  userId: string,
+  input: {
+    sectionId: string;
+    orderedIds: string[];
+  }
+) {
+  await assertTeacherOwnsSection(input.sectionId, userId);
+  await prisma.$transaction(
+    input.orderedIds.map((id, index) =>
+      prisma.moduleItem.updateMany({
+        where: { id, sectionId: input.sectionId },
+        data: { order: index + 1 },
+      })
+    )
+  );
+  return findModuleItemsBySectionId(input.sectionId);
+}

package/src/services/notification.ts

@@ -130,3 +130,46 @@ export async function markAllAsRead(userId: string) {
   const result = await markAllNotificationsAsReadForReceiver(userId);
   return { count: result.count };
 }
+
+/** C6: Emit a FEES notification (due / paid / reminder). Used by A2 fee flows. */
+export async function notifyFeeEvent(input: {
+  receiverIds: string[];
+  title: string;
+  content: string;
+  entityId?: string | null;
+  senderId?: string | null;
+}) {
+  return sendToMultiple({
+    receiverIds: input.receiverIds,
+    title: input.title,
+    content: input.content,
+    senderId: input.senderId,
+    type: "FEES",
+    entityType: "FEE",
+    entityId: input.entityId ?? null,
+  });
+}
+
+/**
+ * C6: Excusal notification hook (trivial).
+ * A1 owns StudentExcusal; call this when an excusal is created/decided.
+ */
+export async function notifyExcusalEvent(input: {
+  receiverIds: string[];
+  title: string;
+  content: string;
+  entityId?: string | null;
+  classId?: string | null;
+  senderId?: string | null;
+}) {
+  return sendToMultiple({
+    receiverIds: input.receiverIds,
+    title: input.title,
+    content: input.content,
+    senderId: input.senderId,
+    type: "EXCUSAL",
+    entityType: "EXCUSAL",
+    entityId: input.entityId ?? null,
+    classId: input.classId ?? null,
+  });
+}

package/src/services/parentPortal.ts

@@ -0,0 +1,380 @@
+/**
+ * C4: Minimal parent portal — link parents to students and expose
+ * read-only attendance / grades stubs for linked children.
+ */
+import { TRPCError } from "@trpc/server";
+import { prisma } from "../lib/prisma.js";
+import {
+  findActiveSchoolAdminMembership,
+  findActiveSchoolMembership,
+  findSchoolMembership,
+} from "../models/school.js";
+
+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 perform this action",
+    });
+  }
+  return membership;
+}
+
+async function requireParentMembership(schoolId: string, userId: string) {
+  const membership = await findActiveSchoolMembership(schoolId, userId);
+  if (!membership || membership.role !== "PARENT") {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Only parents can access this resource",
+    });
+  }
+  return membership;
+}
+
+export async function linkParentToStudent(
+  userId: string,
+  input: { schoolId: string; parentUserId: string; studentUserId: string }
+) {
+  await requireSchoolAdmin(input.schoolId, userId);
+
+  const [parentMembership, studentMembership] = await Promise.all([
+    findSchoolMembership(input.schoolId, input.parentUserId),
+    findSchoolMembership(input.schoolId, input.studentUserId),
+  ]);
+
+  if (!parentMembership || parentMembership.status !== "ACTIVE") {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Parent must be an active school member",
+    });
+  }
+  if (parentMembership.role !== "PARENT") {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "parentUserId must have the PARENT role",
+    });
+  }
+  if (
+    !studentMembership ||
+    studentMembership.status !== "ACTIVE" ||
+    studentMembership.role !== "STUDENT"
+  ) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "studentUserId must be an active STUDENT member",
+    });
+  }
+
+  const link = await prisma.parentStudentLink.upsert({
+    where: {
+      schoolId_parentUserId_studentUserId: {
+        schoolId: input.schoolId,
+        parentUserId: input.parentUserId,
+        studentUserId: input.studentUserId,
+      },
+    },
+    update: {},
+    create: {
+      schoolId: input.schoolId,
+      parentUserId: input.parentUserId,
+      studentUserId: input.studentUserId,
+    },
+  });
+
+  return { link };
+}
+
+export async function unlinkParentFromStudent(
+  userId: string,
+  input: { schoolId: string; parentUserId: string; studentUserId: string }
+) {
+  await requireSchoolAdmin(input.schoolId, userId);
+  await prisma.parentStudentLink.deleteMany({
+    where: {
+      schoolId: input.schoolId,
+      parentUserId: input.parentUserId,
+      studentUserId: input.studentUserId,
+    },
+  });
+  return { ok: true as const };
+}
+
+export async function listParentLinks(
+  userId: string,
+  input: { schoolId: string; parentUserId?: string; studentUserId?: string }
+) {
+  await requireSchoolAdmin(input.schoolId, userId);
+  const links = await prisma.parentStudentLink.findMany({
+    where: {
+      schoolId: input.schoolId,
+      ...(input.parentUserId ? { parentUserId: input.parentUserId } : {}),
+      ...(input.studentUserId ? { studentUserId: input.studentUserId } : {}),
+    },
+    include: {
+      parent: {
+        select: {
+          id: true,
+          username: true,
+          email: true,
+          profile: { select: { displayName: true } },
+        },
+      },
+      student: {
+        select: {
+          id: true,
+          username: true,
+          email: true,
+          profile: { select: { displayName: true } },
+        },
+      },
+    },
+    orderBy: { createdAt: "desc" },
+  });
+  return { links };
+}
+
+export async function listMyChildren(userId: string, schoolId: string) {
+  await requireParentMembership(schoolId, userId);
+  const links = await prisma.parentStudentLink.findMany({
+    where: { schoolId, parentUserId: userId },
+    include: {
+      student: {
+        select: {
+          id: true,
+          username: true,
+          email: true,
+          profile: {
+            select: {
+              displayName: true,
+              profilePicture: true,
+              profilePictureThumbnail: true,
+            },
+          },
+          studentIn: {
+            where: { schoolId },
+            select: {
+              id: true,
+              name: true,
+              subject: true,
+              section: true,
+              color: true,
+            },
+          },
+        },
+      },
+    },
+    orderBy: { createdAt: "asc" },
+  });
+
+  return {
+    children: links.map((link) => ({
+      linkId: link.id,
+      student: {
+        id: link.student.id,
+        username: link.student.username,
+        email: link.student.email,
+        displayName: link.student.profile?.displayName ?? null,
+        profilePicture: link.student.profile?.profilePicture ?? null,
+        profilePictureThumbnail:
+          link.student.profile?.profilePictureThumbnail ?? null,
+        classes: link.student.studentIn,
+      },
+    })),
+  };
+}
+
+async function assertParentOfStudent(
+  schoolId: string,
+  parentUserId: string,
+  studentUserId: string
+) {
+  await requireParentMembership(schoolId, parentUserId);
+  const link = await prisma.parentStudentLink.findUnique({
+    where: {
+      schoolId_parentUserId_studentUserId: {
+        schoolId,
+        parentUserId,
+        studentUserId,
+      },
+    },
+  });
+  if (!link) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "You are not linked to this student",
+    });
+  }
+  return link;
+}
+
+/**
+ * Read-only attendance stub for a linked child (aggregates class attendance M2M).
+ * Does not touch A1 AttendanceRecord refactor.
+ */
+export async function getChildAttendance(
+  userId: string,
+  input: {
+    schoolId: string;
+    studentUserId: string;
+    classId?: string;
+    from?: Date;
+    to?: Date;
+  }
+) {
+  await assertParentOfStudent(input.schoolId, userId, input.studentUserId);
+
+  const classes = await prisma.class.findMany({
+    where: {
+      schoolId: input.schoolId,
+      students: { some: { id: input.studentUserId } },
+      ...(input.classId ? { id: input.classId } : {}),
+    },
+    select: { id: true, name: true, subject: true, section: true },
+  });
+  const classIds = classes.map((c) => c.id);
+
+  const attendance = await prisma.attendance.findMany({
+    where: {
+      classId: { in: classIds },
+      ...(input.from || input.to
+        ? {
+            date: {
+              ...(input.from ? { gte: input.from } : {}),
+              ...(input.to ? { lte: input.to } : {}),
+            },
+          }
+        : {}),
+      OR: [
+        { present: { some: { id: input.studentUserId } } },
+        { late: { some: { id: input.studentUserId } } },
+        { absent: { some: { id: input.studentUserId } } },
+      ],
+    },
+    select: {
+      id: true,
+      date: true,
+      classId: true,
+      present: { where: { id: input.studentUserId }, select: { id: true } },
+      late: { where: { id: input.studentUserId }, select: { id: true } },
+      absent: { where: { id: input.studentUserId }, select: { id: true } },
+    },
+    orderBy: { date: "desc" },
+    take: 200,
+  });
+
+  const classMap = new Map(classes.map((c) => [c.id, c]));
+  const records = attendance.map((row) => {
+    let status: "PRESENT" | "LATE" | "ABSENT" = "PRESENT";
+    if (row.absent.length > 0) status = "ABSENT";
+    else if (row.late.length > 0) status = "LATE";
+    return {
+      attendanceId: row.id,
+      date: row.date,
+      classId: row.classId,
+      class: classMap.get(row.classId) ?? null,
+      status,
+    };
+  });
+
+  const summary = records.reduce(
+    (acc, r) => {
+      acc.total += 1;
+      if (r.status === "PRESENT") acc.present += 1;
+      else if (r.status === "LATE") acc.late += 1;
+      else acc.absent += 1;
+      return acc;
+    },
+    { present: 0, late: 0, absent: 0, total: 0 }
+  );
+
+  return { summary, records };
+}
+
+/**
+ * Read-only grades stub — returns assignment score rows for the linked child.
+ */
+export async function getChildGrades(
+  userId: string,
+  input: { schoolId: string; studentUserId: string; classId?: string }
+) {
+  await assertParentOfStudent(input.schoolId, userId, input.studentUserId);
+
+  const classes = await prisma.class.findMany({
+    where: {
+      schoolId: input.schoolId,
+      students: { some: { id: input.studentUserId } },
+      ...(input.classId ? { id: input.classId } : {}),
+    },
+    select: {
+      id: true,
+      name: true,
+      subject: true,
+      section: true,
+      assignments: {
+        select: {
+          id: true,
+          title: true,
+          type: true,
+          dueDate: true,
+          maxGrade: true,
+          submissions: {
+            where: { studentId: input.studentUserId },
+            select: {
+              id: true,
+              gradeReceived: true,
+              returned: true,
+              submittedAt: true,
+            },
+            take: 1,
+          },
+        },
+        orderBy: { dueDate: "desc" },
+        take: 100,
+      },
+    },
+  });
+
+  return {
+    classes: classes.map((cls) => ({
+      id: cls.id,
+      name: cls.name,
+      subject: cls.subject,
+      section: cls.section,
+      assignments: cls.assignments.map((a) => ({
+        id: a.id,
+        title: a.title,
+        type: a.type,
+        dueDate: a.dueDate,
+        maxGrade: a.maxGrade,
+        submission: a.submissions[0]
+          ? {
+              id: a.submissions[0].id,
+              gradeReceived: a.submissions[0].gradeReceived,
+              returned: a.submissions[0].returned,
+              submittedAt: a.submissions[0].submittedAt,
+            }
+          : null,
+      })),
+    })),
+  };
+}
+
+/** Helper for other services: is this user a parent of the student? */
+export async function isParentOfStudent(
+  schoolId: string,
+  parentUserId: string,
+  studentUserId: string
+) {
+  const link = await prisma.parentStudentLink.findUnique({
+    where: {
+      schoolId_parentUserId_studentUserId: {
+        schoolId,
+        parentUserId,
+        studentUserId,
+      },
+    },
+    select: { id: true },
+  });
+  return Boolean(link);
+}