@studious-lms/server 1.1.24 → 1.2.6

package/src/routers/announcement.ts

@@ -2,133 +2,698 @@ import { z } from "zod";
 import { createTRPCRouter, protectedClassMemberProcedure, protectedTeacherProcedure, protectedProcedure } from "../trpc.js";
 import { prisma } from "../lib/prisma.js";
 import { TRPCError } from "@trpc/server";
+import {
+  getAllAnnouncements,
+  getAnnouncement,
+  createAnnouncementRecord,
+  updateAnnouncementRecord,
+  deleteAnnouncementRecord,
+} from "../services/announcement.js";
+import { findAnnouncementByIdAndClass } from "../models/announcement.js";
+import {
+  findCommentWithAnnouncement,
+  findReactionByUserAndComment,
+  upsertReaction,
+  deleteReactionById,
+} from "../models/comment.js";
+import { getReactions as getCommentReactions } from "../services/comment.js";
 
-const AnnouncementSelect = {
-    id: true,
-    teacher: {
-        select: {
-            id: true,
-            username: true,
-        },
-    },
-    remarks: true,
-    createdAt: true,
-};
+import { logger } from "../utils/logger.js";
+import { createDirectUploadFiles, type UploadedFile, type DirectUploadFile, confirmDirectUpload } from "../lib/fileUpload.js";
+import { deleteFile } from "../lib/googleCloudStorage.js";
+import { sendToMultiple } from "../services/notification.js";
+
+// Schema for direct file uploads (no base64 data)
+const directFileSchema = z.object({
+  name: z.string(),
+  type: z.string(),
+  size: z.number(),
+});
+
+// Schemas for file upload endpoints
+const getAnnouncementUploadUrlsSchema = z.object({
+  announcementId: z.string(),
+  classId: z.string(),
+  files: z.array(directFileSchema),
+});
+
+const confirmAnnouncementUploadSchema = z.object({
+  fileId: z.string(),
+  uploadSuccess: z.boolean(),
+  errorMessage: z.string().optional(),
+});
 
 export const announcementRouter = createTRPCRouter({
     getAll: protectedClassMemberProcedure
+        .input(z.object({ classId: z.string() }))
+        .query(({ input }) => getAllAnnouncements(input.classId)),
+
+    get: protectedClassMemberProcedure
+        .input(z.object({ id: z.string(), classId: z.string() }))
+        .query(({ input }) => getAnnouncement(input.id, input.classId)),
+
+    create: protectedTeacherProcedure
         .input(z.object({
             classId: z.string(),
+            remarks: z.string().min(1, "Remarks cannot be empty"),
+            files: z.array(directFileSchema).optional(),
+            existingFileIds: z.array(z.string()).optional(),
         }))
-        .query(async ({ ctx, input }) => {
-            const announcements = await prisma.announcement.findMany({
+        .mutation(({ ctx, input }) =>
+            createAnnouncementRecord(ctx.user!.id, {
+                classId: input.classId,
+                remarks: input.remarks,
+                files: input.files,
+                existingFileIds: input.existingFileIds,
+            })
+        ),
+
+    update: protectedTeacherProcedure
+        .input(z.object({
+            id: z.string(),
+            classId: z.string(),
+            data: z.object({
+                remarks: z.string().min(1, "Remarks cannot be empty").optional(),
+                files: z.array(directFileSchema).optional(),
+                existingFileIds: z.array(z.string()).optional(),
+                removedAttachments: z.array(z.string()).optional(),
+            }),
+        }))
+        .mutation(({ ctx, input }) =>
+            updateAnnouncementRecord(ctx.user!.id, {
+                id: input.id,
+                classId: input.classId,
+                data: input.data,
+            })
+        ),
+
+    delete: protectedTeacherProcedure
+        .input(z.object({ id: z.string(), classId: z.string() }))
+        .mutation(({ ctx, input }) =>
+            deleteAnnouncementRecord(ctx.user!.id, input.id, input.classId)
+        ),
+
+    getAnnouncementUploadUrls: protectedTeacherProcedure
+        .input(getAnnouncementUploadUrlsSchema)
+        .mutation(async ({ ctx, input }) => {
+            const { announcementId, classId, files } = input;
+
+            if (!ctx.user) {
+                throw new TRPCError({
+                    code: "UNAUTHORIZED",
+                    message: "You must be logged in to upload files",
+                });
+            }
+
+            // Verify user is a teacher of the class
+            const classData = await prisma.class.findFirst({
                 where: {
-                    classId: input.classId,
+                    id: classId,
+                    teachers: {
+                        some: {
+                            id: ctx.user.id,
+                        },
+                    },
                 },
-                select: AnnouncementSelect,
-                orderBy: {
-                    createdAt: 'desc',
+            });
+
+            if (!classData) {
+                throw new TRPCError({
+                    code: "NOT_FOUND",
+                    message: "Class not found or you are not a teacher",
+                });
+            }
+
+            const announcement = await findAnnouncementByIdAndClass(announcementId, classId);
+            if (!announcement) {
+                throw new TRPCError({
+                    code: "NOT_FOUND",
+                    message: "Announcement not found",
+                });
+            }
+
+            // Create direct upload files
+            const directUploadFiles = await createDirectUploadFiles(
+                files,
+                ctx.user.id,
+                undefined, // No specific directory
+                undefined, // No assignment ID
+                undefined, // No submission ID
+                announcementId
+            );
+
+            return {
+                success: true,
+                uploadFiles: directUploadFiles,
+            };
+        }),
+
+    confirmAnnouncementUpload: protectedTeacherProcedure
+        .input(confirmAnnouncementUploadSchema)
+        .mutation(async ({ ctx, input }) => {
+            const { fileId, uploadSuccess, errorMessage } = input;
+
+            if (!ctx.user) {
+                throw new TRPCError({
+                    code: "UNAUTHORIZED",
+                    message: "You must be logged in",
+                });
+            }
+
+            // Verify file belongs to user and is an announcement file
+            const file = await prisma.file.findFirst({
+                where: {
+                    id: fileId,
+                    userId: ctx.user.id,
+                    announcement: {
+                        isNot: null,
+                    },
                 },
             });
 
+            if (!file) {
+                throw new TRPCError({
+                    code: "NOT_FOUND",
+                    message: "File not found or you don't have permission",
+                });
+            }
+
+            await confirmDirectUpload(fileId, uploadSuccess, errorMessage);
+
             return {
-                announcements,
+                success: true,
+                message: uploadSuccess ? "Upload confirmed successfully" : "Upload failed",
             };
         }),
 
-    create: protectedTeacherProcedure
+    // Comment endpoints
+    addComment: protectedClassMemberProcedure
         .input(z.object({
+            announcementId: z.string(),
             classId: z.string(),
-            remarks: z.string(),
+            content: z.string().min(1, "Comment cannot be empty"),
+            parentCommentId: z.string().optional(),
         }))
         .mutation(async ({ ctx, input }) => {
-            const announcement = await prisma.announcement.create({
+            if (!ctx.user) {
+                throw new TRPCError({
+                    code: "UNAUTHORIZED",
+                    message: "User must be authenticated",
+                });
+            }
+
+            const announcement = await findAnnouncementByIdAndClass(input.announcementId, input.classId);
+            if (!announcement) {
+                throw new TRPCError({
+                    code: "NOT_FOUND",
+                    message: "Announcement not found",
+                });
+            }
+
+            // If replying to a comment, verify parent comment exists and belongs to the same announcement
+            if (input.parentCommentId) {
+                const parentComment = await prisma.comment.findFirst({
+                    where: {
+                        id: input.parentCommentId,
+                        announcementId: input.announcementId,
+                    },
+                });
+
+                if (!parentComment) {
+                    throw new TRPCError({
+                        code: "NOT_FOUND",
+                        message: "Parent comment not found",
+                    });
+                }
+            }
+
+            const comment = await prisma.comment.create({
                 data: {
-                    remarks: input.remarks,
-                    teacher: {
-                        connect: {
-                            id: ctx.user?.id,
-                        },
+                    content: input.content,
+                    author: {
+                        connect: { id: ctx.user.id },
+                    },
+                    announcement: {
+                        connect: { id: input.announcementId },
                     },
-                    class: {
-                        connect: {
-                            id: input.classId,
+                    ...(input.parentCommentId && {
+                        parentComment: {
+                            connect: { id: input.parentCommentId },
+                        },
+                    }),
+                },
+                include: {
+                    author: {
+                        select: {
+                            id: true,
+                            username: true,
+                            profile: {
+                                select: {
+                                    displayName: true,
+                                    profilePicture: true,
+                                    profilePictureThumbnail: true,
+                                },
+                            },
                         },
                     },
                 },
-                select: AnnouncementSelect,
             });
 
-            return {
-                announcement,
-            };
+            return { comment };
         }),
 
-    update: protectedProcedure
+    updateComment: protectedProcedure
         .input(z.object({
             id: z.string(),
-            data: z.object({
-                content: z.string(),
-            }),
+            content: z.string().min(1, "Comment cannot be empty"),
         }))
         .mutation(async ({ ctx, input }) => {
+            if (!ctx.user) {
+                throw new TRPCError({
+                    code: "UNAUTHORIZED",
+                    message: "User must be authenticated",
+                });
+            }
 
-            const announcement = await prisma.announcement.findUnique({
+            const comment = await prisma.comment.findUnique({
                 where: { id: input.id },
-                include: {
-                    class: {
-                        include: {
-                            teachers: true,
-                        },
-                    },
-                },
             });
 
-            if (!announcement) {
+            if (!comment) {
                 throw new TRPCError({
                     code: "NOT_FOUND",
-                    message: "Announcement not found",
+                    message: "Comment not found",
+                });
+            }
+
+            // Only the author can update their comment
+            if (comment.authorId !== ctx.user.id) {
+                throw new TRPCError({
+                    code: "FORBIDDEN",
+                    message: "Only the comment author can update this comment",
                 });
             }
 
-            const updatedAnnouncement = await prisma.announcement.update({
+            const updatedComment = await prisma.comment.update({
                 where: { id: input.id },
                 data: {
-                    remarks: input.data.content,
+                    content: input.content,
+                },
+                include: {
+                    author: {
+                        select: {
+                            id: true,
+                            username: true,
+                            profile: {
+                                select: {
+                                    displayName: true,
+                                    profilePicture: true,
+                                    profilePictureThumbnail: true,
+                                },
+                            },
+                        },
+                    },
                 },
             });
 
-            return { announcement: updatedAnnouncement };
+            return { comment: updatedComment };
         }),
 
-    delete: protectedProcedure
+    deleteComment: protectedProcedure
         .input(z.object({
             id: z.string(),
         }))
         .mutation(async ({ ctx, input }) => {
+            if (!ctx.user) {
+                throw new TRPCError({
+                    code: "UNAUTHORIZED",
+                    message: "User must be authenticated",
+                });
+            }
 
-            const announcement = await prisma.announcement.findUnique({
+            const comment = await prisma.comment.findUnique({
                 where: { id: input.id },
                 include: {
-                    class: {
+                    announcement: {
                         include: {
-                            teachers: true,
+                            class: {
+                                include: {
+                                    teachers: true,
+                                },
+                            },
                         },
                     },
                 },
             });
 
-            if (!announcement) {
+            if (!comment) {
                 throw new TRPCError({
                     code: "NOT_FOUND",
-                    message: "Announcement not found",
+                    message: "Comment not found",
+                });
+            }
+
+            // 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(
+                (teacher) => teacher.id === userId
+            );
+
+            if (!isAuthor && !isClassTeacher) {
+                throw new TRPCError({
+                    code: "FORBIDDEN",
+                    message: "Only the comment author or class teachers can delete comments",
                 });
             }
 
-            await prisma.announcement.delete({
+            await prisma.comment.delete({
                 where: { id: input.id },
             });
 
             return { success: true };
         }),
+
+    getComments: protectedClassMemberProcedure
+        .input(z.object({
+            announcementId: z.string(),
+            classId: z.string(),
+        }))
+        .query(async ({ ctx, input }) => {
+            const announcement = await findAnnouncementByIdAndClass(input.announcementId, input.classId);
+            if (!announcement) {
+                throw new TRPCError({
+                    code: "NOT_FOUND",
+                    message: "Announcement not found",
+                });
+            }
+
+            // Get all top-level comments (no parent)
+            const comments = await prisma.comment.findMany({
+                where: {
+                    announcementId: input.announcementId,
+                    parentCommentId: null,
+                },
+                include: {
+                    author: {
+                        select: {
+                            id: true,
+                            username: true,
+                            profile: {
+                                select: {
+                                    displayName: true,
+                                    profilePicture: true,
+                                    profilePictureThumbnail: true,
+                                },
+                            },
+                        },
+                    },
+                    replies: {
+                        include: {
+                            author: {
+                                select: {
+                                    id: true,
+                                    username: true,
+                                    profile: {
+                                        select: {
+                                            displayName: true,
+                                            profilePicture: true,
+                                            profilePictureThumbnail: true,
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                        orderBy: {
+                            createdAt: 'asc',
+                        },
+                    },
+                },
+                orderBy: {
+                    createdAt: 'asc',
+                },
+            });
+
+            return { comments };
+        }),
+
+    // Reaction endpoints
+    addReaction: protectedClassMemberProcedure
+        .input(z.object({
+            announcementId: z.string().optional(),
+            commentId: z.string().optional(),
+            classId: 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
+            if (!input.announcementId && !input.commentId) {
+                throw new TRPCError({
+                    code: "BAD_REQUEST",
+                    message: "Either announcementId or commentId must be provided",
+                });
+            }
+
+            if (input.announcementId && input.commentId) {
+                throw new TRPCError({
+                    code: "BAD_REQUEST",
+                    message: "Cannot react to both announcement and comment at the same time",
+                });
+            }
+
+            const userId = ctx.user.id;
+
+            if (input.announcementId) {
+                const announcement = await findAnnouncementByIdAndClass(input.announcementId, input.classId);
+                if (!announcement) {
+                    throw new TRPCError({
+                        code: "NOT_FOUND",
+                        message: "Announcement not found",
+                    });
+                }
+
+                // Upsert reaction: update if exists, create if not
+                const reaction = await prisma.reaction.upsert({
+                    where: {
+                        userId_announcementId: {
+                            userId,
+                            announcementId: input.announcementId,
+                        },
+                    },
+                    update: {
+                        type: input.type,
+                    },
+                    create: {
+                        type: input.type,
+                        userId,
+                        announcementId: input.announcementId,
+                    },
+                    include: {
+                        user: {
+                            select: {
+                                id: true,
+                                username: true,
+                                profile: {
+                                    select: {
+                                        displayName: true,
+                                        profilePicture: true,
+                                        profilePictureThumbnail: true,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                });
+
+                return { reaction };
+            } else if (input.commentId) {
+                const comment = await findCommentWithAnnouncement(input.commentId);
+                if (!comment) {
+                    throw new TRPCError({
+                        code: "NOT_FOUND",
+                        message: "Comment not found",
+                    });
+                }
+                if (comment.announcement!.classId !== input.classId) {
+                    throw new TRPCError({
+                        code: "FORBIDDEN",
+                        message: "Comment does not belong to this class",
+                    });
+                }
+
+                const reaction = await upsertReaction({
+                    userId,
+                    commentId: input.commentId,
+                    type: input.type,
+                });
+                return { reaction };
+            }
+
+            throw new TRPCError({
+                code: "INTERNAL_SERVER_ERROR",
+                message: "Unexpected error",
+            });
+        }),
+
+    removeReaction: protectedProcedure
+        .input(z.object({
+            announcementId: z.string().optional(),
+            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.announcementId && !input.commentId) {
+                throw new TRPCError({
+                    code: "BAD_REQUEST",
+                    message: "Either announcementId or commentId must be provided",
+                });
+            }
+
+            const userId = ctx.user.id;
+
+            if (input.announcementId) {
+                const reaction = await prisma.reaction.findUnique({
+                    where: {
+                        userId_announcementId: {
+                            userId,
+                            announcementId: input.announcementId,
+                        },
+                    },
+                });
+
+                if (!reaction) {
+                    throw new TRPCError({
+                        code: "NOT_FOUND",
+                        message: "Reaction not found",
+                    });
+                }
+
+                await prisma.reaction.delete({
+                    where: { id: reaction.id },
+                });
+
+                return { success: true };
+            } else if (input.commentId) {
+                const reaction = await findReactionByUserAndComment(userId, input.commentId);
+                if (!reaction) {
+                    throw new TRPCError({
+                        code: "NOT_FOUND",
+                        message: "Reaction not found",
+                    });
+                }
+                await deleteReactionById(reaction.id);
+                return { success: true };
+            }
+
+            throw new TRPCError({
+                code: "INTERNAL_SERVER_ERROR",
+                message: "Unexpected error",
+            });
+        }),
+
+    getReactions: protectedClassMemberProcedure
+        .input(z.object({
+            announcementId: z.string().optional(),
+            commentId: z.string().optional(),
+            classId: z.string(),
+        }))
+        .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.announcementId && !input.commentId) {
+                throw new TRPCError({
+                    code: "BAD_REQUEST",
+                    message: "Either announcementId or commentId must be provided",
+                });
+            }
+
+            const userId = ctx.user.id;
+
+            if (input.announcementId) {
+                const announcement = await findAnnouncementByIdAndClass(input.announcementId, input.classId);
+                if (!announcement) {
+                    throw new TRPCError({
+                        code: "NOT_FOUND",
+                        message: "Announcement not found",
+                    });
+                }
+
+                // Get reaction counts by type
+                const reactionCounts = await prisma.reaction.groupBy({
+                    by: ['type'],
+                    where: { announcementId: input.announcementId },
+                    _count: { type: true },
+                });
+
+                // Get current user's reaction
+                const userReaction = await prisma.reaction.findUnique({
+                    where: {
+                        userId_announcementId: {
+                            userId,
+                            announcementId: input.announcementId,
+                        },
+                    },
+                });
+
+                // 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),
+                };
+            } else if (input.commentId) {
+                const comment = await findCommentWithAnnouncement(input.commentId);
+                if (!comment) {
+                    throw new TRPCError({
+                        code: "NOT_FOUND",
+                        message: "Comment not found",
+                    });
+                }
+                if (comment.announcement!.classId !== input.classId) {
+                    throw new TRPCError({
+                        code: "FORBIDDEN",
+                        message: "Comment does not belong to this class",
+                    });
+                }
+                return getCommentReactions(userId, input.commentId);
+            }
+
+            throw new TRPCError({
+                code: "INTERNAL_SERVER_ERROR",
+                message: "Unexpected error",
+            });
+        }),
 });