@studious-lms/server 1.2.53 → 1.4.0

package/dist/routers/event.d.ts

@@ -50,13 +50,13 @@ export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
                     title: string;
                     dueDate: Date;
                     maxGrade: number | null;
+                    instructions: string;
+                    graded: boolean;
+                    weight: number;
                     teacher: {
                         id: string;
                         username: string;
                     };
-                    instructions: string;
-                    weight: number;
-                    graded: boolean;
                     attachments: {
                         type: string;
                         id: string;
@@ -65,14 +65,14 @@ export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
                 }[];
             } & {
                 id: string;
+                userId: string | null;
+                location: string | null;
+                classId: string | null;
                 name: string | null;
                 color: string | null;
-                location: string | null;
                 startTime: Date;
                 endTime: Date;
                 remarks: string | null;
-                classId: string | null;
-                userId: string | null;
             };
         };
         meta: object;
@@ -81,27 +81,27 @@ export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
         input: {
             startTime: string;
             endTime: string;
+            location?: string | undefined;
+            classId?: string | undefined;
             name?: string | undefined;
             color?: string | undefined;
-            location?: string | undefined;
             remarks?: string | undefined;
-            classId?: string | undefined;
         };
         output: {
             event: {
                 id: string;
-                name: string | null;
+                userId: string | null;
+                location: string | null;
+                classId: string | null;
                 class: {
                     id: string;
                     name: string;
                 } | null;
+                name: string | null;
                 color: string | null;
-                location: string | null;
                 startTime: Date;
                 endTime: Date;
                 remarks: string | null;
-                classId: string | null;
-                userId: string | null;
             };
         };
         meta: object;
@@ -112,24 +112,24 @@ export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
             data: {
                 startTime: string;
                 endTime: string;
+                location?: string | undefined;
+                classId?: string | undefined;
                 name?: string | undefined;
                 color?: string | undefined;
-                location?: string | undefined;
                 remarks?: string | undefined;
-                classId?: string | undefined;
             };
         };
         output: {
             event: {
                 id: string;
+                userId: string | null;
+                location: string | null;
+                classId: string | null;
                 name: string | null;
                 color: string | null;
-                location: string | null;
                 startTime: Date;
                 endTime: Date;
                 remarks: string | null;
-                classId: string | null;
-                userId: string | null;
             };
         };
         meta: object;
@@ -166,19 +166,13 @@ export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
             } & {
                 type: import(".prisma/client").$Enums.AssignmentType;
                 id: string;
+                createdAt: Date | null;
+                classId: string;
                 title: string;
                 dueDate: Date;
                 maxGrade: number | null;
-                classId: string;
                 eventId: string | null;
-                markSchemeId: string | null;
-                gradingBoundaryId: string | null;
                 instructions: string;
-                weight: number;
-                graded: boolean;
-                sectionId: string | null;
-                template: boolean;
-                createdAt: Date | null;
                 modifiedAt: Date | null;
                 teacherId: string;
                 acceptFiles: boolean;
@@ -186,8 +180,14 @@ export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
                 acceptWorksheet: boolean;
                 gradeWithAI: boolean;
                 aiPolicyLevel: number;
+                sectionId: string | null;
+                graded: boolean;
+                weight: number;
                 inProgress: boolean;
+                template: boolean;
+                markSchemeId: string | null;
                 order: number | null;
+                gradingBoundaryId: string | null;
             };
         };
         meta: object;
@@ -215,19 +215,13 @@ export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
             } & {
                 type: import(".prisma/client").$Enums.AssignmentType;
                 id: string;
+                createdAt: Date | null;
+                classId: string;
                 title: string;
                 dueDate: Date;
                 maxGrade: number | null;
-                classId: string;
                 eventId: string | null;
-                markSchemeId: string | null;
-                gradingBoundaryId: string | null;
                 instructions: string;
-                weight: number;
-                graded: boolean;
-                sectionId: string | null;
-                template: boolean;
-                createdAt: Date | null;
                 modifiedAt: Date | null;
                 teacherId: string;
                 acceptFiles: boolean;
@@ -235,8 +229,14 @@ export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
                 acceptWorksheet: boolean;
                 gradeWithAI: boolean;
                 aiPolicyLevel: number;
+                sectionId: string | null;
+                graded: boolean;
+                weight: number;
                 inProgress: boolean;
+                template: boolean;
+                markSchemeId: string | null;
                 order: number | null;
+                gradingBoundaryId: string | null;
             };
         };
         meta: object;
