@studious-lms/server 1.2.34 → 1.2.35

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

@@ -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,
         },
@@ -407,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;
+      const { responseId, questionId, studentWorksheetResponseId, response, isCorrect, feedback, markschemeState, points } = 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,
-            },
-          },
-        },
-      });
-
-      // 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;
     }),
 });