@studious-lms/server 1.1.26 → 1.2.6

package/src/services/class.ts

@@ -0,0 +1,622 @@
+/**
+ * Class service – CRUD for classes, members, grades, mark schemes, grading boundaries,
+ * syllabus, lab drafts, and invite codes.
+ */
+import { TRPCError } from "@trpc/server";
+import { prisma } from "../lib/prisma.js";
+import { generateInviteCode } from "../utils/generateInviteCode.js";
+import {
+  findTeacherClasses,
+  findStudentClasses,
+  isTeacherInClass,
+  findClassWithAssignments,
+  findSectionsByClassId,
+  findUserById,
+  findSessionByClassCode,
+  findSessionByClassId,
+  findSubmissionsForGrades,
+  findEventsByClassId,
+  findMarkSchemesByClassId,
+  findGradingBoundariesByClassId,
+  findClassSyllabus,
+  findLabDraftsByClass,
+  findAssignmentsWithFiles,
+  findFullExportableClass,
+  createClassByImport,
+} from "../models/class.js";
+import { Class, Folder } from "@prisma/client";
+
+/** Get all classes where user is teacher or student, with assignments and members. */
+export async function getAllClasses(userId: string) {
+  const [teacherClasses, studentClasses] = await Promise.all([
+    findTeacherClasses(userId),
+    findStudentClasses(userId),
+  ]);
+
+  return {
+    teacherInClass: teacherClasses.map((cls) => ({
+      id: cls.id,
+      name: cls.name,
+      section: cls.section,
+      subject: cls.subject,
+      dueToday: cls.assignments,
+      assignments: cls.assignments,
+      members: [...cls.students, ...cls.teachers],
+      color: cls.color,
+    })),
+    studentInClass: studentClasses.map((cls) => ({
+      id: cls.id,
+      name: cls.name,
+      section: cls.section,
+      subject: cls.subject,
+      dueToday: cls.assignments,
+      assignments: cls.assignments,
+      members: [...cls.students, ...cls.teachers],
+      color: cls.color,
+    })),
+  };
+}
+
+/** Get single class with assignments, sections, and submission status. */
+export async function getClass(userId: string, classId: string) {
+  const isTeacher = await isTeacherInClass(classId, userId ?? "");
+
+  const classData = await findClassWithAssignments(classId, {
+    isTeacher: !!isTeacher,
+    userId: userId ?? undefined,
+  });
+
+  if (!classData) {
+    throw new Error("Class not found");
+  }
+
+  const formattedClassData = {
+    ...classData,
+    assignments: classData.assignments.map((assignment) => ({
+      ...assignment,
+      late: assignment.dueDate < new Date(),
+      submitted: assignment.submissions.find(
+        (s) => s.studentId === userId
+      )?.submitted,
+      returned: assignment.submissions.find(
+        (s) => s.studentId === userId
+      )?.returned,
+    })),
+  };
+
+  const sections = await findSectionsByClassId(classId);
+
+  return {
+    class: {
+      ...formattedClassData,
+      sections,
+    },
+  };
+}
+
+export async function updateClass(
+  classId: string,
+  data: { name?: string; section?: string; subject?: string }
+) {
+  const updatedClass = await prisma.class.update({
+    where: { id: classId },
+    data,
+    select: {
+      id: true,
+      name: true,
+      section: true,
+      subject: true,
+    },
+  });
+  return { updatedClass };
+}
+
+export async function createClass(
+  userId: string,
+  input: {
+    students?: string[];
+    teachers?: string[];
+    name: string;
+    section: string;
+    subject: string;
+    color?: string;
+  }
+) {
+  const { students, teachers, name, section, subject, color } = input;
+
+  if (teachers && teachers.length > 0 && students && students.length > 0) {
+    return prisma.class.create({
+      data: {
+        name,
+        section,
+        subject,
+        color,
+        teachers: { connect: teachers.map((id) => ({ id })) },
+        students: { connect: students.map((id) => ({ id })) },
+      },
+      include: { teachers: true, students: true },
+    });
+  }
+
+  return prisma.class.create({
+    data: {
+      name,
+      section,
+      subject,
+      color,
+      teachers: { connect: { id: userId } },
+    },
+  });
+}
+
+export async function deleteClass(classId: string) {
+  const classToDelete = await prisma.class.findFirst({
+    where: { id: classId },
+  });
+
+  if (!classToDelete) {
+    throw new Error("Class not found or you don't have permission to delete it");
+  }
+
+  await prisma.class.delete({
+    where: { id: classId },
+  });
+
+  return { deletedClass: { id: classId } };
+}
+
+export async function addStudent(classId: string, studentId: string) {
+  const student = await findUserById(studentId);
+  if (!student) {
+    throw new Error("Student not found");
+  }
+
+  const updatedClass = await prisma.class.update({
+    where: { id: classId },
+    data: {
+      students: { connect: { id: studentId } },
+    },
+    select: {
+      id: true,
+      name: true,
+      section: true,
+      subject: true,
+    },
+  });
+
+  return { updatedClass, newStudent: student };
+}
+
+export async function changeRole(
+  classId: string,
+  userId: string,
+  type: "teacher" | "student"
+) {
+  const user = await findUserById(userId);
+  if (!user) {
+    throw new Error("User not found");
+  }
+
+  const updatedClass = await prisma.class.update({
+    where: { id: classId },
+    data: {
+      [type === "teacher" ? "teachers" : "students"]: {
+        connect: { id: userId },
+      },
+      [type === "teacher" ? "students" : "teachers"]: {
+        disconnect: { id: userId },
+      },
+    },
+  });
+
+  return {
+    updatedClass,
+    user: { ...user, type },
+  };
+}
+
+export async function removeMember(classId: string, userId: string) {
+  const updatedClass = await prisma.class.update({
+    where: { id: classId },
+    data: {
+      teachers: { disconnect: { id: userId } },
+      students: { disconnect: { id: userId } },
+    },
+  });
+  return { updatedClass, removedUserId: userId };
+}
+
+export async function leaveClass(userId: string, classId: string) {
+  const classData = await prisma.class.findFirst({
+    where: {
+      id: classId,
+      students: { some: { id: userId } },
+    },
+  });
+
+  if (!classData) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Class not found or you are not a student in this class",
+    });
+  }
+
+  await prisma.class.update({
+    where: { id: classId },
+    data: {
+      students: { disconnect: { id: userId } },
+    },
+  });
+
+  return { success: true, leftClassId: classId };
+}
+
+export async function joinClass(userId: string, classCode: string) {
+  const session = await findSessionByClassCode(classCode);
+
+  if (!session || !session.classId) {
+    throw new Error("Class not found");
+  }
+
+  if (session.expiresAt && session.expiresAt < new Date()) {
+    throw new Error("Session expired");
+  }
+
+  const updatedClass = await prisma.class.update({
+    where: { id: session.classId },
+    data: {
+      students: { connect: { id: userId } },
+    },
+    select: {
+      id: true,
+      name: true,
+      section: true,
+      subject: true,
+    },
+  });
+
+  return { joinedClass: updatedClass };
+}
+
+export async function getInviteCode(classId: string) {
+  const session = await findSessionByClassId(classId);
+
+  if ((session?.expiresAt && session.expiresAt < new Date()) || !session) {
+    const newSession = await prisma.session.create({
+      data: {
+        id: generateInviteCode(),
+        classId,
+        expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000),
+      },
+    });
+    return { code: newSession.id };
+  }
+
+  return { code: session?.id };
+}
+
+export async function createInviteCode(classId: string) {
+  await prisma.session.deleteMany({
+    where: { classId },
+  });
+
+  const session = await prisma.session.create({
+    data: {
+      id: generateInviteCode(),
+      classId,
+      expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000),
+    },
+  });
+
+  return { code: session.id };
+}
+
+export async function getGrades(
+  userId: string,
+  classId: string,
+  targetUserId: string
+) {
+  const isTeacher = await isTeacherInClass(classId, userId);
+  if (userId !== targetUserId && !isTeacher) {
+    throw new TRPCError({
+      code: "UNAUTHORIZED",
+      message: "You can only view your own grades",
+    });
+  }
+
+  const grades = await findSubmissionsForGrades(targetUserId, classId);
+  return { grades };
+}
+
+export async function updateGrade(
+  assignmentId: string,
+  submissionId: string,
+  gradeReceived: number | null
+) {
+  const updatedSubmission = await prisma.submission.update({
+    where: { id: submissionId, assignmentId },
+    data: { gradeReceived },
+    include: {
+      assignment: {
+        select: {
+          id: true,
+          title: true,
+          maxGrade: true,
+          weight: true,
+        },
+      },
+    },
+  });
+  return updatedSubmission;
+}
+
+export async function getEvents(classId: string) {
+  return findEventsByClassId(classId);
+}
+
+export async function listMarkSchemes(classId: string) {
+  return findMarkSchemesByClassId(classId);
+}
+
+export async function createMarkScheme(classId: string, structure: string) {
+  const validatedStructure = structure.replace(/\\n/g, "\n");
+  return prisma.markScheme.create({
+    data: {
+      class: { connect: { id: classId } },
+      structured: validatedStructure,
+    },
+  });
+}
+
+export async function updateMarkScheme(
+  markSchemeId: string,
+  classId: string,
+  structure: string
+) {
+  const validatedStructure = structure.replace(/\\n/g, "\n");
+  return prisma.markScheme.update({
+    where: { id: markSchemeId },
+    data: {
+      class: { connect: { id: classId } },
+      structured: validatedStructure,
+    },
+  });
+}
+
+export async function deleteMarkScheme(markSchemeId: string) {
+  return prisma.markScheme.delete({
+    where: { id: markSchemeId },
+  });
+}
+
+export async function listGradingBoundaries(classId: string) {
+  return findGradingBoundariesByClassId(classId);
+}
+
+export async function createGradingBoundary(classId: string, structure: string) {
+  const validatedStructure = structure.replace(/\\n/g, "\n");
+  return prisma.gradingBoundary.create({
+    data: {
+      class: { connect: { id: classId } },
+      structured: validatedStructure,
+    },
+  });
+}
+
+export async function updateGradingBoundary(
+  gradingBoundaryId: string,
+  classId: string,
+  structure: string
+) {
+  const validatedStructure = structure.replace(/\\n/g, "\n");
+  return prisma.gradingBoundary.update({
+    where: { id: gradingBoundaryId },
+    data: {
+      class: { connect: { id: classId } },
+      structured: validatedStructure,
+    },
+  });
+}
+
+export async function deleteGradingBoundary(gradingBoundaryId: string) {
+  return prisma.gradingBoundary.delete({
+    where: { id: gradingBoundaryId },
+  });
+}
+
+export async function getSyllabus(classId: string) {
+  const classData = await findClassSyllabus(classId);
+  const markSchemes = await findMarkSchemesByClassId(classId);
+  const gradingBoundaries = await findGradingBoundariesByClassId(classId);
+  return {
+    syllabus: classData?.syllabus,
+    gradingBoundaries,
+    markSchemes,
+  };
+}
+
+export async function updateSyllabus(classId: string, contents: string) {
+  if (!contents) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Missing key contents",
+    });
+  }
+  return prisma.class.update({
+    where: { id: classId },
+    data: { syllabus: contents },
+  });
+}
+
+export async function listLabDrafts(classId: string, teacherId: string) {
+  return findLabDraftsByClass(classId, teacherId);
+}
+
+export async function createLabDraft(
+  classId: string,
+  teacherId: string,
+  input: {
+    title: string;
+    type: string;
+    instructions: string;
+    dueDate?: Date;
+    maxGrade?: number;
+    weight?: number;
+    graded?: boolean;
+    sectionId?: string;
+    markSchemeId?: string;
+    gradingBoundaryId?: string;
+  }
+) {
+  return prisma.assignment.create({
+    data: {
+      classId,
+      teacherId,
+      inProgress: true,
+      graded: input.graded ?? false,
+      maxGrade: input.maxGrade ?? 0,
+      weight: input.weight ?? 1,
+      dueDate:
+        input.dueDate ||
+        new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
+      title: input.title,
+      instructions: input.instructions,
+      type: input.type as any,
+      ...(input.sectionId && { sectionId: input.sectionId }),
+      ...(input.markSchemeId && { markSchemeId: input.markSchemeId }),
+      ...(input.gradingBoundaryId && {
+        gradingBoundaryId: input.gradingBoundaryId,
+      }),
+    },
+  });
+}
+
+export async function updateLabDraft(
+  classId: string,
+  teacherId: string,
+  draftId: string,
+  input: Record<string, unknown>
+) {
+  const updateData: Record<string, unknown> = {
+    modifiedAt: new Date(),
+  };
+  if (input.title !== undefined) updateData.title = input.title;
+  if (input.instructions !== undefined)
+    updateData.instructions = input.instructions;
+  if (input.dueDate !== undefined) updateData.dueDate = input.dueDate;
+  if (input.maxGrade !== undefined) updateData.maxGrade = input.maxGrade;
+  if (input.weight !== undefined) updateData.weight = input.weight;
+  if (input.graded !== undefined) updateData.graded = input.graded;
+  if (input.sectionId !== undefined) updateData.sectionId = input.sectionId;
+  if (input.markSchemeId !== undefined)
+    updateData.markSchemeId = input.markSchemeId;
+  if (input.gradingBoundaryId !== undefined)
+    updateData.gradingBoundaryId = input.gradingBoundaryId;
+
+  return prisma.assignment.update({
+    where: {
+      id: draftId,
+      classId,
+      teacherId,
+      inProgress: true,
+    },
+    data: updateData as any,
+  });
+}
+
+export async function deleteLabDraft(
+  classId: string,
+  teacherId: string,
+  draftId: string
+) {
+  return prisma.assignment.delete({
+    where: {
+      id: draftId,
+      classId,
+      teacherId,
+      inProgress: true,
+    },
+  });
+}
+
+export async function publishLabDraft(
+  classId: string,
+  teacherId: string,
+  draftId: string,
+  input: {
+    dueDate?: Date;
+    maxGrade?: number;
+    weight?: number;
+    graded?: boolean;
+  }
+) {
+  const labDraft = await prisma.assignment.findUnique({
+    where: {
+      id: draftId,
+      classId,
+      teacherId,
+      inProgress: true,
+    },
+  });
+
+  if (!labDraft) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Lab draft not found",
+    });
+  }
+
+  return prisma.assignment.update({
+    where: { id: draftId },
+    data: {
+      inProgress: false,
+      dueDate: input.dueDate || labDraft.dueDate,
+      maxGrade: input.maxGrade || labDraft.maxGrade || 100,
+      weight: input.weight || labDraft.weight || 1,
+      graded: input.graded !== undefined ? input.graded : true,
+      modifiedAt: new Date(),
+    },
+  });
+}
+
+export async function getFiles(classId: string) {
+  const assignments = await findAssignmentsWithFiles(classId);
+  return assignments.map((assignment) => ({
+    id: assignment.id,
+    title: assignment.title,
+    teacher: assignment.teacher,
+    teacherAttachments: assignment.attachments,
+    students: assignment.submissions.map((submission) => ({
+      id: submission.student.id,
+      username: submission.student.username,
+      attachments: submission.attachments,
+      annotations: submission.annotations,
+    })),
+  }));
+}
+
+export async function exportClass(classId: string, userId: string) {
+  const classExport = await findFullExportableClass(classId);
+  if (!classExport) {
+    throw new TRPCError({
+      code: "INTERNAL_SERVER_ERROR",
+      message: "Failed to export class",
+    });
+  }
+
+  return classExport;
+}
+
+export async function importClass(classId: string, userId: string, year: number, classData: Class & { classFiles: Folder | null }) {
+  const newClassId = await createClassByImport(classId, userId, year, classData);
+  
+
+  if (!newClassId) {
+    throw new TRPCError({
+      code: "INTERNAL_SERVER_ERROR",
+      message: "Failed to import class",
+    });
+  }
+
+  return newClassId;
+}

