@studious-lms/server 1.2.53 → 1.4.0

package/dist/routers/announcement.js

@@ -1,13 +1,14 @@
 
-!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]="a7728c55-4567-50bb-acc9-7f592bac0ec1")}catch(e){}}();
+!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";
+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";
-import { deleteFile } from "../lib/googleCloudStorage.js";
 // Schema for direct file uploads (no base64 data)
 const directFileSchema = z.object({
     name: z.string(),
@@ -25,91 +26,13 @@ const confirmAnnouncementUploadSchema = z.object({
     uploadSuccess: z.boolean(),
     errorMessage: z.string().optional(),
 });
-const AnnouncementSelect = {
-    id: true,
-    teacher: {
-        select: {
-            id: true,
-            username: true,
-            profile: {
-                select: {
-                    displayName: true,
-                    profilePicture: true,
-                    profilePictureThumbnail: true,
-                },
-            },
-        },
-    },
-    remarks: true,
-    createdAt: true,
-    modifiedAt: true,
-    attachments: {
-        select: {
-            id: true,
-            name: true,
-            type: true,
-            size: true,
-            path: true,
-            uploadedAt: true,
-            thumbnailId: true,
-        },
-    },
-};
 export const announcementRouter = createTRPCRouter({
     getAll: protectedClassMemberProcedure
-        .input(z.object({
-        classId: z.string(),
-    }))
-        .query(async ({ ctx, input }) => {
-        const announcements = await prisma.announcement.findMany({
-            where: {
-                classId: input.classId,
-            },
-            select: {
-                ...AnnouncementSelect,
-                _count: {
-                    select: {
-                        comments: true,
-                    },
-                },
-            },
-            orderBy: {
-                createdAt: 'desc',
-            },
-        });
-        // Transform to include comment count
-        const announcementsWithCounts = announcements.map(announcement => ({
-            ...announcement,
-            commentCount: announcement._count.comments,
-            _count: undefined,
-        }));
-        return {
-            announcements: announcementsWithCounts,
-        };
-    }),
+        .input(z.object({ classId: z.string() }))
+        .query(({ input }) => getAllAnnouncements(input.classId)),
     get: protectedClassMemberProcedure
-        .input(z.object({
-        id: z.string(),
-        classId: z.string(),
-    }))
-        .query(async ({ ctx, input }) => {
-        const announcement = await prisma.announcement.findUnique({
-            where: {
-                id: input.id,
-                classId: input.classId,
-            },
-            select: AnnouncementSelect,
-        });
-        if (!announcement) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Announcement not found",
-            });
-        }
-        return {
-            announcement,
-        };
-    }),
+        .input(z.object({ id: z.string(), classId: z.string() }))
+        .query(({ input }) => getAnnouncement(input.id, input.classId)),
     create: protectedTeacherProcedure
         .input(z.object({
         classId: z.string(),
@@ -117,83 +40,12 @@ export const announcementRouter = createTRPCRouter({
         files: z.array(directFileSchema).optional(),
         existingFileIds: z.array(z.string()).optional(),
     }))
-        .mutation(async ({ ctx, input }) => {
-        const { classId, remarks, files, existingFileIds } = input;
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const classData = await prisma.class.findUnique({
-            where: { id: classId },
-            include: {
-                students: {
-                    select: { id: true }
-                }
-            }
-        });
-        if (!classData) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Class not found",
-            });
-        }
-        const announcement = await prisma.announcement.create({
-            data: {
-                remarks: remarks,
-                teacher: {
-                    connect: {
-                        id: ctx.user.id,
-                    },
-                },
-                class: {
-                    connect: {
-                        id: classId,
-                    },
-                },
-            },
-            select: AnnouncementSelect,
-        });
-        // Handle file attachments
-        // NOTE: Files are now handled via direct upload endpoints
-        // The files field in the schema is for metadata only
-        // Actual file uploads should use getAnnouncementUploadUrls endpoint
-        // However, if files are provided here, we create the file records and return upload URLs
-        let directUploadFiles = [];
-        if (files && files.length > 0) {
-            // Create direct upload files - this creates file records with upload URLs
-            // Files are automatically connected to the announcement via announcementId
-            directUploadFiles = await createDirectUploadFiles(files, ctx.user.id, undefined, undefined, undefined, announcement.id);
-        }
-        // Connect existing files if provided
-        if (existingFileIds && existingFileIds.length > 0) {
-            await prisma.announcement.update({
-                where: { id: announcement.id },
-                data: {
-                    attachments: {
-                        connect: existingFileIds.map(fileId => ({ id: fileId }))
-                    }
-                }
-            });
-        }
-        // Fetch announcement with attachments
-        const announcementWithAttachments = await prisma.announcement.findUnique({
-            where: { id: announcement.id },
-            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:', error);
-        });
-        return {
-            announcement: announcementWithAttachments || announcement,
-            // Return upload URLs if files were provided
-            uploadFiles: directUploadFiles.length > 0 ? directUploadFiles : undefined,
-        };
-    }),
+        .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(),
@@ -205,158 +57,14 @@ export const announcementRouter = createTRPCRouter({
             removedAttachments: z.array(z.string()).optional(),
         }),
     }))
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const announcement = await prisma.announcement.findUnique({
-            where: { id: input.id },
-            include: {
-                class: {
-                    include: {
-                        teachers: true,
-                    },
-                },
-                attachments: {
-                    select: {
-                        id: true,
-                        name: true,
-                        type: true,
-                        path: true,
-                        size: true,
-                        uploadStatus: true,
-                        thumbnail: {
-                            select: {
-                                path: true
-                            }
-                        }
-                    },
-                },
-            },
-        });
-        if (!announcement) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Announcement not found",
-            });
-        }
-        // Authorization check: user must be the creator OR a teacher in the class
-        const userId = ctx.user.id;
-        const isCreator = announcement.teacherId === userId;
-        const isClassTeacher = announcement.class.teachers.some((teacher) => teacher.id === userId);
-        if (!isCreator && !isClassTeacher) {
-            throw new TRPCError({
-                code: "FORBIDDEN",
-                message: "Only the announcement creator or class teachers can update announcements",
-            });
-        }
-        // Handle file attachments
-        // NOTE: Files are now handled via direct upload endpoints
-        let directUploadFiles = [];
-        if (input.data.files && input.data.files.length > 0) {
-            // Create direct upload files - this creates file records with upload URLs
-            // Files are automatically connected to the announcement via announcementId
-            directUploadFiles = await createDirectUploadFiles(input.data.files, userId, undefined, undefined, undefined, input.id);
-        }
-        // Delete removed attachments from storage before updating database
-        if (input.data.removedAttachments && input.data.removedAttachments.length > 0) {
-            const filesToDelete = announcement.attachments.filter((file) => input.data.removedAttachments.includes(file.id));
-            // Delete files from storage (only if they were actually uploaded)
-            await Promise.all(filesToDelete.map(async (file) => {
-                try {
-                    // Only delete from GCS if the file was successfully uploaded
-                    if (file.uploadStatus === 'COMPLETED') {
-                        // Delete the main file
-                        await deleteFile(file.path);
-                        // Delete thumbnail if it exists
-                        if (file.thumbnail?.path) {
-                            await deleteFile(file.thumbnail.path);
-                        }
-                    }
-                }
-                catch (error) {
-                    logger.warn(`Failed to delete file ${file.path}:`, {
-                        error: error instanceof Error ? {
-                            name: error.name,
-                            message: error.message,
-                            stack: error.stack,
-                        } : error
-                    });
-                }
-            }));
-        }
-        const updatedAnnouncement = await prisma.announcement.update({
-            where: { id: input.id },
-            data: {
-                ...(input.data.remarks && { remarks: input.data.remarks }),
-                // Note: directUploadFiles are already connected via createDirectUploadFiles
-                ...(input.data.existingFileIds && input.data.existingFileIds.length > 0 && {
-                    attachments: {
-                        connect: input.data.existingFileIds.map(fileId => ({ id: fileId }))
-                    }
-                }),
-                ...(input.data.removedAttachments && input.data.removedAttachments.length > 0 && {
-                    attachments: {
-                        deleteMany: {
-                            id: { in: input.data.removedAttachments }
-                        }
-                    }
-                }),
-            },
-            select: AnnouncementSelect,
-        });
-        return {
-            announcement: updatedAnnouncement,
-            // Return upload URLs if new files were provided
-            uploadFiles: directUploadFiles.length > 0 ? directUploadFiles : undefined,
-        };
-    }),
+        .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(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const announcement = await prisma.announcement.findUnique({
-            where: { id: input.id },
-            include: {
-                class: {
-                    include: {
-                        teachers: true,
-                    },
-                },
-            },
-        });
-        if (!announcement) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Announcement not found",
-            });
-        }
-        // Authorization check: user must be the creator OR a teacher in the class
-        const userId = ctx.user.id;
-        const isCreator = announcement.teacherId === userId;
-        const isClassTeacher = announcement.class.teachers.some((teacher) => teacher.id === userId);
-        if (!isCreator && !isClassTeacher) {
-            throw new TRPCError({
-                code: "FORBIDDEN",
-                message: "Only the announcement creator or class teachers can delete announcements",
-            });
-        }
-        await prisma.announcement.delete({
-            where: { id: input.id },
-        });
-        return { success: true };
-    }),
+        .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 }) => {
@@ -384,13 +92,7 @@ export const announcementRouter = createTRPCRouter({
                 message: "Class not found or you are not a teacher",
             });
         }