@@ -256,13 +256,13 @@ export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
                 title: string;
                 dueDate: Date;
                 maxGrade: number | null;
+                instructions: string;
+                graded: boolean;
+                weight: number;
                 teacher: {
                     id: string;
                     username: string;
                 };
-                instructions: string;
-                weight: number;
-                graded: boolean;
                 attachments: {
                     type: string;
                     id: string;

package/dist/routers/event.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event.d.ts","sourceRoot":"/","sources":["routers/event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgBxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4etB,CAAC"}
+{"version":3,"file":"event.d.ts","sourceRoot":"/","sources":["routers/event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAsBxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDtB,CAAC"}

package/dist/routers/event.js

@@ -1,10 +1,8 @@
 
-!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]="a9324f3c-d989-5a88-87a3-ae7ddd7de34c")}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]="4c9803f2-4631-5ddc-b780-b4b7b107df2a")}catch(e){}}();
 import { z } from "zod";
 import { createTRPCRouter, protectedProcedure } from "../trpc.js";
-import { TRPCError } from "@trpc/server";
-import { prisma } from "../lib/prisma.js";
-import { parseISO } from "date-fns";
+import { getEvent, createEventRecord, updateEventRecord, deleteEventRecord, attachAssignment, detachAssignment, getAvailableAssignments, } from "../services/event.js";
 const eventSchema = z.object({
     name: z.string().optional(),
     location: z.string().optional(),
@@ -16,453 +14,35 @@ const eventSchema = z.object({
 });
 export const eventRouter = createTRPCRouter({
     get: protectedProcedure
-        .input(z.object({
-        id: z.string(),
-    }))
-        .query(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "You must be logged in to get an event",
-            });
-        }
-        const event = await prisma.event.findUnique({
-            where: { id: input.id },
-            include: {
-                class: true,
-                user: true,
-                assignmentsAttached: {
-                    select: {
-                        id: true,
-                        title: true,
-                        instructions: true,
-                        dueDate: true,
-                        type: true,
-                        graded: true,
-                        maxGrade: true,
-                        weight: true,
-                        attachments: {
-                            select: {
-                                id: true,
-                                name: true,
-                                type: true,
-                            }
-                        },
-                        section: {
-                            select: {
-                                id: true,
-                                name: true
-                            }
-                        },
-                        teacher: {
-                            select: {
-                                id: true,
-                                username: true
-                            }
-                        }
-                    }
-                }
-            },
-        });
-        if (!event) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Event not found",
-            });
-        }
-        if (event.userId !== ctx.user.id) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "You are not authorized to view this event",
-            });
-        }
-        return { event };
-    }),
+        .input(z.object({ id: z.string() }))
+        .query(({ ctx, input }) => getEvent(ctx.user.id, input.id)),
     create: protectedProcedure
         .input(eventSchema)
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "You must be logged in to create an event",
-            });
-        }
-        // If classId is provided, check if user is a teacher of the class
-        if (input.classId) {
-            const classData = await prisma.class.findUnique({
-                where: {
-                    id: input.classId,
-                    teachers: {
-                        some: {
-                            id: ctx.user.id,
-                        },
-                    },
-                },
-            });
-            if (!classData) {
-                throw new TRPCError({
-                    code: "UNAUTHORIZED",
-                    message: "You are not authorized to create events for this class",
-                });
-            }
-        }
-        const event = await prisma.event.create({
-            data: {
-                name: input.name,
-                location: input.location,
-                remarks: input.remarks,
-                startTime: parseISO(input.startTime),
-                endTime: parseISO(input.endTime),
-                userId: ctx.user.id,
-                color: input.color,
-                ...(input.classId ? { classId: input.classId } : {}),
-            },
-            select: {
-                id: true,
-                name: true,
-                location: true,
-                remarks: true,
-                startTime: true,
-                endTime: true,
-                color: true,
-                classId: true,
-                userId: true,
-                class: {
-                    select: {
-                        id: true,
-                        name: true
-                    }
-                },
-            }
-        });
-        return { event };
-    }),
+        .mutation(({ ctx, input }) => createEventRecord(ctx.user.id, input)),
     update: protectedProcedure
         .input(z.object({
         id: z.string(),
         data: eventSchema,
     }))
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "You must be logged in to update an event",
-            });
-        }
-        const event = await prisma.event.findUnique({
-            where: { id: input.id },
-        });
-        if (!event) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Event not found",
-            });
-        }
-        if (event.userId !== ctx.user.id) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "You are not authorized to update this event",
-            });
-        }
-        const updatedEvent = await prisma.event.update({
-            where: { id: input.id },
-            data: {
-                name: input.data.name,
-                location: input.data.location,
-                remarks: input.data.remarks,
-                startTime: parseISO(input.data.startTime),
-                endTime: parseISO(input.data.endTime),
-                color: input.data.color,
-                ...(input.data.classId ? { classId: input.data.classId } : {}),
-            },
-        });
-        return { event: updatedEvent };
-    }),
+        .mutation(({ ctx, input }) => updateEventRecord(ctx.user.id, input.id, input.data)),
     delete: protectedProcedure
