@studious-lms/server 1.0.1 → 1.0.3

package/src/routers/attendance.ts

@@ -0,0 +1,284 @@
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc";
+import { TRPCError } from "@trpc/server";
+import { prisma } from "../lib/prisma";
+
+const attendanceSchema = z.object({
+  eventId: z.string().optional(),
+  present: z.array(z.object({ id: z.string(), username: z.string() })),
+  late: z.array(z.object({ id: z.string(), username: z.string() })),
+  absent: z.array(z.object({ id: z.string(), username: z.string() })),
+});
+
+export const attendanceRouter = createTRPCRouter({
+  get: protectedProcedure
+    .input(z.object({
+      classId: z.string(),
+      eventId: z.string().optional(),
+    }))
+    .query(async ({ ctx, input }) => {
+      if (!ctx.user) {
+        throw new 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.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 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.event.findMany({
+        where: {
+          classId: input.classId,
+        },
+      });
+      
+      for (const event of events) {
+        const attendance = await prisma.attendance.findFirst({
+          where: {
+            eventId: event.id,
+          },
+        });
+        
+        if (!attendance) {
+          await 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.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: protectedProcedure
+    .input(z.object({
+      classId: z.string(),
+      eventId: z.string().optional(),
+      attendance: attendanceSchema,
+    }))
+    .mutation(async ({ ctx, input }) => {
+      if (!ctx.user) {
+        throw new 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.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 update this class's attendance",
+        });
+      }
+
+      // Check if attendance record exists
+      const existingAttendance = await prisma.attendance.findFirst({
+        where: {
+          classId: input.classId,
+          eventId: input.eventId,
+        },
+      });
+
+      if (!existingAttendance) {
+        // Create new attendance record
+        const attendance = await 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.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/src/routers/auth.ts

@@ -0,0 +1,286 @@
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure, publicProcedure } from "../trpc";
+import { TRPCError } from "@trpc/server";
+import { prisma } from "../lib/prisma";
+import { v4 as uuidv4 } from 'uuid';
+import { compare, hash } from "bcryptjs";
+import { transport } from "../utils/email";
+
+const loginSchema = z.object({
+  username: z.string(),
+  password: z.string(),
+});
+
+const registerSchema = z.object({
+  username: z.string().min(3, "Username must be at least 3 characters"),
+  email: z.string().email("Invalid email address"),
+  password: z.string().min(6, "Password must be at least 6 characters"),
+  confirmPassword: z.string(),
+}).refine((data) => data.password === data.confirmPassword, {
+  message: "Passwords don't match",
+  path: ["confirmPassword"],
+});
+
+export const authRouter = createTRPCRouter({
+  register: publicProcedure
+    .input(registerSchema)
+    .mutation(async ({ input }) => {
+      const { username, email, password } = input;
+
+      // Check if username already exists
+      const existingUser = await prisma.user.findFirst({
+        where: { 
+          OR: [
+            { username },
+            { email }
+          ]
+        },
+        select: {
+          id: true,
+          username: true,
+          email: true,
+          verified: true,
+        }
+      });
+
+      if (existingUser && existingUser.verified) {
+        if (existingUser.username === username) {
+          throw new TRPCError({
+            code: "CONFLICT",
+            message: "Username already exists",
+          });
+        }
+        if (existingUser.email === email) {
+          throw new TRPCError({
+            code: "CONFLICT",
+            message: "Email already exists",
+          });
+        }
+      } else if (existingUser && !existingUser.verified) {
+        await prisma.session.deleteMany({
+          where: { userId: existingUser.id },
+        });
+
+        await prisma.user.delete({
+          where: { id: existingUser.id },
+        });
+      }
+
+      // Create new user
+      const user = await prisma.user.create({
+        data: {
+          username,
+          email,
+          password: await hash(password, 10),
+          profile: {},
+        },
+        select: {
+          id: true,
+          username: true,
+          email: true,
+        }
+      });
+
+      const verificationToken = await prisma.session.create({
+        data: {
+          id: uuidv4(),
+          userId: user.id,
+          expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 30),
+        },
+      });
+
+      await transport.sendMail({
+        from: 'noreply@studious.sh',
+        to: user.email,
+        subject: 'Verify your email',
+        text: `Click the link to verify your email: ${process.env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`,
+      });
+
+      return {
+        user: {
+          id: user.id,
+          username: user.username,
+        },
+      };
+    }),
+
+  login: publicProcedure
+    .input(loginSchema)
+    .mutation(async ({ input }) => {
+      const { username, password } = input;
+
+      const user = await prisma.user.findFirst({
+        where: { username },
+        select: {
+          id: true,
+          username: true,
+          password: true,
+          email: true,
+          verified: true,
+        }
+      });
+
+      if (!user) {
+        throw new TRPCError({
+          code: "UNAUTHORIZED",
+          message: "Invalid username or password",
+        });
+      }
+
+      if (await compare(password, user.password)) {
+        throw new TRPCError({
+          code: "UNAUTHORIZED",
+          message: "Invalid username or password",
+        });
+      }
+
+      if (!user.verified) {
+        return {
+          verified: false,
+          user: {
+            email: user.email,
+          },
+        }
+      }
+
+      // Create a new session
+      const session = await prisma.session.create({
+        data: {
+          id: uuidv4(),
+          userId: user.id,
+          expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 30),
+        },
+      });
+
+      return {
+        token: session.id,
+        user: {
+          id: user.id,
+          username: user.username,
+        },
+      };
+    }),
+
+  logout: publicProcedure
+    .mutation(async ({ ctx }) => {
+      if (!ctx.user) {
+        throw new TRPCError({
+          code: "UNAUTHORIZED",
+          message: "Not authenticated",
+        });
+      }
+
+      // Delete the current session
+      await prisma.session.deleteMany({
+        where: { userId: ctx.user.id },
+      });
+
+      return { success: true };
+    }),
+
+  check: protectedProcedure
+    .query(async ({ ctx }) => {
+      if (!ctx.user) {
+        throw new TRPCError({
+          code: "UNAUTHORIZED",
+          message: "Not authenticated",
+        });
+      }
+
+      const user = await prisma.user.findUnique({
+        where: { id: ctx.user.id },
+        select: {
+          id: true,
+          username: true,
+        }
+      });
+
+      if (!user) {
+        throw new TRPCError({
+          code: "NOT_FOUND",
+          message: "User not found",
+        });
+      }
+
+      return {user};
+    }),
+    resendVerificationEmail: publicProcedure
+      .input(z.object({
+        email: z.string().email(),
+      }))
+      .mutation(async ({ input }) => {
+        const { email } = input;
+
+        const user = await prisma.user.findFirst({
+          where: { 
+            email,
+           },
+          select: {
+            id: true,
+            email: true,
+          },
+        });
+
+        if (!user) {
+          throw new TRPCError({
+            code: "NOT_FOUND",
+            message: "User not found",
+          });
+        }
+
+        await prisma.session.deleteMany({
+          where: { userId: user?.id },
+        });
+
+        const verificationToken = await prisma.session.create({
+          data: {
+            id: uuidv4(),
+            userId: user.id,
+            expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 30),
+          },
+        });
+        
+        await transport.sendMail({
+          from: 'noreply@studious.sh',
+          to: user.email,
+          subject: 'Verify your email',
+          text: `Click the link to verify your email: ${process.env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`,
+        });
+
+        return { success: true };
+      }),
+    verify: publicProcedure
+      .input(z.object({
+        token: z.string(),
+      }))
+      .mutation(async ({ input }) => {
+        const { token } = input;
+
+        const session = await prisma.session.findUnique({
+          where: { id: token },
+        });
+
+        if (!session) {
+          throw new TRPCError({
+            code: "NOT_FOUND",
+            message: "Session not found",
+          });
+        }
+
+        if (session.expiresAt && session.expiresAt < new Date()) {
+          throw new TRPCError({
+            code: "UNAUTHORIZED",
+            message: "Session expired",
+          });
+        }
+
+        await prisma.user.update({
+          where: { id: session.userId! },
+          data: {
+            verified: true,
+          },
+        });
+
+        return { success: true };
+      }),
+});