package/src/services/comment.ts

@@ -0,0 +1,106 @@
+/**
+ * Comment service – get comments, replies, and reactions. Used for announcements and worksheets.
+ */
+import { TRPCError } from "@trpc/server";
+import {
+  findCommentById,
+  findRepliesByCommentId,
+  createComment,
+  findReactionByUserAndComment,
+  upsertReaction,
+  deleteReactionById,
+  findCommentWithAnnouncement,
+  getReactionCountsByCommentId,
+} from "../models/comment.js";
+
+/** Get a comment by ID. */
+export async function getComment(id: string) {
+  const comment = await findCommentById(id);
+  if (!comment) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Comment not found",
+    });
+  }
+  return comment;
+}
+
+/** Get all replies to a comment. */
+export async function getReplies(commentId: string) {
+  return findRepliesByCommentId(commentId);
+}
+
+/** Create a reply to an existing comment. */
+export async function replyToComment(
+  userId: string,
+  parentCommentId: string,
+  content: string
+) {
+  return createComment({
+    parentCommentId,
+    content,
+    authorId: userId,
+  });
+}
+
+/** Add or update a reaction (emoji) on a comment. */
+export async function addReaction(
+  userId: string,
+  commentId: string,
+  type: string
+) {
+  const comment = await findCommentById(commentId);
+  if (!comment) {
+    throw new TRPCError({
+      code: "INTERNAL_SERVER_ERROR",
+      message: "Unexpected error",
+    });
+  }
+
+  const reaction = await upsertReaction({ userId, commentId, type });
+  return { reaction };
+}
+
+/** Remove user's reaction from a comment. */
+export async function removeReaction(userId: string, commentId: string) {
+  const reaction = await findReactionByUserAndComment(userId, commentId);
+  if (!reaction) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Reaction not found",
+    });
+  }
+  await deleteReactionById(reaction.id);
+  return { success: true };
+}
+
+export async function getReactions(userId: string, commentId: string) {
+  const comment = await findCommentWithAnnouncement(commentId);
+  if (!comment) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Comment not found",
+    });
+  }
+
+  const reactionCounts = await getReactionCountsByCommentId(commentId);
+  const userReaction = await findReactionByUserAndComment(userId, commentId);
+
+  const counts = {
+    THUMBSUP: 0,
+    CELEBRATE: 0,
+    CARE: 0,
+    HEART: 0,
+    IDEA: 0,
+    HAPPY: 0,
+  };
+  reactionCounts.forEach((item) => {
+    counts[item.type as keyof typeof counts] = item._count.type;
+  });
+
+  return {
+    counts,
+    userReaction: userReaction?.type || null,
+    total: reactionCounts.reduce((sum, item) => sum + item._count.type, 0),
+  };
+}