@studious-lms/server 1.0.6 → 1.0.7

package/src/routers/_app.ts

@@ -11,6 +11,8 @@ import { eventRouter } from "./event";
 import { authRouter } from "./auth";
 import { agendaRouter } from "./agenda";
 import { fileRouter } from "./file";
+import { folderRouter } from "./folder";
+import { notificationRouter } from "./notifications";
 
 export const appRouter = createTRPCRouter({
   class: classRouter,
@@ -23,7 +25,9 @@ export const appRouter = createTRPCRouter({
   auth: authRouter,
   agenda: agendaRouter,
   file: fileRouter,
-});
+  folder: folderRouter,
+  notification: notificationRouter,
+}); 
 
 // Export type router type definition
 export type AppRouter = typeof appRouter;

package/src/routers/assignment.ts

@@ -18,6 +18,7 @@ const createAssignmentSchema = z.object({
   instructions: z.string(),
   dueDate: z.string(),
   files: z.array(fileSchema).optional(),
+  existingFileIds: z.array(z.string()).optional(),
   maxGrade: z.number().optional(),
   graded: z.boolean().optional(),
   weight: z.number().optional(),
@@ -25,6 +26,7 @@ const createAssignmentSchema = z.object({
   type: z.enum(['HOMEWORK', 'QUIZ', 'TEST', 'PROJECT', 'ESSAY', 'DISCUSSION', 'PRESENTATION', 'LAB', 'OTHER']).optional(),
   markSchemeId: z.string().optional(),
   gradingBoundaryId: z.string().optional(),
+  inProgress: z.boolean().optional(),
 });
 
 const updateAssignmentSchema = z.object({
@@ -34,12 +36,14 @@ const updateAssignmentSchema = z.object({
   instructions: z.string().optional(),
   dueDate: z.string().optional(),
   files: z.array(fileSchema).optional(),
+  existingFileIds: z.array(z.string()).optional(),
   removedAttachments: z.array(z.string()).optional(),
   maxGrade: z.number().optional(),
   graded: z.boolean().optional(),
   weight: z.number().optional(),
   sectionId: z.string().nullable().optional(),
   type: z.enum(['HOMEWORK', 'QUIZ', 'TEST', 'PROJECT', 'ESSAY', 'DISCUSSION', 'PRESENTATION', 'LAB', 'OTHER']).optional(),
+  inProgress: z.boolean().optional(),
 });
 
 const deleteAssignmentSchema = z.object({
@@ -58,6 +62,7 @@ const submissionSchema = z.object({
   submissionId: z.string(),
   submit: z.boolean().optional(),
   newAttachments: z.array(fileSchema).optional(),
+  existingFileIds: z.array(z.string()).optional(),
   removedAttachments: z.array(z.string()).optional(),
 });
 
@@ -68,6 +73,7 @@ const updateSubmissionSchema = z.object({
   return: z.boolean().optional(),
   gradeReceived: z.number().nullable().optional(),
   newAttachments: z.array(fileSchema).optional(),
+  existingFileIds: z.array(z.string()).optional(),
   removedAttachments: z.array(z.string()).optional(),
   rubricGrades: z.array(z.object({
     criteriaId: z.string(),
@@ -81,7 +87,7 @@ export const assignmentRouter = createTRPCRouter({
   create: protectedProcedure
     .input(createAssignmentSchema)
     .mutation(async ({ ctx, input }) => {
-      const { classId, title, instructions, dueDate, files, maxGrade, graded, weight, sectionId, type, markSchemeId, gradingBoundaryId } = input;
+      const { classId, title, instructions, dueDate, files, existingFileIds, maxGrade, graded, weight, sectionId, type, markSchemeId, gradingBoundaryId, inProgress } = input;
 
       if (!ctx.user) {
         throw new TRPCError({
@@ -107,20 +113,24 @@ export const assignmentRouter = createTRPCRouter({
         });
       }
 
-      const rubric = await prisma.markScheme.findUnique({
-        where: { id: markSchemeId },
-        select: {
-          structured: true,
-        }
-      });
+      let computedMaxGrade = maxGrade;
+      if (markSchemeId) {
+        const rubric = await prisma.markScheme.findUnique({
+          where: { id: markSchemeId },
+          select: {
+            structured: true,
+          }
+        });
 
-      const parsedRubric = JSON.parse(rubric?.structured || "{}");
+        const parsedRubric = JSON.parse(rubric?.structured || "{}");
 
-      // Calculate max grade from rubric criteria levels
-      const computedMaxGrade = parsedRubric.criteria.reduce((acc: number, criterion: any) => {
-        const maxPoints = Math.max(...criterion.levels.map((level: any) => level.points));
-        return acc + maxPoints;
-      }, 0);
+        // Calculate max grade from rubric criteria levels
+        computedMaxGrade = parsedRubric.criteria.reduce((acc: number, criterion: any) => {
+          const maxPoints = Math.max(...criterion.levels.map((level: any) => level.points));
+          return acc + maxPoints;
+        }, 0);
+      }
+      console.log(markSchemeId, gradingBoundaryId);
 
       // Create assignment with submissions for all students
       const assignment = await prisma.assignment.create({
@@ -132,6 +142,7 @@ export const assignmentRouter = createTRPCRouter({
           graded,
           weight,
           type,
+          inProgress: inProgress || false,
           class: {
             connect: { id: classId }
           },
@@ -197,11 +208,12 @@ export const assignmentRouter = createTRPCRouter({
           }
         }
       });
+
       // Upload files if provided
       let uploadedFiles: UploadedFile[] = [];
       if (files && files.length > 0) {
         // Store files in a class and assignment specific directory
-        uploadedFiles = await uploadFiles(files, ctx.user.id, `class/${classId}/assignment/${assignment.id}`);
+        uploadedFiles = await uploadFiles(files, ctx.user.id);
       }
 
       // Update assignment with new file attachments
@@ -226,12 +238,24 @@ export const assignmentRouter = createTRPCRouter({
         });
       }
 
+      // Connect existing files if provided
+      if (existingFileIds && existingFileIds.length > 0) {
+        await prisma.assignment.update({
+          where: { id: assignment.id },
+          data: {
+            attachments: {
+              connect: existingFileIds.map(fileId => ({ id: fileId }))
+            }
+          }
+        });
+      }
+
       return assignment;
     }),
   update: protectedProcedure
     .input(updateAssignmentSchema)
     .mutation(async ({ ctx, input }) => {
-      const { id, title, instructions, dueDate, files, maxGrade, graded, weight, sectionId, type } = input;
+      const { id, title, instructions, dueDate, files, existingFileIds, maxGrade, graded, weight, sectionId, type, inProgress } = input;
 
       if (!ctx.user) {
         throw new TRPCError({
@@ -252,6 +276,8 @@ export const assignmentRouter = createTRPCRouter({
               id: true,
               name: true,
               type: true,
+              path: true,
+              size: true,
               thumbnail: {
                 select: {
                   path: true
@@ -279,7 +305,7 @@ export const assignmentRouter = createTRPCRouter({
       let uploadedFiles: UploadedFile[] = [];
       if (files && files.length > 0) {
         // Store files in a class and assignment specific directory
-        uploadedFiles = await uploadFiles(files, ctx.user.id, `class/${assignment.classId}/assignment/${id}`);
+        uploadedFiles = await uploadFiles(files, ctx.user.id);
       }
 
       // Update assignment
@@ -293,6 +319,7 @@ export const assignmentRouter = createTRPCRouter({
           ...(graded !== undefined && { graded }),
           ...(weight && { weight }),
           ...(type && { type }),
+          ...(inProgress !== undefined && { inProgress }),
           ...(sectionId !== undefined && {
             section: sectionId ? {
               connect: { id: sectionId }
@@ -315,6 +342,11 @@ export const assignmentRouter = createTRPCRouter({
               }))
             }
           }),
+          ...(existingFileIds && existingFileIds.length > 0 && {
+            attachments: {
+              connect: existingFileIds.map(fileId => ({ id: fileId }))
+            }
+          }),
           ...(input.removedAttachments && input.removedAttachments.length > 0 && {
             attachments: {
               deleteMany: {
@@ -348,7 +380,11 @@ export const assignmentRouter = createTRPCRouter({
               id: true,
               name: true,
               type: true,
-              thumbnail: true
+              thumbnail: true,
+              size: true,
+              path: true,
+              uploadedAt: true,
+              thumbnailId: true,
             }
           },
           section: true,
@@ -497,6 +533,7 @@ export const assignmentRouter = createTRPCRouter({
               type: true,
               size: true,
               path: true,
+              uploadedAt: true,
               thumbnailId: true,
             }
           },
@@ -740,7 +777,7 @@ export const assignmentRouter = createTRPCRouter({
         });
       }
 
-      const { submissionId, submit, newAttachments, removedAttachments } = input;
+      const { submissionId, submit, newAttachments, existingFileIds, removedAttachments } = input;
 
       const submission = await prisma.submission.findFirst({
         where: {
@@ -837,7 +874,7 @@ export const assignmentRouter = createTRPCRouter({
       let uploadedFiles: UploadedFile[] = [];
       if (newAttachments && newAttachments.length > 0) {
         // Store files in a class and assignment specific directory
-        uploadedFiles = await uploadFiles(newAttachments, ctx.user.id, `class/${submission.assignment.classId}/assignment/${submission.assignmentId}/submission/${submission.id}`);
+        uploadedFiles = await uploadFiles(newAttachments, ctx.user.id);
       }
 
       // Update submission with new file attachments
@@ -862,6 +899,18 @@ export const assignmentRouter = createTRPCRouter({
         });
       }
 
+      // Connect existing files if provided
+      if (existingFileIds && existingFileIds.length > 0) {
+        await prisma.submission.update({
+          where: { id: submission.id },
+          data: {
+            attachments: {
+              connect: existingFileIds.map(fileId => ({ id: fileId }))
+            }
+          }
+        });
+      }
+
       // Delete removed attachments if any
       if (removedAttachments && removedAttachments.length > 0) {
         const filesToDelete = submission.attachments.filter((file) => 
@@ -1003,7 +1052,7 @@ export const assignmentRouter = createTRPCRouter({
         });
       }
 
-      const { submissionId, return: returnSubmission, gradeReceived, newAttachments, removedAttachments, rubricGrades } = input;
+      const { submissionId, return: returnSubmission, gradeReceived, newAttachments, existingFileIds, removedAttachments, rubricGrades } = input;
 
       const submission = await prisma.submission.findFirst({
         where: {
@@ -1093,7 +1142,7 @@ export const assignmentRouter = createTRPCRouter({
       let uploadedFiles: UploadedFile[] = [];
       if (newAttachments && newAttachments.length > 0) {
         // Store files in a class and assignment specific directory
-        uploadedFiles = await uploadFiles(newAttachments, ctx.user.id, `class/${submission.assignment.classId}/assignment/${submission.assignmentId}/submission/${submission.id}/annotations`);
+        uploadedFiles = await uploadFiles(newAttachments, ctx.user.id);
       }
 
       // Update submission with new file attachments
@@ -1118,6 +1167,18 @@ export const assignmentRouter = createTRPCRouter({
         });
       }
 
+      // Connect existing files if provided
+      if (existingFileIds && existingFileIds.length > 0) {
+        await prisma.submission.update({
+          where: { id: submission.id },
+          data: {
+            annotations: {
+              connect: existingFileIds.map(fileId => ({ id: fileId }))
+            }
+          }
+        });
+      }
+
       // Delete removed attachments if any
       if (removedAttachments && removedAttachments.length > 0) {
         const filesToDelete = submission.annotations.filter((file) => 
@@ -1552,7 +1613,6 @@ export const assignmentRouter = createTRPCRouter({
 
       return updatedAssignment;
     }),
-
     attachGradingBoundary: protectedTeacherProcedure
     .input(z.object({
       assignmentId: z.string(),

package/src/routers/auth.ts

@@ -5,6 +5,7 @@ import { prisma } from "../lib/prisma";
 import { v4 as uuidv4 } from 'uuid';
 import { compare, hash } from "bcryptjs";
 import { transport } from "../utils/email";
+import { prismaWrapper } from "../utils/prismaWrapper";
 
 const loginSchema = z.object({
   username: z.string(),
@@ -28,20 +29,23 @@ export const authRouter = createTRPCRouter({
       const { username, email, password } = input;
 
       // Check if username already exists
-      const existingUser = await prisma.user.findFirst({
-        where: { 
-          OR: [
-            { username },
-            { email }
-          ]
-        },
-        select: {
-          id: true,
-          username: true,
-          email: true,
-          verified: true,
-        }
-      });
+      const existingUser = await prismaWrapper.findFirst(
+        () => prisma.user.findFirst({
+          where: { 
+            OR: [
+              { username },
+              { email }
+            ]
+          },
+          select: {
+            id: true,
+            username: true,
+            email: true,
+            verified: true,
+          }
+        }),
+        'checking for existing user during registration'
+      );
 
       if (existingUser && existingUser.verified) {
         if (existingUser.username === username) {
@@ -57,44 +61,59 @@ export const authRouter = createTRPCRouter({
           });
         }
       } else if (existingUser && !existingUser.verified) {
-        await prisma.session.deleteMany({
-          where: { userId: existingUser.id },
-        });
-
-        await prisma.user.delete({
-          where: { id: existingUser.id },
-        });
+        await prismaWrapper.deleteMany(
+          () => prisma.session.deleteMany({
+            where: { userId: existingUser.id },
+          }),
+          'deleting existing sessions for unverified user'
+        );
+
+        await prismaWrapper.delete(
+          () => prisma.user.delete({
+            where: { id: existingUser.id },
+          }),
+          'deleting unverified user'
+        );
       }
 
       // Create new user
-      const user = await prisma.user.create({
-        data: {
-          username,
-          email,
-          password: await hash(password, 10),
-          profile: {},
-        },
-        select: {
-          id: true,
-          username: true,
-          email: true,
-        }
-      });
+      const user = await prismaWrapper.create(
+        async () => await prisma.user.create({
+          data: {
+            username,
+            email,
+            password: await hash(password, 10),
+            profile: {},
+            verified: true, // temporary
+          },
+          select: {
+            id: true,
+            username: true,
+            email: true,
+          }
+        }),
+        'creating new user during registration'
+      );
 
-      const verificationToken = await prisma.session.create({
-        data: {
-          id: uuidv4(),
-          userId: user.id,
-          expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 30),
-        },
-      });
+      const verificationToken = await prismaWrapper.create(
+        () => prisma.session.create({
+          data: {
+            id: uuidv4(),
+            userId: user.id,
+            expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 30),
+          },
+        }),
+        'creating verification token'
+      );
 
-      await transport.sendMail({
-        from: 'noreply@studious.sh',
-        to: user.email,
-        subject: 'Verify your email',
-        text: `Click the link to verify your email: ${process.env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`,
-      });
+      // await transport.sendMail({
+      //   from: 'noreply@studious.sh',
+      //   to: user.email,
+      //   subject: 'Verify your email',
+      //   text: `Click the link to verify your email: ${process.env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`,
+      // });
+
+      console.log(`${process.env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`)
 
       return {
         user: {
@@ -127,7 +146,7 @@ export const authRouter = createTRPCRouter({
         });
       }
 
-      if (await compare(password, user.password)) {
+      if (!(await compare(password, user.password))) {
         throw new TRPCError({
           code: "UNAUTHORIZED",
           message: "Invalid username or password",
@@ -218,6 +237,8 @@ export const authRouter = createTRPCRouter({
           select: {
             id: true,
             email: true,
+            role: true,
+            schoolId: true,
           },
         });
 
@@ -240,12 +261,12 @@ export const authRouter = createTRPCRouter({
           },
         });
         
-        await transport.sendMail({
-          from: 'noreply@studious.sh',
-          to: user.email,
-          subject: 'Verify your email',
-          text: `Click the link to verify your email: ${process.env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`,
-        });
+        // await transport.sendMail({
+        //   from: 'noreply@studious.sh',
+        //   to: user.email,
+        //   subject: 'Verify your email',
+        //   text: `Click the link to verify your email: ${process.env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`,
+        // });
 
         return { success: true };
       }),
@@ -281,6 +302,11 @@ export const authRouter = createTRPCRouter({
           },
         });
 
+        // Clean up the verification token
+        await prisma.session.delete({
+          where: { id: token },
+        });
+
         return { success: true };
       }),
 });