@studious-lms/server 1.2.53 → 1.3.0

package/src/services/agenda.ts

@@ -0,0 +1,21 @@
+/**
+ * Agenda service – fetches personal and class events for a date range.
+ */
+import { addMonths, subMonths, startOfDay, endOfDay } from "date-fns";
+import { findPersonalEvents, findClassEvents } from "../models/agenda.js";
+
+const RANGE_MONTHS = 3;
+
+/** Get agenda events (personal + class) for ±3 months around the given week start. */
+export async function getAgenda(userId: string, weekStart: string) {
+  const referenceDate = new Date(weekStart);
+  const rangeStart = startOfDay(subMonths(referenceDate, RANGE_MONTHS));
+  const rangeEnd = endOfDay(addMonths(referenceDate, RANGE_MONTHS));
+
+  const [personal, classEvents] = await Promise.all([
+    findPersonalEvents(userId, rangeStart, rangeEnd),
+    findClassEvents(userId, rangeStart, rangeEnd),
+  ]);
+
+  return { events: { personal, class: classEvents } };
+}

package/src/services/announcement.ts

@@ -0,0 +1,290 @@
+/**
+ * Announcement service – create, read, update, delete announcements.
+ */
+import { TRPCError } from "@trpc/server";
+import {
+  findAnnouncementsByClassId,
+  findAnnouncementByIdAndClass,
+  findAnnouncementWithClass,
+  createAnnouncement,
+  updateAnnouncement,
+  updateAnnouncementAttachments,
+  deleteAnnouncement,
+} from "../models/announcement.js";
+import { prisma } from "../lib/prisma.js";
+import { createDirectUploadFiles, type DirectUploadFile } from "../lib/fileUpload.js";
+import { deleteFile } from "../lib/googleCloudStorage.js";
+import { sendToMultiple } from "./notification.js";
+import { logger } from "../utils/logger.js";
+
+export async function getAllAnnouncements(classId: string) {
+  const announcements = await findAnnouncementsByClassId(classId);
+  const announcementsWithCounts = announcements.map((a) => ({
+    ...a,
+    commentCount: a._count.comments,
+    _count: undefined,
+  }));
+  return { announcements: announcementsWithCounts };
+}
+
+export async function getAnnouncement(id: string, classId: string) {
+  const announcement = await findAnnouncementByIdAndClass(id, classId);
+  if (!announcement) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Announcement not found",
+    });
+  }
+  return { announcement };
+}
+
+export async function createAnnouncementRecord(
+  userId: string,
+  input: {
+    classId: string;
+    remarks: string;
+    files?: { name: string; type: string; size: number }[];
+    existingFileIds?: string[];
+  }
+) {
+  const { classId, remarks, files, existingFileIds } = input;
+
+  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 createAnnouncement({
+    remarks,
+    teacherId: userId,
+    classId,
+  });
+
+  let directUploadFiles: DirectUploadFile[] = [];
+  if (files && files.length > 0) {
+    directUploadFiles = await createDirectUploadFiles(
+      files,
+      userId,
+      undefined,
+      undefined,
+      undefined,
+      announcement.id
+    );
+  }
+
+  if (existingFileIds && existingFileIds.length > 0) {
+    await updateAnnouncementAttachments(announcement.id, {
+      connect: existingFileIds.map((fileId) => ({ id: fileId })),
+    });
+  }
+
+  const announcementWithAttachments = await prisma.announcement.findUnique({
+    where: { id: announcement.id },
+    select: {
+      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,
+        },
+      },
+    },
+  });
+
+  sendToMultiple({
+    receiverIds: classData.students.map((s) => s.id),
+    title: `🔔 Announcement for ${classData.name}`,
+    content: remarks,
+  }).catch((error) => {
+    logger.error("Failed to send announcement notifications:", error);
+  });
+
+  return {
+    announcement: announcementWithAttachments || announcement,
+    uploadFiles: directUploadFiles.length > 0 ? directUploadFiles : undefined,
+  };
+}
+
+export async function updateAnnouncementRecord(
+  userId: string,
+  input: {
+    id: string;
+    classId: string;
+    data: {
+      remarks?: string;
+      files?: { name: string; type: string; size: number }[];
+      existingFileIds?: string[];
+      removedAttachments?: string[];
+    };
+  }
+) {
+  const announcement = await findAnnouncementWithClass(input.id);
+
+  if (!announcement) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Announcement not found",
+    });
+  }
+
+  const isCreator = announcement.teacherId === userId;
+  const isClassTeacher = announcement.class.teachers.some((t) => t.id === userId);
+
+  if (!isCreator && !isClassTeacher) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Only the announcement creator or class teachers can update announcements",
+    });
+  }
+
+  let directUploadFiles: DirectUploadFile[] = [];
+  if (input.data.files && input.data.files.length > 0) {
+    directUploadFiles = await createDirectUploadFiles(
+      input.data.files,
+      userId,
+      undefined,
+      undefined,
+      undefined,
+      input.id
+    );
+  }
+
+  if (input.data.removedAttachments && input.data.removedAttachments.length > 0) {
+    const filesToDelete = announcement.attachments.filter((f) =>
+      input.data.removedAttachments!.includes(f.id)
+    );
+    await Promise.all(
+      filesToDelete.map(async (file) => {
+        try {
+          if (file.uploadStatus === "COMPLETED") {
+            await deleteFile(file.path);
+            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 } : error,
+          });
+        }
+      })
+    );
+  }
+
+  const updateData: { remarks?: string; attachments?: object } = {};
+  if (input.data.remarks) updateData.remarks = input.data.remarks;
+
+  if (input.data.existingFileIds && input.data.existingFileIds.length > 0) {
+    await prisma.announcement.update({
+      where: { id: input.id },
+      data: {
+        attachments: {
+          connect: input.data.existingFileIds.map((fileId) => ({ id: fileId })),
+        },
+      },
+    });
+  }
+
+  if (input.data.removedAttachments && input.data.removedAttachments.length > 0) {
+    await prisma.announcement.update({
+      where: { id: input.id },
+      data: {
+        attachments: {
+          deleteMany: { id: { in: input.data.removedAttachments } },
+        },
+      },
+    });
+  }
+
+  const updatedAnnouncement = await prisma.announcement.update({
+    where: { id: input.id },
+    data: updateData,
+    select: {
+      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,
+        },
+      },
+    },
+  });
+
+  return {
+    announcement: updatedAnnouncement,
+    uploadFiles: directUploadFiles.length > 0 ? directUploadFiles : undefined,
+  };
+}
+
+export async function deleteAnnouncementRecord(userId: string, id: string, classId: string) {
+  const announcement = await findAnnouncementWithClass(id);
+
+  if (!announcement) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Announcement not found",
+    });
+  }
+
+  const isCreator = announcement.teacherId === userId;
+  const isClassTeacher = announcement.class.teachers.some((t) => t.id === userId);
+
+  if (!isCreator && !isClassTeacher) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Only the announcement creator or class teachers can delete announcements",
+    });
+  }
+
+  await deleteAnnouncement(id);
+  return { success: true };
+}