@studious-lms/server 1.0.0

package/dist/routers/attendance.d.ts

@@ -0,0 +1,99 @@
+import { z } from "zod";
+export declare const attendanceRouter: import("@trpc/server/dist/unstable-core-do-not-import").BuiltRouter<{
+    ctx: import("../trpc").Context;
+    meta: object;
+    errorShape: {
+        data: {
+            zodError: z.typeToFlattenedError<any, string> | null;
+            code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: false;
+}, import("@trpc/server/dist/unstable-core-do-not-import").DecorateCreateRouterOptions<{
+    get: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            classId: string;
+            eventId?: string | undefined;
+        };
+        output: ({
+            event: {
+                id: string;
+                name: string | null;
+                color: string | null;
+                startTime: Date;
+                endTime: Date;
+                location: string | null;
+            } | null;
+            late: {
+                id: string;
+                username: string;
+            }[];
+            present: {
+                id: string;
+                username: string;
+            }[];
+            absent: {
+                id: string;
+                username: string;
+            }[];
+        } & {
+            id: string;
+            classId: string;
+            date: Date;
+            eventId: string | null;
+        })[];
+    }>;
+    update: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            attendance: {
+                late: {
+                    id: string;
+                    username: string;
+                }[];
+                present: {
+                    id: string;
+                    username: string;
+                }[];
+                absent: {
+                    id: string;
+                    username: string;
+                }[];
+                eventId?: string | undefined;
+            };
+            classId: string;
+            eventId?: string | undefined;
+        };
+        output: {
+            event: {
+                id: string;
+                name: string | null;
+                startTime: Date;
+                endTime: Date;
+                location: string | null;
+            } | null;
+            late: {
+                id: string;
+                username: string;
+            }[];
+            present: {
+                id: string;
+                username: string;
+            }[];
+            absent: {
+                id: string;
+                username: string;
+            }[];
+        } & {
+            id: string;
+            classId: string;
+            date: Date;
+            eventId: string | null;
+        };
+    }>;
+}>>;
+//# sourceMappingURL=attendance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"attendance.d.ts","sourceRoot":"","sources":["../../src/routers/attendance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+Q3B,CAAC"}

