@studious-lms/server 1.1.26 → 1.2.6

package/dist/routers/announcement.js

@@ -1,143 +1,609 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="a4b6352a-4a02-5817-b542-3f6ab5651e28")}catch(e){}}();
 import { z } from "zod";
 import { createTRPCRouter, protectedClassMemberProcedure, protectedTeacherProcedure, protectedProcedure } from "../trpc.js";
 import { prisma } from "../lib/prisma.js";
 import { TRPCError } from "@trpc/server";
-import { sendNotifications } from "../lib/notificationHandler.js";
-import { logger } from "../utils/logger.js";
-const AnnouncementSelect = {
-    id: true,
-    teacher: {
-        select: {
-            id: true,
-            username: true,
-        },
-    },
-    remarks: true,
-    createdAt: true,
-};
+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";
+import { createDirectUploadFiles, confirmDirectUpload } from "../lib/fileUpload.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 classId = input.classId;
-        const remarks = input.remarks;
-        const classData = await prisma.class.findUnique({
-            where: { id: classId },
-            include: {
-                students: {
-                    select: { id: true }
-                }
-            }
-        });
-        if (!classData) {
+        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: "Class not found",
+                message: "Announcement not found",
             });
         }
-        const announcement = await prisma.announcement.create({
+        // 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: remarks,
-                teacher: {
-                    connect: {
-                        id: ctx.user?.id,
-                    },
+                content: input.content,
+                author: {
+                    connect: { id: ctx.user.id },
+                },
+                announcement: {
+                    connect: { id: input.announcementId },
                 },
-                class: {
-                    connect: {
-                        id: 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,
         });
-        sendNotifications(classData.students.map(student => student.id), {
-            title: `🔔 Announcement for ${classData.name}`,
-            content: remarks
-        }).catch(error => {
-            logger.error('Failed to send announcement notifications:');
-        });
-        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 }) => {
-        const announcement = await prisma.announcement.findUnique({
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        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 }) => {
-        const announcement = await prisma.announcement.findUnique({
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        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",
             });
         }
-        await prisma.announcement.delete({
+        // 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.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] = 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",
+        });
+    }),
 });
+//# sourceMappingURL=announcement.js.map
+//# debugId=a4b6352a-4a02-5817-b542-3f6ab5651e28