@studious-lms/server 1.0.0

package/dist/routers/class.js

@@ -0,0 +1,693 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classRouter = void 0;
+const zod_1 = require("zod");
+const trpc_1 = require("../trpc");
+const prisma_1 = require("@lib/prisma");
+const server_1 = require("@trpc/server");
+const generateInviteCode_1 = require("@/utils/generateInviteCode");
+exports.classRouter = (0, trpc_1.createTRPCRouter)({
+    getAll: trpc_1.protectedProcedure
+        .query(async ({ ctx }) => {
+        const [teacherClasses, studentClasses] = await Promise.all([
+            prisma_1.prisma.class.findMany({
+                where: {
+                    teachers: {
+                        some: {
+                            id: ctx.user?.id,
+                        },
+                    },
+                },
+                include: {
+                    assignments: {
+                        where: {
+                            dueDate: {
+                                equals: new Date(new Date().setHours(0, 0, 0, 0)),
+                            },
+                        },
+                        select: {
+                            id: true,
+                            title: true,
+                        },
+                    },
+                },
+            }),
+            prisma_1.prisma.class.findMany({
+                where: {
+                    students: {
+                        some: {
+                            id: ctx.user?.id,
+                        },
+                    },
+                },
+                include: {
+                    assignments: {
+                        where: {
+                            dueDate: {
+                                equals: new Date(new Date().setHours(0, 0, 0, 0)),
+                            },
+                        },
+                        select: {
+                            id: true,
+                            title: true,
+                        },
+                    },
+                },
+            }),
+        ]);
+        const adminClasses = await prisma_1.prisma.class.findMany({
+            where: {
+                teachers: {
+                    some: {
+                        id: ctx.user?.id,
+                    },
+                },
+            },
+            include: {
+                assignments: {
+                    where: {
+                        dueDate: {
+                            equals: new Date(new Date().setHours(0, 0, 0, 0)),
+                        },
+                    },
+                    select: {
+                        id: true,
+                        title: true,
+                    },
+                },
+            },
+        });
+        return {
+            teacherInClass: teacherClasses.map(cls => ({
+                id: cls.id,
+                name: cls.name,
+                section: cls.section,
+                subject: cls.subject,
+                dueToday: cls.assignments,
+                color: cls.color,
+            })),
+            studentInClass: studentClasses.map(cls => ({
+                id: cls.id,
+                name: cls.name,
+                section: cls.section,
+                subject: cls.subject,
+                dueToday: cls.assignments,
+                color: cls.color,
+            })),
+            adminInClass: adminClasses.map(cls => ({
+                id: cls.id,
+                name: cls.name,
+                section: cls.section,
+                subject: cls.subject,
+                dueToday: cls.assignments,
+                color: cls.color,
+            })),
+        };
+    }),
+    get: trpc_1.protectedProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+    }))
+        .query(async ({ ctx, input }) => {
+        const { classId } = input;
+        const classData = await prisma_1.prisma.class.findUnique({
+            where: {
+                id: classId,
+            },
+            include: {
+                teachers: {
+                    select: {
+                        id: true,
+                        username: true,
+                    },
+                },
+                students: {
+                    select: {
+                        id: true,
+                        username: true,
+                    },
+                },
+                announcements: {
+                    orderBy: {
+                        createdAt: 'desc',
+                    },
+                    select: {
+                        id: true,
+                        remarks: true,
+                        createdAt: true,
+                        teacher: {
+                            select: {
+                                id: true,
+                                username: true,
+                            },
+                        },
+                    },
+                },
+                assignments: {
+                    select: {
+                        type: true,
+                        id: true,
+                        title: true,
+                        dueDate: true,
+                        createdAt: true,
+                        weight: true,
+                        graded: true,
+                        maxGrade: true,
+                        instructions: true,
+                        section: {
+                            select: {
+                                id: true,
+                                name: true,
+                            },
+                        },
+                        markScheme: {
+                            select: {
+                                id: true,
+                                structured: true,
+                            },
+                        },
+                        gradingBoundary: {
+                            select: {
+                                id: true,
+                                structured: true,
+                            },
+                        },
+                        submissions: {
+                            where: {
+                                studentId: ctx.user?.id,
+                            },
+                            select: {
+                                studentId: true,
+                                id: true,
+                                submitted: true,
+                                returned: true,
+                                submittedAt: true,
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        const sections = await prisma_1.prisma.section.findMany({
+            where: {
+                classId: classId,
+            },
+        });
+        if (!classData) {
+            throw new Error('Class not found');
+        }
+        return {
+            class: {
+                ...classData,
+                assignments: classData.assignments.map(assignment => ({
+                    ...assignment,
+                    late: assignment.dueDate < new Date(),
+                    submitted: assignment.submissions.some(submission => submission.studentId === ctx.user?.id),
+                    returned: assignment.submissions.some(submission => submission.studentId === ctx.user?.id && submission.returned),
+                })),
+                sections,
+            },
+        };
+    }),
+    update: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+        name: zod_1.z.string().optional(),
+        section: zod_1.z.string().optional(),
+        subject: zod_1.z.string().optional(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { classId, ...updateData } = input;
+        const updatedClass = await prisma_1.prisma.class.update({
+            where: {
+                id: classId,
+            },
+            data: updateData,
+            select: {
+                id: true,
+                name: true,
+                section: true,
+                subject: true,
+            }
+        });
+        return {
+            updatedClass,
+        };
+    }),
+    create: trpc_1.protectedProcedure
+        .input(zod_1.z.object({
+        students: zod_1.z.array(zod_1.z.string()).optional(),
+        teachers: zod_1.z.array(zod_1.z.string()).optional(),
+        name: zod_1.z.string(),
+        section: zod_1.z.string(),
+        subject: zod_1.z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { students, teachers, name, section, subject } = input;
+        if (teachers && teachers.length > 0 && students && students.length > 0) {
+            const newClass = await prisma_1.prisma.class.create({
+                data: {
+                    name,
+                    section,
+                    subject,
+                    teachers: {
+                        connect: teachers.map(teacher => ({ id: teacher })),
+                    },
+                    students: {
+                        connect: students.map(student => ({ id: student })),
+                    },
+                },
+                include: {
+                    teachers: true,
+                    students: true,
+                },
+            });
+            return newClass;
+        }
+        const newClass = await prisma_1.prisma.class.create({
+            data: {
+                name,
+                section,
+                subject,
+                teachers: {
+                    connect: {
+                        id: ctx.user?.id,
+                    },
+                },
+            },
+        });
+        return newClass;
+    }),
+    delete: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+        id: zod_1.z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        // Verify user is the teacher of this class
+        const classToDelete = await prisma_1.prisma.class.findFirst({
+            where: {
+                id: input.id,
+            },
+        });
+        if (!classToDelete) {
+            throw new Error("Class not found or you don't have permission to delete it");
+        }
+        await prisma_1.prisma.class.delete({
+            where: {
+                id: input.id,
+            },
+        });
+        return {
+            deletedClass: {
+                id: input.id,
+            }
+        };
+    }),
+    addStudent: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+        studentId: zod_1.z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { classId, studentId } = input;
+        const student = await prisma_1.prisma.user.findUnique({
+            where: {
+                id: studentId,
+            },
+        });
+        if (!student) {
+            throw new Error("Student not found");
+        }
+        const updatedClass = await prisma_1.prisma.class.update({
+            where: {
+                id: classId,
+            },
+            data: {
+                students: {
+                    connect: {
+                        id: studentId,
+                    },
+                },
+            },
+            select: {
+                id: true,
+                name: true,
+                section: true,
+                subject: true,
+            }
+        });
+        return {
+            updatedClass,
+            newStudent: student,
+        };
+    }),
+    changeRole: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+        userId: zod_1.z.string(),
+        type: zod_1.z.enum(['teacher', 'student']),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { classId, userId, type } = input;
+        const user = await prisma_1.prisma.user.findUnique({
+            where: { id: userId },
+            select: {
+                id: true,
+                username: true,
+            },
+        });
+        if (!user) {
+            throw new Error("User not found");
+        }
+        const updatedClass = await prisma_1.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,
+            },
+        };
+    }),
+    removeMember: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+        userId: zod_1.z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { classId, userId } = input;
+        const updatedClass = await prisma_1.prisma.class.update({
+            where: { id: classId },
+            data: {
+                teachers: {
+                    disconnect: { id: userId },
+                },
+                students: {
+                    disconnect: { id: userId },
+                },
+            },
+        });
+        return {
+            updatedClass,
+            removedUserId: userId,
+        };
+    }),
+    join: trpc_1.protectedProcedure
+        .input(zod_1.z.object({
+        classCode: zod_1.z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { classCode } = input;
+        const session = await prisma_1.prisma.session.findFirst({
+            where: {
+                id: 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_1.prisma.class.update({
+            where: { id: session.classId },
+            data: {
+                students: {
+                    connect: { id: ctx.user?.id },
+                },
+            },
+            select: {
+                id: true,
+                name: true,
+                section: true,
+                subject: true,
+            },
+        });
+        return {
+            joinedClass: updatedClass,
+        };
+    }),
+    getInviteCode: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+    }))
+        .query(async ({ ctx, input }) => {
+        const { classId } = input;
+        const session = await prisma_1.prisma.session.findFirst({
+            where: {
+                classId,
+            },
+        });
+        if ((session?.expiresAt && session.expiresAt < new Date()) || !session) {
+            const newSession = await prisma_1.prisma.session.create({
+                data: {
+                    id: (0, generateInviteCode_1.generateInviteCode)(),
+                    classId,
+                    expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24 hours from now
+                }
+            });
+            return {
+                code: newSession.id,
+            };
+        }
+        return {
+            code: session?.id,
+        };
+    }),
+    createInviteCode: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { classId } = input;
+        // Create a new session for the invite code
+        const session = await prisma_1.prisma.session.create({
+            data: {
+                id: (0, generateInviteCode_1.generateInviteCode)(),
+                classId,
+                expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24 hours from now
+            }
+        });
+        return {
+            code: session.id,
+        };
+    }),
+    getGrades: trpc_1.protectedClassMemberProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+        userId: zod_1.z.string(),
+    }))
+        .query(async ({ ctx, input }) => {
+        const { classId, userId } = input;
+        const isTeacher = await prisma_1.prisma.class.findFirst({
+            where: {
+                id: classId,
+                teachers: {
+                    some: { id: ctx.user?.id }
+                }
+            }
+        });
+        // If student, only allow viewing their own grades
+        if (ctx.user?.id !== userId && !isTeacher) {
+            throw new server_1.TRPCError({
+                code: 'UNAUTHORIZED',
+                message: 'You can only view your own grades',
+            });
+        }
+        const grades = await prisma_1.prisma.submission.findMany({
+            where: {
+                studentId: userId,
+                assignment: {
+                    classId: classId,
+                    graded: true
+                }
+            },
+            include: {
+                assignment: {
+                    select: {
+                        id: true,
+                        title: true,
+                        maxGrade: true,
+                        weight: true,
+                    }
+                },
+            }
+        });
+        return {
+            grades,
+        };
+    }),
+    updateGrade: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+        assignmentId: zod_1.z.string(),
+        submissionId: zod_1.z.string(),
+        gradeReceived: zod_1.z.number().nullable(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { classId, assignmentId, submissionId, gradeReceived } = input;
+        // Update the grade
+        const updatedSubmission = await prisma_1.prisma.submission.update({
+            where: {
+                id: submissionId,
+                assignmentId: assignmentId,
+            },
+            data: {
+                gradeReceived,
+            },
+            include: {
+                assignment: {
+                    select: {
+                        id: true,
+                        title: true,
+                        maxGrade: true,
+                        weight: true,
+                    }
+                }
+            }
+        });
+        return updatedSubmission;
+    }),
+    getEvents: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+    }))
+        .query(async ({ ctx, input }) => {
+        const { classId } = input;
+        const events = await prisma_1.prisma.event.findMany({
+            where: {
+                class: {
+                    id: classId,
+                }
+            },
+            select: {
+                name: true,
+                startTime: true,
+                endTime: true,
+            }
+        });
+        return events;
+    }),
+    listMarkSchemes: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+    }))
+        .query(async ({ ctx, input }) => {
+        const { classId } = input;
+        const markSchemes = await prisma_1.prisma.markScheme.findMany({
+            where: {
+                classId: classId,
+            },
+        });
+        return markSchemes;
+    }),
+    createMarkScheme: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+        structure: zod_1.z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { classId, structure } = input;
+        const validatedStructure = structure.replace(/\\n/g, '\n');
+        const markScheme = await prisma_1.prisma.markScheme.create({
+            data: {
+                classId: classId,
+                structured: validatedStructure,
+            },
+        });
+        return markScheme;
+    }),
+    updateMarkScheme: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+        markSchemeId: zod_1.z.string(),
+        structure: zod_1.z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { classId, markSchemeId, structure } = input;
+        const validatedStructure = structure.replace(/\\n/g, '\n');
+        const markScheme = await prisma_1.prisma.markScheme.update({
+            where: { id: markSchemeId },
+            data: { structured: validatedStructure },
+        });
+        return markScheme;
+    }),
+    deleteMarkScheme: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+        markSchemeId: zod_1.z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { classId, markSchemeId } = input;
+        const markScheme = await prisma_1.prisma.markScheme.delete({
+            where: { id: markSchemeId },
+        });
+        return markScheme;
+    }),
+    listGradingBoundaries: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+    }))
+        .query(async ({ ctx, input }) => {
+        const { classId } = input;
+        const gradingBoundaries = await prisma_1.prisma.gradingBoundary.findMany({
+            where: {
+                classId: classId,
+            },
+        });
+        return gradingBoundaries;
+    }),
+    createGradingBoundary: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+        structure: zod_1.z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { classId, structure } = input;
+        const validatedStructure = structure.replace(/\\n/g, '\n');
+        const gradingBoundary = await prisma_1.prisma.gradingBoundary.create({
+            data: {
+                classId: classId,
+                structured: validatedStructure,
+            },
+        });
+        return gradingBoundary;
+    }),
+    updateGradingBoundary: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+        gradingBoundaryId: zod_1.z.string(),
+        structure: zod_1.z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { classId, gradingBoundaryId, structure } = input;
+        const validatedStructure = structure.replace(/\\n/g, '\n');
+        const gradingBoundary = await prisma_1.prisma.gradingBoundary.update({
+            where: { id: gradingBoundaryId },
+            data: { structured: validatedStructure },
+        });
+        return gradingBoundary;
+    }),
+    deleteGradingBoundary: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+        gradingBoundaryId: zod_1.z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { classId, gradingBoundaryId } = input;
+        const gradingBoundary = await prisma_1.prisma.gradingBoundary.delete({
+            where: { id: gradingBoundaryId },
+        });
+        return gradingBoundary;
+    }),
+});