@studious-lms/server 1.7.0 → 1.9.0

package/src/services/department.ts

@@ -0,0 +1,478 @@
+/**
+ * Department service — admin CRUD, members, and template management for
+ * department-level rubrics and grading boundaries.
+ */
+import { TRPCError } from "@trpc/server";
+import { prisma } from "../lib/prisma.js";
+import {
+  addDepartmentMembers,
+  createDepartment,
+  deleteDepartment,
+  findDepartmentMembership,
+  getDepartment,
+  listDepartmentsForSchool,
+  listDepartmentsForUser,
+  removeDepartmentMember,
+  updateDepartment,
+} from "../models/department.js";
+import {
+  findActiveSchoolAdminMembership,
+  findSchoolMembership,
+} from "../models/school.js";
+
+async function requireAdmin(schoolId: string, userId: string) {
+  const membership = await findActiveSchoolAdminMembership(schoolId, userId);
+  if (!membership) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Only school admins can manage departments",
+    });
+  }
+}
+
+async function requireMember(schoolId: string, userId: string) {
+  const membership = await findSchoolMembership(schoolId, userId);
+  if (!membership || membership.status !== "ACTIVE") {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "You aren't a member of this institution",
+    });
+  }
+}
+
+export async function listDepartments(
+  userId: string,
+  schoolId: string
+) {
+  await requireMember(schoolId, userId);
+  return listDepartmentsForSchool(schoolId);
+}
+
+export async function listMyDepartments(
+  userId: string,
+  schoolId: string
+) {
+  await requireMember(schoolId, userId);
+  return listDepartmentsForUser(userId, schoolId);
+}
+
+export async function getDepartmentDetails(
+  userId: string,
+  departmentId: string
+) {
+  const department = await getDepartment(departmentId);
+  if (!department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Department not found",
+    });
+  }
+  await requireMember(department.schoolId, userId);
+  return department;
+}
+
+export async function createDepartmentRecord(
+  userId: string,
+  input: {
+    schoolId: string;
+    name: string;
+    description?: string;
+    color?: string;
+  }
+) {
+  await requireAdmin(input.schoolId, userId);
+  return createDepartment(input);
+}
+
+export async function updateDepartmentRecord(
+  userId: string,
+  input: {
+    departmentId: string;
+    name?: string;
+    description?: string | null;
+    color?: string;
+  }
+) {
+  const department = await getDepartment(input.departmentId);
+  if (!department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Department not found",
+    });
+  }
+  await requireAdmin(department.schoolId, userId);
+  return updateDepartment(input.departmentId, {
+    name: input.name,
+    description: input.description,
+    color: input.color,
+  });
+}
+
+export async function deleteDepartmentRecord(
+  userId: string,
+  departmentId: string
+) {
+  const department = await getDepartment(departmentId);
+  if (!department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Department not found",
+    });
+  }
+  await requireAdmin(department.schoolId, userId);
+  await deleteDepartment(departmentId);
+  return { success: true };
+}
+
+export async function addMembersToDepartment(
+  userId: string,
+  input: { departmentId: string; userIds: string[] }
+) {
+  const department = await getDepartment(input.departmentId);
+  if (!department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Department not found",
+    });
+  }
+  await requireAdmin(department.schoolId, userId);
+
+  // Members must already be in the institution.
+  const memberships = await prisma.schoolMembership.findMany({
+    where: {
+      schoolId: department.schoolId,
+      userId: { in: input.userIds },
+      status: "ACTIVE",
+    },
+    select: { userId: true },
+  });
+  const validIds = new Set(memberships.map((m) => m.userId));
+  const validUserIds = input.userIds.filter((id) => validIds.has(id));
+
+  if (validUserIds.length === 0) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "None of the supplied users are institution members",
+    });
+  }
+  return addDepartmentMembers(input.departmentId, validUserIds);
+}
+
+export async function removeMemberFromDepartment(
+  userId: string,
+  input: { departmentId: string; memberId: string }
+) {
+  const department = await getDepartment(input.departmentId);
+  if (!department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Department not found",
+    });
+  }
+  await requireAdmin(department.schoolId, userId);
+  return removeDepartmentMember(input.departmentId, input.memberId);
+}
+
+/** Department template authoring (rubrics + boundaries). */
+export async function createRubricTemplate(
+  userId: string,
+  input: { departmentId: string; name: string; structured: string }
+) {
+  const department = await getDepartment(input.departmentId);
+  if (!department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Department not found",
+    });
+  }
+  await requireAdmin(department.schoolId, userId);
+  return prisma.markScheme.create({
+    data: {
+      name: input.name,
+      structured: input.structured.replace(/\\n/g, "\n"),
+      department: { connect: { id: input.departmentId } },
+    },
+    select: { id: true, name: true, structured: true, departmentId: true },
+  });
+}
+
+export async function updateRubricTemplate(
+  userId: string,
+  input: {
+    templateId: string;
+    name?: string;
+    structured?: string;
+  }
+) {
+  const template = await prisma.markScheme.findUnique({
+    where: { id: input.templateId },
+    select: { departmentId: true, department: { select: { schoolId: true } } },
+  });
+  if (!template?.departmentId || !template.department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Template not found",
+    });
+  }
+  await requireAdmin(template.department.schoolId, userId);
+  return prisma.markScheme.update({
+    where: { id: input.templateId },
+    data: {
+      ...(input.name !== undefined ? { name: input.name } : {}),
+      ...(input.structured !== undefined
+        ? { structured: input.structured.replace(/\\n/g, "\n") }
+        : {}),
+    },
+  });
+}
+
+export async function deleteRubricTemplate(
+  userId: string,
+  templateId: string
+) {
+  const template = await prisma.markScheme.findUnique({
+    where: { id: templateId },
+    select: { departmentId: true, department: { select: { schoolId: true } } },
+  });
+  if (!template?.departmentId || !template.department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Template not found",
+    });
+  }
+  await requireAdmin(template.department.schoolId, userId);
+  return prisma.markScheme.delete({ where: { id: templateId } });
+}
+
+export async function createBoundaryTemplate(
+  userId: string,
+  input: { departmentId: string; name: string; structured: string }
+) {
+  const department = await getDepartment(input.departmentId);
+  if (!department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Department not found",
+    });
+  }
+  await requireAdmin(department.schoolId, userId);
+  return prisma.gradingBoundary.create({
+    data: {
+      name: input.name,
+      structured: input.structured.replace(/\\n/g, "\n"),
+      department: { connect: { id: input.departmentId } },
+    },
+    select: { id: true, name: true, structured: true, departmentId: true },
+  });
+}
+
+export async function updateBoundaryTemplate(
+  userId: string,
+  input: {
+    templateId: string;
+    name?: string;
+    structured?: string;
+  }
+) {
+  const template = await prisma.gradingBoundary.findUnique({
+    where: { id: input.templateId },
+    select: { departmentId: true, department: { select: { schoolId: true } } },
+  });
+  if (!template?.departmentId || !template.department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Template not found",
+    });
+  }
+  await requireAdmin(template.department.schoolId, userId);
+  return prisma.gradingBoundary.update({
+    where: { id: input.templateId },
+    data: {
+      ...(input.name !== undefined ? { name: input.name } : {}),
+      ...(input.structured !== undefined
+        ? { structured: input.structured.replace(/\\n/g, "\n") }
+        : {}),
+    },
+  });
+}
+
+export async function deleteBoundaryTemplate(
+  userId: string,
+  templateId: string
+) {
+  const template = await prisma.gradingBoundary.findUnique({
+    where: { id: templateId },
+    select: { departmentId: true, department: { select: { schoolId: true } } },
+  });
+  if (!template?.departmentId || !template.department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Template not found",
+    });
+  }
+  await requireAdmin(template.department.schoolId, userId);
+  return prisma.gradingBoundary.delete({ where: { id: templateId } });
+}
+
+/**
+ * Apply a department template to a class by *copying* the structured payload
+ * into a class-scoped record. Teacher-only (the class teacher).
+ */
+export async function applyRubricTemplate(
+  userId: string,
+  input: { classId: string; templateId: string }
+) {
+  const cls = await prisma.class.findFirst({
+    where: {
+      id: input.classId,
+      OR: [
+        { teachers: { some: { id: userId } } },
+        {
+          school: {
+            memberships: {
+              some: { userId, role: "ADMIN", status: "ACTIVE" },
+            },
+          },
+        },
+      ],
+    },
+    select: { id: true, departmentId: true },
+  });
+  if (!cls) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "You don't have permission to apply templates to this class",
+    });
+  }
+
+  const template = await prisma.markScheme.findUnique({
+    where: { id: input.templateId },
+    select: { id: true, structured: true, departmentId: true, name: true },
+  });
+  if (!template?.departmentId) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Template not found",
+    });
+  }
+  if (cls.departmentId && cls.departmentId !== template.departmentId) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message:
+        "This template belongs to a different department than the class",
+    });
+  }
+
+  return prisma.markScheme.create({
+    data: {
+      class: { connect: { id: input.classId } },
+      structured: template.structured,
+      name: template.name,
+    },
+  });
+}
+
+export async function applyBoundaryTemplate(
+  userId: string,
+  input: { classId: string; templateId: string }
+) {
+  const cls = await prisma.class.findFirst({
+    where: {
+      id: input.classId,
+      OR: [
+        { teachers: { some: { id: userId } } },
+        {
+          school: {
+            memberships: {
+              some: { userId, role: "ADMIN", status: "ACTIVE" },
+            },
+          },
+        },
+      ],
+    },
+    select: { id: true, departmentId: true },
+  });
+  if (!cls) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "You don't have permission to apply templates to this class",
+    });
+  }
+
+  const template = await prisma.gradingBoundary.findUnique({
+    where: { id: input.templateId },
+    select: { id: true, structured: true, departmentId: true, name: true },
+  });
+  if (!template?.departmentId) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Template not found",
+    });
+  }
+  if (cls.departmentId && cls.departmentId !== template.departmentId) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message:
+        "This template belongs to a different department than the class",
+    });
+  }
+
+  return prisma.gradingBoundary.create({
+    data: {
+      class: { connect: { id: input.classId } },
+      structured: template.structured,
+      name: template.name,
+    },
+  });
+}
+
+/** Helper used by the auto-tag flow on class creation. */
+export async function setClassDepartment(
+  userId: string,
+  input: { classId: string; departmentId: string | null }
+) {
+  const cls = await prisma.class.findFirst({
+    where: {
+      id: input.classId,
+      OR: [
+        { teachers: { some: { id: userId } } },
+        {
+          school: {
+            memberships: {
+              some: { userId, role: "ADMIN", status: "ACTIVE" },
+            },
+          },
+        },
+      ],
+    },
+    select: { id: true, schoolId: true },
+  });
+  if (!cls?.schoolId) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Class is not affiliated with an institution",
+    });
+  }
+
+  if (input.departmentId) {
+    const dept = await getDepartment(input.departmentId);
+    if (!dept || dept.schoolId !== cls.schoolId) {
+      throw new TRPCError({
+        code: "BAD_REQUEST",
+        message: "Department does not belong to this institution",
+      });
+    }
+  }
+  return prisma.class.update({
+    where: { id: input.classId },
+    data: { departmentId: input.departmentId },
+    select: { id: true, departmentId: true },
+  });
+}
+
+export async function checkDepartmentMember(
+  userId: string,
+  departmentId: string
+) {
+  return Boolean(await findDepartmentMembership(departmentId, userId));
+}