-        .input(z.object({
-        id: z.string(),
-    }))
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "You must be logged in to delete an event",
-            });
-        }
-        const event = await prisma.event.findUnique({
-            where: { id: input.id },
-        });
-        if (!event) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Event not found",
-            });
-        }
-        if (event.userId !== ctx.user.id) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "You are not authorized to delete this event",
-            });
-        }
-        await prisma.event.delete({
-            where: { id: input.id },
-        });
-        return { success: true };
-    }),
+        .input(z.object({ id: z.string() }))
+        .mutation(({ ctx, input }) => deleteEventRecord(ctx.user.id, input.id)),
     attachAssignment: protectedProcedure
         .input(z.object({
         eventId: z.string(),
         assignmentId: z.string(),
     }))
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user || !ctx.user.id) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "You must be logged in to attach an assignment",
-            });
-        }
-        // Check if user owns the event
-        const event = await prisma.event.findUnique({
-            where: { id: input.eventId },
-            include: {
-                class: {
-                    include: {
-                        teachers: {
-                            select: { id: true }
-                        }
-                    }
-                }
-            }
-        });
-        if (!event) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Event not found",
-            });
-        }
-        // Check if user is the event owner or a teacher of the class
-        if (event.userId !== ctx.user.id &&
-            !event.class?.teachers.some(teacher => teacher.id === ctx.user.id)) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "You are not authorized to modify this event",
-            });
-        }
-        // Check if assignment exists and belongs to the same class
-        const assignment = await prisma.assignment.findUnique({
-            where: { id: input.assignmentId },
-            include: {
-                class: {
-                    include: {
-                        teachers: {
-                            select: { id: true }
-                        }
-                    }
-                }
-            }
-        });
-        if (!assignment) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Assignment not found",
-            });
-        }
-        // Check if user is a teacher of the assignment's class
-        if (!assignment.class.teachers.some(teacher => teacher.id === ctx.user.id)) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "You are not authorized to modify this assignment",
-            });
-        }
-        // Check if event and assignment belong to the same class
-        if (event.classId !== assignment.classId) {
-            throw new TRPCError({
-                code: "BAD_REQUEST",
-                message: "Event and assignment must belong to the same class",
-            });
-        }
-        // Attach assignment to event
-        const updatedAssignment = await prisma.assignment.update({
-            where: { id: input.assignmentId },
-            data: {
-                eventAttached: {
-                    connect: { id: input.eventId }
-                }
-            },
-            include: {
-                attachments: {
-                    select: {
-                        id: true,
-                        name: true,
-                        type: true,
-                    }
-                },
-                section: {
-                    select: {
-                        id: true,
-                        name: true
-                    }
-                },
-                teacher: {
-                    select: {
-                        id: true,
-                        username: true
-                    }
-                }
-            }
-        });
-        return { assignment: updatedAssignment };
-    }),
+        .mutation(({ ctx, input }) => attachAssignment(ctx.user.id, input.eventId, input.assignmentId)),
     detachAssignment: protectedProcedure
         .input(z.object({
         eventId: z.string(),
         assignmentId: z.string(),
     }))
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "You must be logged in to detach an assignment",
-            });
-        }
-        // Check if user owns the event
-        const event = await prisma.event.findUnique({
-            where: { id: input.eventId },
-            include: {
-                class: {
-                    include: {
-                        teachers: {
-                            select: { id: true }
-                        }
-                    }
-                }
-            }
-        });
-        if (!event) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Event not found",
-            });
-        }
-        // Check if user is the event owner or a teacher of the class
-        if (event.userId !== ctx.user.id &&
-            !event.class?.teachers.some(teacher => teacher.id === ctx.user.id)) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "You are not authorized to modify this event",
-            });
-        }
-        // Detach assignment from event
-        const updatedAssignment = await prisma.assignment.update({
-            where: { id: input.assignmentId },
-            data: {
-                eventAttached: {
-                    disconnect: true
-                }
-            },
-            include: {
-                attachments: {
-                    select: {
-                        id: true,
-                        name: true,
-                        type: true,
-                    }
-                },
-                section: {
-                    select: {
-                        id: true,
-                        name: true
-                    }
-                },
-                teacher: {
-                    select: {
-                        id: true,
-                        username: true
-                    }
-                }
-            }
-        });
-        return { assignment: updatedAssignment };
-    }),
+        .mutation(({ ctx, input }) => detachAssignment(ctx.user.id, input.eventId, input.assignmentId)),
     getAvailableAssignments: protectedProcedure
