@studious-lms/server 1.2.53 → 1.4.0

package/src/routers/announcement.ts

@@ -2,10 +2,26 @@ 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 {
+  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 { 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({
@@ -27,97 +43,14 @@ const confirmAnnouncementUploadSchema = z.object({
   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({
@@ -126,92 +59,14 @@ 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: DirectUploadFile[] = [];
-            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({
@@ -224,180 +79,19 @@ 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: DirectUploadFile[] = [];
-            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)
@@ -430,14 +124,7 @@ export const announcementRouter = createTRPCRouter({
                 });
             }
 
-            // 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",
@@ -515,14 +202,7 @@ export const announcementRouter = createTRPCRouter({
                 });
             }
 
-            // 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",
@@ -700,14 +380,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",
@@ -797,15 +470,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",
@@ -848,25 +514,13 @@ 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",
                         message: "Comment not found",
                     });
                 }
-
                 if (comment.announcement!.classId !== input.classId) {
                     throw new TRPCError({
                         code: "FORBIDDEN",
@@ -874,39 +528,11 @@ export const announcementRouter = createTRPCRouter({
                     });
                 }
 
-                // 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 };
             }
 
@@ -962,26 +588,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 };
             }
 
@@ -1016,14 +630,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",
@@ -1068,68 +675,20 @@ export const announcementRouter = createTRPCRouter({
                     total: reactionCounts.reduce((sum, item) => sum + item._count.type, 0),
                 };
             } 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",
                         message: "Comment not found",
                     });
                 }
-
                 if (comment.announcement!.classId !== input.classId) {
                     throw new TRPCError({
                         code: "FORBIDDEN",
                         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 as keyof typeof counts] = 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({