package/dist/routers/attendance.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attendanceRouter = void 0;
+const zod_1 = require("zod");
+const trpc_1 = require("../trpc");
+const server_1 = require("@trpc/server");
+const prisma_1 = require("@lib/prisma");
+const attendanceSchema = zod_1.z.object({
+    eventId: zod_1.z.string().optional(),
+    present: zod_1.z.array(zod_1.z.object({ id: zod_1.z.string(), username: zod_1.z.string() })),
+    late: zod_1.z.array(zod_1.z.object({ id: zod_1.z.string(), username: zod_1.z.string() })),
+    absent: zod_1.z.array(zod_1.z.object({ id: zod_1.z.string(), username: zod_1.z.string() })),
+});
+exports.attendanceRouter = (0, trpc_1.createTRPCRouter)({
+    get: trpc_1.protectedProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+        eventId: zod_1.z.string().optional(),
+    }))
+        .query(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You must be logged in to view attendance",
+            });
+        }
+        // Check if user is a teacher or student of the class
+        const classData = await prisma_1.prisma.class.findUnique({
+            where: {
+                id: input.classId,
+                OR: [
+                    {
+                        teachers: {
+                            some: {
+                                id: ctx.user.id,
+                            },
+                        },
+                    },
+                    {
+                        students: {
+                            some: {
+                                id: ctx.user.id,
+                            },
+                        },
+                    },
+                ],
+            },
+            select: {
+                students: {
+                    select: {
+                        id: true,
+                    },
+                },
+            },
+        });
+        if (!classData) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You are not authorized to view this class's attendance",
+            });
+        }
+        // check each event has an attendance, if not create one
+        const events = await prisma_1.prisma.event.findMany({
+            where: {
+                classId: input.classId,
+            },
+        });
+        for (const event of events) {
+            const attendance = await prisma_1.prisma.attendance.findFirst({
+                where: {
+                    eventId: event.id,
+                },
+            });
+            if (!attendance) {
+                await prisma_1.prisma.attendance.create({
+                    data: {
+                        event: {
+                            connect: {
+                                id: event.id,
+                            },
+                        },
+                        class: {
+                            connect: {
+                                id: input.classId,
+                            },
+                        },
+                        present: {
+                            connect: classData.students.map(student => ({ id: student.id })),
+                        },
+                    },
+                });
+            }
+        }
+        const attendance = await prisma_1.prisma.attendance.findMany({
+            where: {
+                classId: input.classId,
+                ...(input.eventId ? { eventId: input.eventId } : {}),
+            },
+            include: {
+                event: {
+                    select: {
+                        id: true,
+                        name: true,
+                        startTime: true,
+                        endTime: true,
+                        location: true,
+                        color: true,
+                    },
+                },
+                present: {
+                    select: {
+                        id: true,
+                        username: true,
+                    },
+                },
+                late: {
+                    select: {
+                        id: true,
+                        username: true,
+                    },
+                },
+                absent: {
+                    select: {
+                        id: true,
+                        username: true,
+                    },
+                },
+            },
+            orderBy: {
+                date: "desc",
+            },
+        });
+        return attendance;
+    }),
+    update: trpc_1.protectedProcedure
+        .input(zod_1.z.object({
+        classId: zod_1.z.string(),
+        eventId: zod_1.z.string().optional(),
+        attendance: attendanceSchema,
+    }))
+        .mutation(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You must be logged in to update attendance",
+            });
+        }
+        // Check if user is a teacher of the class
+        const classData = await prisma_1.prisma.class.findUnique({
+            where: {
+                id: input.classId,
+                teachers: {
+                    some: {
+                        id: ctx.user.id,
+                    },
+                },
+            },
+        });
+        if (!classData) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You are not authorized to update this class's attendance",
+            });
+        }
+        // Check if attendance record exists
+        const existingAttendance = await prisma_1.prisma.attendance.findFirst({
+            where: {
+                classId: input.classId,
+                eventId: input.eventId,
+            },
+        });
+        if (!existingAttendance) {
+            // Create new attendance record
+            const attendance = await prisma_1.prisma.attendance.create({
+                data: {
+                    classId: input.classId,
+                    eventId: input.eventId,
+                    date: new Date(),
+                    present: {
+                        connect: input.attendance.present.map(student => ({ id: student.id })),
+                    },
+                    late: {
+                        connect: input.attendance.late.map(student => ({ id: student.id })),
+                    },
+                    absent: {
+                        connect: input.attendance.absent.map(student => ({ id: student.id })),
+                    },
+                },
+                include: {
+                    event: {
+                        select: {
+                            id: true,
+                            name: true,
+                            startTime: true,
+                            endTime: true,
+                            location: true,
+                        },
+                    },
+                    present: {
+                        select: {
+                            id: true,
+                            username: true,
+                        },
+                    },
+                    late: {
+                        select: {
+                            id: true,
+                            username: true,
+                        },
+                    },
+                    absent: {
+                        select: {
+                            id: true,
+                            username: true,
+                        },
+                    },
+                },
+            });
+            return attendance;
+        }
+        // Update existing attendance record
+        const attendance = await prisma_1.prisma.attendance.update({
+            where: {
+                id: existingAttendance.id,
+            },
+            data: {
+                present: {
+                    set: input.attendance.present.map(student => ({ id: student.id })),
+                },
+                late: {
+                    set: input.attendance.late.map(student => ({ id: student.id })),
+                },
+                absent: {
+                    set: input.attendance.absent.map(student => ({ id: student.id })),
+                },
+            },
+            include: {
+                event: {
+                    select: {
+                        id: true,
+                        name: true,
+                        startTime: true,
+                        endTime: true,
+                        location: true,
+                    },
+                },
+                present: {
+                    select: {
+                        id: true,
+                        username: true,
+                    },
+                },
+                late: {
+                    select: {
+                        id: true,
+                        username: true,
+                    },
+                },
+                absent: {
+                    select: {
+                        id: true,
+                        username: true,
+                    },
+                },
+            },
+        });
+        return attendance;
+    }),
+});

package/dist/routers/auth.d.ts

@@ -0,0 +1,87 @@
+import { z } from "zod";
+export declare const authRouter: import("@trpc/server/dist/unstable-core-do-not-import").BuiltRouter<{
+    ctx: import("../trpc").Context;
+    meta: object;
+    errorShape: {
+        data: {
+            zodError: z.typeToFlattenedError<any, string> | null;
+            code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: false;
+}, import("@trpc/server/dist/unstable-core-do-not-import").DecorateCreateRouterOptions<{
+    register: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            username: string;
+            email: string;
+            password: string;
+            confirmPassword: string;
+        };
+        output: {
+            user: {
+                id: string;
+                username: string;
+            };
+        };
+    }>;
+    login: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            username: string;
+            password: string;
+        };
+        output: {
+            verified: boolean;
+            user: {
+                email: string;
+                id?: undefined;
+                username?: undefined;
+            };
+            token?: undefined;
+        } | {
+            token: string;
+            user: {
+                id: string;
+                username: string;
+                email?: undefined;
+            };
+            verified?: undefined;
+        };
+    }>;
+    logout: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            success: boolean;
+        };
+    }>;
+    check: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            user: {
+                id: string;
+                username: string;
+            };
+        };
+    }>;
+    resendVerificationEmail: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            email: string;
+        };
+        output: {
+            success: boolean;
+        };
+    }>;
+    verify: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            token: string;
+        };
+        output: {
+            success: boolean;
+        };
+    }>;
+}>>;
+//# sourceMappingURL=auth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/routers/auth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuBxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsQrB,CAAC"}