-        .input(z.object({
-        eventId: z.string(),
-    }))
-        .query(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "You must be logged in to get available assignments",
-            });
-        }
-        // Get the event to find the class
-        const event = await prisma.event.findUnique({
-            where: { id: input.eventId },
-            include: {
-                class: {
-                    include: {
-                        teachers: {
-                            select: { id: true }
-                        }
-                    }
-                }
-            }
-        });
-        if (!event || !event.classId) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Event not found",
-            });
-        }
-        // Check if user is authorized to access this event/class
-        if (event.userId !== ctx.user.id &&
-            !event.class?.teachers.some(teacher => teacher.id === ctx.user.id)) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "You are not authorized to access this event",
-            });
-        }
-        // Get all assignments for the class that are not already attached to an event
-        const assignments = await prisma.assignment.findMany({
-            where: {
-                classId: event.classId,
-                eventId: null, // Not already attached to any event
-            },
-            select: {
-                id: true,
-                title: true,
-                instructions: true,
-                dueDate: true,
-                type: true,
-                graded: true,
-                maxGrade: true,
-                weight: true,
-                section: {
-                    select: {
-                        id: true,
-                        name: true
-                    }
-                },
-                attachments: {
-                    select: {
-                        id: true,
-                        name: true,
-                        type: true,
-                    }
-                },
-                teacher: {
-                    select: {
-                        id: true,
-                        username: true
-                    }
-                }
-            },
-            orderBy: {
-                createdAt: 'desc'
-            }
-        });
-        return { assignments };
-    }),
+        .input(z.object({ eventId: z.string() }))
+        .query(({ ctx, input }) => getAvailableAssignments(ctx.user.id, input.eventId)),
 });
 //# sourceMappingURL=event.js.map
-//# debugId=a9324f3c-d989-5a88-87a3-ae7ddd7de34c
+//# debugId=4c9803f2-4631-5ddc-b780-b4b7b107df2a