@studious-lms/server 1.2.33 → 1.2.35

package/src/routers/announcement.ts

@@ -523,7 +523,7 @@ export const announcementRouter = createTRPCRouter({
 
             // If replying to a comment, verify parent comment exists and belongs to the same announcement
             if (input.parentCommentId) {
-                const parentComment = await prisma.announcementComment.findFirst({
+                const parentComment = await prisma.comment.findFirst({
                     where: {
                         id: input.parentCommentId,
                         announcementId: input.announcementId,
@@ -538,7 +538,7 @@ export const announcementRouter = createTRPCRouter({
                 }
             }
 
-            const comment = await prisma.announcementComment.create({
+            const comment = await prisma.comment.create({
                 data: {
                     content: input.content,
                     author: {
@@ -586,7 +586,7 @@ export const announcementRouter = createTRPCRouter({
                 });
             }
 
-            const comment = await prisma.announcementComment.findUnique({
+            const comment = await prisma.comment.findUnique({
                 where: { id: input.id },
             });
 
@@ -605,7 +605,7 @@ export const announcementRouter = createTRPCRouter({
                 });
             }
 
-            const updatedComment = await prisma.announcementComment.update({
+            const updatedComment = await prisma.comment.update({
                 where: { id: input.id },
                 data: {
                     content: input.content,
@@ -642,7 +642,7 @@ export const announcementRouter = createTRPCRouter({
                 });
             }
 
-            const comment = await prisma.announcementComment.findUnique({
+            const comment = await prisma.comment.findUnique({
                 where: { id: input.id },
                 include: {
                     announcement: {
@@ -667,7 +667,7 @@ export const announcementRouter = createTRPCRouter({
             // Only the author or a class teacher can delete comments
             const userId = ctx.user.id;
             const isAuthor = comment.authorId === userId;
-            const isClassTeacher = comment.announcement.class.teachers.some(
+            const isClassTeacher = comment.announcement!.class.teachers.some(
                 (teacher) => teacher.id === userId
             );
 
@@ -678,7 +678,7 @@ export const announcementRouter = createTRPCRouter({
                 });
             }
 
-            await prisma.announcementComment.delete({
+            await prisma.comment.delete({
                 where: { id: input.id },
             });
 
@@ -707,7 +707,7 @@ export const announcementRouter = createTRPCRouter({
             }
 
             // Get all top-level comments (no parent)
-            const comments = await prisma.announcementComment.findMany({
+            const comments = await prisma.comment.findMany({
                 where: {
                     announcementId: input.announcementId,
                     parentCommentId: null,
@@ -840,7 +840,7 @@ export const announcementRouter = createTRPCRouter({
                 return { reaction };
             } else if (input.commentId) {
                 // Verify comment exists and get its announcement to check class
-                const comment = await prisma.announcementComment.findUnique({
+                    const comment = await prisma.comment.findUnique({
                     where: { id: input.commentId },
                     include: {
                         announcement: {
@@ -858,7 +858,7 @@ export const announcementRouter = createTRPCRouter({
                     });
                 }
 
-                if (comment.announcement.classId !== input.classId) {
+                if (comment.announcement!.classId !== input.classId) {
                     throw new TRPCError({
                         code: "FORBIDDEN",
                         message: "Comment does not belong to this class",
@@ -1060,7 +1060,7 @@ export const announcementRouter = createTRPCRouter({
                 };
             } else if (input.commentId) {
                 // Verify comment exists
-                const comment = await prisma.announcementComment.findUnique({
+                const comment = await prisma.comment.findUnique({
                     where: { id: input.commentId },
                     include: {
                         announcement: {
@@ -1078,7 +1078,7 @@ export const announcementRouter = createTRPCRouter({
                     });
                 }
 
-                if (comment.announcement.classId !== input.classId) {
+                if (comment.announcement!.classId !== input.classId) {
                     throw new TRPCError({
                         code: "FORBIDDEN",
                         message: "Comment does not belong to this class",

package/src/routers/comment.ts

@@ -0,0 +1,268 @@
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import { z } from "zod";
+import { prisma } from "../lib/prisma.js";
+import { TRPCError } from "@trpc/server";
+
+export const commentRouter = createTRPCRouter({
+    get: protectedProcedure
+    .input(z.object({
+        id: z.string(),
+    }))
+    .query(async ({ ctx, input }) => {
+        const comment = await prisma.comment.findUnique({
+            where: { id: input.id },
+            select: {
+                replies: {
+                    select: {
+                        id: true,
+                        content: true,
+                        author: {
+                            select: {
+                                id: true,
+                                username: true,
+                                profile: {
+                                    select: {
+                                        displayName: true,
+                                        profilePicture: true,
+                                        profilePictureThumbnail: true,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                reactions: {
+                    select: {
+                        type: true,
+                        user: {
+                            select: {
+                                id: true,
+                                username: true,
+                                profile: {
+                                    select: {
+                                        displayName: true,
+                                        profilePicture: true,
+                                        profilePictureThumbnail: true,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            }
+        });
+        return comment;
+    }),
+    replyToComment: protectedProcedure
+    .input(z.object({
+        parentCommentId: z.string(),
+        content: z.string(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+        const { parentCommentId, content } = input;
+
+        const newComment = await prisma.comment.create({
+            data: {
+                parentCommentId,
+                content,
+                authorId: ctx.user!.id,
+            },
+        });
+
+        return newComment;
+    }), 
+    addReaction: protectedProcedure
+    .input(z.object({
+        id: z.string(),
+        type: z.enum(['THUMBSUP', 'CELEBRATE', 'CARE', 'HEART', 'IDEA', 'HAPPY']),
+    }))
+    .mutation(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+
+        // Exactly one of announcementId or commentId must be provided
+        const comment = await prisma.comment.findUnique({
+            where: { id: input.id },
+        });
+
+        const userId = ctx.user.id;
+
+        // Verify the announcement or comment exists and belongs to the class
+        if (comment) {
+            const announcement = await prisma.announcement.findFirst({
+                where: {
+                    id: input.id,
+                },
+            });
+
+            // Upsert reaction: update if exists, create if not
+            const reaction = await prisma.reaction.upsert({
+                where: {
+                    userId_commentId: {
+                        userId,
+                        commentId: input.id,
+                    },
+                },
+                update: {
+                    type: input.type,
+                },
+                create: {
+                    type: input.type,
+                    userId,
+                    commentId: input.id,
+                },
+                include: {
+                    user: {
+                        select: {
+                            id: true,
+                            username: true,
+                            profile: {
+                                select: {
+                                    displayName: true,
+                                    profilePicture: true,
+                                    profilePictureThumbnail: true,
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+
+            return { reaction };
+        }
+
+        throw new TRPCError({
+            code: "INTERNAL_SERVER_ERROR",
+            message: "Unexpected error",
+        });
+    }),
+
+removeReaction: protectedProcedure
+    .input(z.object({
+        commentId: z.string().optional(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+
+        // Exactly one of announcementId or commentId must be provided
+        if (!input.commentId) {
+            throw new TRPCError({
+                code: "BAD_REQUEST",
+                message: "Either announcementId or commentId must be provided",
+            });
+        }
+
+        const userId = ctx.user.id;
+
+            const reaction = await prisma.reaction.findUnique({
+                where: {
+                    userId_commentId: {
+                        userId,
+                        commentId: input.commentId,
+                    },
+                },
+            });
+
+            if (!reaction) {
+                throw new TRPCError({
+                    code: "NOT_FOUND",
+                    message: "Reaction not found",
+                });
+            }
+
+            await prisma.reaction.delete({
+                where: { id: reaction.id },
+            });
+
+            return { success: true };
+
+    }),
+
+getReactions: protectedProcedure
+    .input(z.object({
+        commentId: z.string().optional(),
+    }))
+    .query(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+
+        // Exactly one of announcementId or commentId must be provided
+        if (!input.commentId) {
+            throw new TRPCError({
+                code: "BAD_REQUEST",
+                message: "Either announcementId or commentId must be provided",
+            });
+        }
+
+        const userId = ctx.user.id;
+
+            // Verify comment exists
+            const comment = await prisma.comment.findUnique({
+                where: { id: input.commentId },
+                include: {
+                    announcement: {
+                        select: {
+                            classId: true,
+                        },
+                    },
+                },
+            });
+
+            if (!comment) {
+                throw new TRPCError({
+                    code: "NOT_FOUND",
+                    message: "Comment not found",
+                });
+            }
+
+            // Get reaction counts by type
+            const reactionCounts = await prisma.reaction.groupBy({
+                by: ['type'],
+                where: { commentId: input.commentId },
+                _count: { type: true },
+            });
+
+            // Get current user's reaction
+            const userReaction = await prisma.reaction.findUnique({
+                where: {
+                    userId_commentId: {
+                        userId,
+                        commentId: input.commentId,
+                    },
+                },
+            });
+
+            // Format counts
+            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),
+            };
+    }),
+});

package/src/routers/worksheet.ts

@@ -1,7 +1,7 @@
 import { TRPCError } from "@trpc/server";
-import { createTRPCRouter, protectedProcedure } from "src/trpc";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
 import { z } from "zod";
-import { prisma } from "src/lib/prisma";
+import { prisma } from "../lib/prisma.js";
 import { WorksheetQuestionType } from "@prisma/client";
 
 export const worksheetRouter = createTRPCRouter({
@@ -18,6 +18,7 @@ export const worksheetRouter = createTRPCRouter({
         include: {
           questions: {
             orderBy: { createdAt: 'asc' },
+            // select: { id: true, type: true, question: true, answer: true, points: true },
           },
           class: true,
         },
@@ -112,12 +113,13 @@ export const worksheetRouter = createTRPCRouter({
       worksheetId: z.string(),
       question: z.string(),
       answer: z.string(),
+      points: z.number().optional(),
       options: z.any().optional(), // JSON field
       markScheme: z.any().optional(), // JSON field
       type: z.enum(['MULTIPLE_CHOICE', 'TRUE_FALSE', 'SHORT_ANSWER', 'LONG_ANSWER', 'MATH_EXPRESSION', 'ESSAY']),
     }))
     .mutation(async ({ ctx, input }) => {
-      const { worksheetId, question, answer, options, markScheme, type } = input;
+      const { worksheetId, question, points, answer, options, markScheme, type } = input;
 
       const worksheet = await prisma.worksheet.findUnique({
         where: { id: worksheetId },
@@ -131,6 +133,7 @@ export const worksheetRouter = createTRPCRouter({
         data: {
           worksheetId,
           type,
+          points,
           question,
           answer,
           options,
@@ -201,12 +204,13 @@ export const worksheetRouter = createTRPCRouter({
       questionId: z.string(),
       question: z.string().optional(),
       answer: z.string().optional(),
+      points: z.number().optional(),
       options: z.any().optional(), // JSON field
       markScheme: z.any().optional(), // JSON field
       type: z.enum(['MULTIPLE_CHOICE', 'TRUE_FALSE', 'SHORT_ANSWER', 'LONG_ANSWER', 'MATH_EXPRESSION', 'ESSAY']).optional(),
     }))
     .mutation(async ({ ctx, input }) => {
-      const { worksheetId, questionId, question, answer, options, markScheme, type } = input;
+      const { worksheetId, questionId, points, question, answer, options, markScheme, type } = input;
 
       const worksheet = await prisma.worksheet.findUnique({
         where: { id: worksheetId },
@@ -224,6 +228,7 @@ export const worksheetRouter = createTRPCRouter({
           ...(markScheme !== undefined && { markScheme }),
           ...(type !== undefined && { type }),
           ...(options !== undefined && { options }),
+          ...(points !== undefined && { points }),
         },
       });
 
@@ -269,7 +274,7 @@ export const worksheetRouter = createTRPCRouter({
       }
 
       // Find or create worksheet response for this submission
-      const worksheetResponses = await prisma.$transaction(async (tx) => {
+      const worksheetResponse = await prisma.$transaction(async (tx) => {
         // First check if a response exists
         const existing = await tx.studentWorksheetResponse.findFirst({
           where: { 
@@ -300,7 +305,9 @@ export const worksheetRouter = createTRPCRouter({
         return created;
       });
 
-      return worksheetResponses;
+
+      console.log(worksheetResponse);
+      return worksheetResponse;
     }),
   answerQuestion: protectedProcedure
     .input(z.object({
@@ -401,104 +408,106 @@ export const worksheetRouter = createTRPCRouter({
       return submittedWorksheet;
     }),
 
-  // Get or create a student's worksheet response
-  getOrCreateWorksheetResponse: protectedProcedure
+  // Grade a student's answer
+  gradeAnswer: protectedProcedure
     .input(z.object({
-      worksheetId: z.string(),
-      studentId: z.string(),
+      questionId: z.string(),
+      responseId: z.string().optional(), // StudentQuestionProgress ID (optional for upsert)
+      studentWorksheetResponseId: z.string(), // Required for linking to worksheet response
+      response: z.string().optional(), // The actual response text (needed if creating new)
+      isCorrect: z.boolean(),
+      feedback: z.string().optional(),
+      markschemeState: z.any().optional(),
+      points: z.number().optional(),
     }))
     .mutation(async ({ ctx, input }) => {
-      const { worksheetId, studentId } = input;
-
-      // Try to find existing response
-      let worksheetResponse = await prisma.studentWorksheetResponse.findFirst({
-        where: {
-          worksheetId,
-          studentId,
-          submitted: false, // Only get unsubmitted responses
-        },
-        include: {
-          responses: {
-            include: {
-              question: true,
-            },
-          },
-        },
-      });
+      const { responseId, questionId, studentWorksheetResponseId, response, isCorrect, feedback, markschemeState, points } = input;
 
-      // Create new response if none exists
-      if (!worksheetResponse) {
-        worksheetResponse = await prisma.studentWorksheetResponse.create({
+      let gradedResponse;
+      
+      if (responseId) {
+        // Update existing progress by ID
+        gradedResponse = await prisma.studentQuestionProgress.update({
+          where: { id: responseId },
           data: {
-            worksheetId,
-            studentId,
-          },
-          include: {
-            responses: {
-              include: {
-                question: true,
-              },
-            },
+            isCorrect,
+            ...(feedback !== undefined && { feedback }),
+            ...(markschemeState !== undefined && { markschemeState }),
+            ...(points !== undefined && { points }),
           },
         });
-      }
+      } else {
+        // Get the studentId from the worksheet response
+        const worksheetResponse = await prisma.studentWorksheetResponse.findUnique({
+          where: { id: studentWorksheetResponseId },
+          select: { studentId: true },
+        });
 
-      return worksheetResponse;
-    }),
+        if (!worksheetResponse) {
+          throw new TRPCError({
+            code: 'NOT_FOUND',
+            message: 'Student worksheet response not found',
+          });
+        }
 
-  // Get all student responses for a worksheet (teacher view)
-  getWorksheetResponse: protectedProcedure
-    .input(z.object({
-      worksheetId: z.string(),
-    }))
-    .query(async ({ ctx, input }) => {
-      const { worksheetId } = input;
+        const { studentId } = worksheetResponse;
 
-      const responses = await prisma.studentWorksheetResponse.findFirst({
-        where: { worksheetId },
-        include: {
-          student: {
-            select: {
-              id: true,
-              username: true,
-              profile: {
-                select: {
-                  displayName: true,
-                  profilePicture: true,
-                },
-              },
-            },
+        // Upsert - find or create the progress record
+        const existing = await prisma.studentQuestionProgress.findFirst({
+          where: {
+            studentId,
+            questionId,
+            studentWorksheetResponseId,
           },
-          responses: {
-            include: {
-              question: true,
+        });
+
+        if (existing) {
+          // Update existing
+          gradedResponse = await prisma.studentQuestionProgress.update({
+            where: { id: existing.id },
+            data: {
+              isCorrect,
+              ...(response !== undefined && { response }),
+              ...(feedback !== undefined && { feedback }),
+              ...(markschemeState !== undefined && { markschemeState }),
+              ...(points !== undefined && { points }),
             },
-          },
-        },
-        orderBy: { submittedAt: 'desc' },
-      });
+          });
+        } else {
+          // Create new
+          gradedResponse = await prisma.studentQuestionProgress.create({
+            data: {
+              studentId,
+              questionId,
+              studentWorksheetResponseId,
+              response: response || '',
+              isCorrect,
+              ...(feedback !== undefined && { feedback }),
+              ...(markschemeState !== undefined && { markschemeState }),
+              ...(points !== undefined && { points: points || 0 }),
+            },
+          });
+        }
+      }
 
-      return responses;
+      return gradedResponse;
     }),
-
-  // Grade a student's answer
-  gradeAnswer: protectedProcedure
+    addComment: protectedProcedure
     .input(z.object({
-      responseId: z.string(), // StudentQuestionProgress ID
-      isCorrect: z.boolean(),
-      feedback: z.string().optional(),
+      responseId: z.string(),
+      comment: z.string(),
     }))
     .mutation(async ({ ctx, input }) => {
-      const { responseId, isCorrect, feedback } = input;
+      const { responseId, comment } = input;
 
-      const gradedResponse = await prisma.studentQuestionProgress.update({
-        where: { id: responseId },
+      const newComment = await prisma.comment.create({
         data: {
-          isCorrect,
-          ...(feedback !== undefined && { feedback }),
+          studentQuestionProgressId: responseId,
+          content: comment,
+          authorId: ctx.user!.id,
         },
       });
 
-      return gradedResponse;
+      return newComment;
     }),
 });