-        // Verify announcement exists and belongs to the class
-        const announcement = await prisma.announcement.findFirst({
-            where: {
-                id: announcementId,
-                classId: classId,
-            },
-        });
+        const announcement = await findAnnouncementByIdAndClass(announcementId, classId);
         if (!announcement) {
             throw new TRPCError({
                 code: "NOT_FOUND",
@@ -454,13 +156,7 @@ export const announcementRouter = createTRPCRouter({
                 message: "User must be authenticated",
             });
         }
-        // Verify announcement exists and belongs to the class
-        const announcement = await prisma.announcement.findFirst({
-            where: {
-                id: input.announcementId,
-                classId: input.classId,
-            },
-        });
+        const announcement = await findAnnouncementByIdAndClass(input.announcementId, input.classId);
         if (!announcement) {
             throw new TRPCError({
                 code: "NOT_FOUND",
@@ -618,13 +314,7 @@ export const announcementRouter = createTRPCRouter({
         classId: z.string(),
     }))
         .query(async ({ ctx, input }) => {
-        // Verify announcement exists and belongs to the class
-        const announcement = await prisma.announcement.findFirst({
-            where: {
-                id: input.announcementId,
-                classId: input.classId,
-            },
-        });
+        const announcement = await findAnnouncementByIdAndClass(input.announcementId, input.classId);
         if (!announcement) {
             throw new TRPCError({
                 code: "NOT_FOUND",
@@ -707,14 +397,8 @@ export const announcementRouter = createTRPCRouter({
             });
         }
         const userId = ctx.user.id;
-        // Verify the announcement or comment exists and belongs to the class
         if (input.announcementId) {
-            const announcement = await prisma.announcement.findFirst({
-                where: {
-                    id: input.announcementId,
-                    classId: input.classId,
-                },
-            });
+            const announcement = await findAnnouncementByIdAndClass(input.announcementId, input.classId);
             if (!announcement) {
                 throw new TRPCError({
                     code: "NOT_FOUND",
@@ -756,17 +440,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.comment.findUnique({
-                where: { id: input.commentId },
-                include: {
-                    announcement: {
-                        select: {
-                            classId: true,
-                        },
-                    },
-                },
-            });
+            const comment = await findCommentWithAnnouncement(input.commentId);
             if (!comment) {
                 throw new TRPCError({
                     code: "NOT_FOUND",
@@ -779,37 +453,10 @@ export const announcementRouter = createTRPCRouter({
                     message: "Comment does not belong to this class",
                 });
             }
-            // Upsert reaction: update if exists, create if not
-            const reaction = await prisma.reaction.upsert({
-                where: {
-                    userId_commentId: {
-                        userId,
-                        commentId: input.commentId,
-                    },
-                },
-                update: {
-                    type: input.type,
-                },
-                create: {
-                    type: input.type,
-                    userId,
-                    commentId: input.commentId,
-                },
-                include: {
-                    user: {
-                        select: {
-                            id: true,
-                            username: true,
-                            profile: {
-                                select: {
-                                    displayName: true,
-                                    profilePicture: true,
-                                    profilePictureThumbnail: true,
-                                },
-                            },
-                        },
-                    },
-                },
+            const reaction = await upsertReaction({
+                userId,
+                commentId: input.commentId,
+                type: input.type,
             });
             return { reaction };
         }
@@ -859,23 +506,14 @@ export const announcementRouter = createTRPCRouter({
             return { success: true };
         }
         else if (input.commentId) {
-            const reaction = await prisma.reaction.findUnique({
-                where: {
-                    userId_commentId: {
-                        userId,
-                        commentId: input.commentId,
-                    },
-                },
-            });
+            const reaction = await findReactionByUserAndComment(userId, input.commentId);
             if (!reaction) {
                 throw new TRPCError({
                     code: "NOT_FOUND",
                     message: "Reaction not found",
                 });
             }
-            await prisma.reaction.delete({
-                where: { id: reaction.id },
-            });
+            await deleteReactionById(reaction.id);
             return { success: true };
         }
         throw new TRPCError({
@@ -905,13 +543,7 @@ export const announcementRouter = createTRPCRouter({
         }
         const userId = ctx.user.id;
         if (input.announcementId) {
-            // Verify announcement exists
-            const announcement = await prisma.announcement.findFirst({
-                where: {
-                    id: input.announcementId,
-                    classId: input.classId,
-                },
-            });
+            const announcement = await findAnnouncementByIdAndClass(input.announcementId, input.classId);
             if (!announcement) {
                 throw new TRPCError({
                     code: "NOT_FOUND",
@@ -952,17 +584,7 @@ export const announcementRouter = createTRPCRouter({
             };
         }
         else if (input.commentId) {
-            // Verify comment exists
-            const comment = await prisma.comment.findUnique({
-                where: { id: input.commentId },
-                include: {
-                    announcement: {
-                        select: {
-                            classId: true,
-                        },
-                    },
-                },
-            });
+            const comment = await findCommentWithAnnouncement(input.commentId);
             if (!comment) {
                 throw new TRPCError({
                     code: "NOT_FOUND",
@@ -975,38 +597,7 @@ export const announcementRouter = createTRPCRouter({
                     message: "Comment does not belong to this class",
                 });
             }
-            // 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] = item._count.type;
-            });
-            return {
-                counts,
-                userReaction: userReaction?.type || null,
-                total: reactionCounts.reduce((sum, item) => sum + item._count.type, 0),
-            };
+            return getCommentReactions(userId, input.commentId);
         }
         throw new TRPCError({
             code: "INTERNAL_SERVER_ERROR",
@@ -1015,4 +606,4 @@ export const announcementRouter = createTRPCRouter({
     }),
 });
 //# sourceMappingURL=announcement.js.map
-//# debugId=a7728c55-4567-50bb-acc9-7f592bac0ec1
+//# debugId=a4b6352a-4a02-5817-b542-3f6ab5651e28