put events-router

src/app.ts

@@ -9,7 +9,7 @@ import morgan from "morgan";
 import bodyParser from "body-parser";
 import errorHandler from "./middleware/error-handler";
 
-import attendeeRouter from "./services/attendees/attendee-router";
+import attendeeRouter from "./services/attendee/attendee-router";
 import authRouter from "./services/auth/auth-router";
 import eventsRouter from "./services/events/events-router";
 import notificationsRouter from "./services/notifications/notifications-router";

src/database.ts

@@ -2,12 +2,20 @@ import mongoose, { Schema, Document } from "mongoose";
 import {
     AttendeeSchema,
     AttendeeValidator,
-} from "./services/attendees/attendee-schema";
-import { RoleValidator, RoleSchema } from "./services/auth/auth-schema";
+} from "./services/attendee/attendee-schema";
+import {
+    AttendeeAttendanceSchema,
+    AttendeeAttendanceValidator,
+} from "./services/attendee/attendee-schema";
 import {
     EventSchema,
     privateEventValidator,
 } from "./services/events/events-schema";
+import {
+    EventAttendanceSchema,
+    EventAttendanceValidator,
+} from "./services/events/events-schema";
+import { RoleValidator, RoleSchema } from "./services/auth/auth-schema";
 import {
     RegistrationSchema,
     RegistrationValidator,
@@ -55,12 +63,22 @@ function initializeModel(
 export const Database = {
     ROLES: initializeModel("roles", RoleSchema, RoleValidator),
     EVENTS: initializeModel("events", EventSchema, privateEventValidator),
+    EVENTS_ATTENDANCE: initializeModel(
+        "events_attendance",
+        EventAttendanceSchema,
+        EventAttendanceValidator
+    ),
+    ATTENDEE: initializeModel("attendee", AttendeeSchema, AttendeeValidator),
+    ATTENDEE_ATTENDANCE: initializeModel(
+        "attendee_attendance",
+        AttendeeAttendanceSchema,
+        AttendeeAttendanceValidator
+    ),
     SUBSCRIPTIONS: initializeModel(
         "subscriptions",
         SubscriptionSchema,
         SubscriptionSchemaValidator
     ),
-    ATTENDEES: initializeModel("attendees", AttendeeSchema, AttendeeValidator),
     REGISTRATION: initializeModel(
         "registration",
         RegistrationSchema,

src/services/attendees/attendee-router.ts → src/services/attendee/attendee-router.ts

@@ -5,7 +5,7 @@ import { Database } from "../../database";
 import RoleChecker from "../../middleware/role-checker";
 import { Role } from "../auth/auth-models";
 import dotenv from "dotenv";
-import { generateQrHash } from "./attendees-utils";
+import { generateQrHash } from "./attendee-utils";
 
 dotenv.config();
 
@@ -15,7 +15,7 @@ const attendeeRouter = Router();
 attendeeRouter.post("/", async (req, res, next) => {
     try {
         const attendeeData = AttendeeValidator.parse(req.body);
-        const attendee = new Database.ATTENDEES(attendeeData);
+        const attendee = new Database.ATTENDEE(attendeeData);
         await attendee.save();
 
         return res.status(StatusCodes.CREATED).json(attendeeData);
@@ -51,7 +51,7 @@ attendeeRouter.get(
             const userId = payload.userId;
 
             // Check if the user exists in the database
-            const user = await Database.ATTENDEES.findOne({ userId });
+            const user = await Database.ATTENDEE.findOne({ userId });
 
             if (!user) {
                 return res

src/services/attendees/attendee-schema.ts → src/services/attendee/attendee-schema.ts

@@ -1,8 +1,8 @@
-import mongoose from "mongoose";
+import { Schema } from "mongoose";
 import { z } from "zod";
 
 // Zod schema for attendee
-const AttendeeValidator = z.object({
+export const AttendeeValidator = z.object({
     userId: z.string(),
     name: z.string(),
     email: z.string().email(),
@@ -21,17 +21,17 @@ const AttendeeValidator = z.object({
 });
 
 // Mongoose schema for attendee
-const AttendeeSchema = new mongoose.Schema({
+export const AttendeeSchema = new Schema({
     userId: { type: String, required: true, unique: true },
     name: { type: String, required: true },
     email: { type: String, required: true, unique: true },
-    events: [{ type: mongoose.Schema.Types.ObjectId, ref: "Event" }],
+    events: [{ type: Schema.Types.ObjectId, ref: "Event" }],
     dietaryRestrictions: { type: [String], required: true },
     allergies: { type: [String], required: true },
     hasCheckedIn: { type: Boolean, default: false },
     points: { type: Number, default: 0 },
     hasPriority: {
-        type: new mongoose.Schema(
+        type: new Schema(
             {
                 dayOne: { type: Boolean, default: false },
                 dayTwo: { type: Boolean, default: false },
@@ -45,4 +45,16 @@ const AttendeeSchema = new mongoose.Schema({
     },
 });
 
-export { AttendeeSchema, AttendeeValidator };
+export const AttendeeAttendanceSchema = new Schema({
+    userId: {
+        type: String,
+        ref: "Attendee",
+        required: true,
+    },
+    eventsAttended: [{ type: String, ref: "Event", required: true }],
+});
+
+export const AttendeeAttendanceValidator = z.object({
+    userId: z.string(),
+    eventsAttended: z.array(z.string()),
+});

src/services/events/events-router.ts

@@ -2,6 +2,8 @@ import { Router } from "express";
 import { StatusCodes } from "http-status-codes";
 import { publicEventValidator } from "./events-schema";
 import { Database } from "../../database";
+import { checkInUserToEvent } from "./events-utils";
+// import {mongoose} from "mongoose";
 
 const eventsRouter = Router();
 
@@ -26,6 +28,21 @@ eventsRouter.get("/currentOrNext", async (req, res, next) => {
     }
 });
 
+eventsRouter.get("/:EVENTID", async (req, res, next) => {
+    const eventId = req.params.EVENTID;
+    try {
+        const event = await Database.EVENTS.findOne({ eventId: eventId });
+        if (!event) {
+            return res
+                .status(StatusCodes.NOT_FOUND)
+                .json({ error: "DoesNotExist" });
+        }
+        return res.status(StatusCodes.OK).json(event.toObject());
+    } catch (error) {
+        next(error);
+    }
+});
+
 eventsRouter.post("/", async (req, res, next) => {
     try {
         const validatedData = publicEventValidator.parse(req.body);
@@ -37,22 +54,22 @@ eventsRouter.post("/", async (req, res, next) => {
     }
 });
 
-eventsRouter.get("/:EVENTID", async (req, res, next) => {
+eventsRouter.put("/:EVENTID", async (req, res, next) => {
     const eventId = req.params.EVENTID;
     try {
-        const unfiltered_event = await Database.EVENTS.findOne({
-            eventId: eventId,
-        });
+        const validatedData = publicEventValidator.parse(req.body);
+        const event = await Database.EVENTS.findOneAndUpdate(
+            { eventId: eventId },
+            { $set: validatedData }
+        );
 
-        if (!unfiltered_event) {
+        if (!event) {
             return res
                 .status(StatusCodes.NOT_FOUND)
                 .json({ error: "DoesNotExist" });
         }
 
-        const filtered_event = publicEventValidator.parse(unfiltered_event);
-
-        return res.status(StatusCodes.OK).json(filtered_event);
+        return res.sendStatus(StatusCodes.OK);
     } catch (error) {
         next(error);
     }
@@ -75,6 +92,7 @@ eventsRouter.get("/", async (req, res, next) => {
 eventsRouter.delete("/:EVENTID", async (req, res, next) => {
     const eventId = req.params.EVENTID;
     try {
+        // const objectId = mongoose.Types.ObjectId(eventId)
         await Database.EVENTS.findOneAndDelete({ eventId: eventId });
 
         return res.sendStatus(StatusCodes.NO_CONTENT);
@@ -83,4 +101,22 @@ eventsRouter.delete("/:EVENTID", async (req, res, next) => {
     }
 });
 
+eventsRouter.post("/check-in", async (req, res, next) => {
+    try {
+        const { eventId, userId } = req.body;
+        const result = await checkInUserToEvent(eventId, userId);
+        if (result.success) {
+            return res
+                .status(StatusCodes.OK)
+                .json({ message: "Check-in successful" });
+        } else {
+            return res
+                .status(StatusCodes.NOT_FOUND)
+                .json({ error: result.message });
+        }
+    } catch (error) {
+        next(error);
+    }
+});
+
 export default eventsRouter;

src/services/events/events-schema.ts

@@ -5,7 +5,7 @@ import { v4 as uuidv4 } from "uuid";
 export const EventType = z.enum(["A", "B", "C"]);
 
 export const publicEventValidator = z.object({
-    eventId: z.coerce.string(),
+    eventId: z.coerce.string().optional(),
     name: z.string(),
     startTime: z.coerce.date(),
     endTime: z.coerce.date(),
@@ -70,3 +70,23 @@ export const EventSchema = new Schema({
         enum: EventType.Values,
     },
 });
+
+export const EventAttendanceSchema = new Schema({
+    eventId: {
+        type: String,
+        ref: "Event",
+        required: true,
+    },
+    attendees: [
+        {
+            type: String,
+            ref: "Attendee",
+            required: true,
+        },
+    ],
+});
+
+export const EventAttendanceValidator = z.object({
+    eventId: z.string(),
+    attendees: z.array(z.string()),
+});

src/services/events/events-utils.ts

@@ -0,0 +1,37 @@
+import { Database } from "../../database";
+
+export async function checkInUserToEvent(eventId: string, userId: string) {
+    // Check if the event and attendee exist
+    const [event, attendee] = await Promise.all([
+        Database.EVENTS.findOne({ eventId }),
+        Database.ATTENDEE.findOne({ userId }),
+    ]);
+
+    console.log(event);
+    console.log(attendee);
+    if (!event || !attendee) {
+        return { success: false, message: "Event or Attendee not found" };
+    }
+
+    try {
+        // Check or create event attendance record
+        const eventAttendance = Database.EVENTS_ATTENDANCE.findOneAndUpdate(
+            { eventId: eventId },
+            { $addToSet: { attendees: userId } },
+            { new: true, upsert: true }
+        );
+
+        // Check or create attendee attendance record
+        const attendeeAttendance =
+            Database.ATTENDEE_ATTENDANCE.findOneAndUpdate(
+                { userId: userId },
+                { $addToSet: { eventsAttended: eventId } },
+                { new: true, upsert: true }
+            );
+
+        await Promise.all([eventAttendance, attendeeAttendance]);
+        return { success: true };
+    } catch (error) {
+        return { success: false, message: "couldn't upsert event or attendee" };
+    }
+}

src/services/registration/registration-router.ts

@@ -4,7 +4,7 @@ import { RegistrationValidator } from "./registration-schema";
 import { Database } from "../../database";
 import RoleChecker from "../../middleware/role-checker";
 import { Role } from "../auth/auth-models";
-import { AttendeeValidator } from "../attendees/attendee-schema";
+import { AttendeeValidator } from "../attendee/attendee-schema";
 import { registrationExists } from "./registration-utils";
 
 const registrationRouter = Router();
@@ -78,7 +78,7 @@ registrationRouter.post("/submit", RoleChecker([]), async (req, res, next) => {
 
         const attendeeData = AttendeeValidator.parse(registrationData);
 
-        await Database.ATTENDEES.findOneAndUpdate(
+        await Database.ATTENDEE.findOneAndUpdate(
             { userId: payload.userId },
             attendeeData,
             { upsert: true, setDefaultsOnInsert: true }

src/services/stats/stats-router.ts

@@ -12,7 +12,7 @@ statsRouter.get(
     RoleChecker([Role.enum.STAFF], false),
     async (req, res, next) => {
         try {
-            const attendees = await Database.ATTENDEES.find({
+            const attendees = await Database.ATTENDEE.find({
                 events: { $ne: [] },
             });
 
@@ -35,7 +35,7 @@ statsRouter.get(
                     .status(StatusCodes.BAD_REQUEST)
                     .json({ error: "MissingPriceParameter" });
             }
-            const attendees = await Database.ATTENDEES.find({
+            const attendees = await Database.ATTENDEE.find({
                 points: { $gte: price },
             });
 
@@ -52,7 +52,7 @@ statsRouter.get(
     RoleChecker([Role.enum.STAFF], false),
     async (req, res, next) => {
         try {
-            const attendees = await Database.ATTENDEES.find({
+            const attendees = await Database.ATTENDEE.find({
                 hasCheckedIn: true,
             });
 
@@ -102,23 +102,23 @@ statsRouter.get(
     async (req, res, next) => {
         try {
             const results = await Promise.allSettled([
-                Database.ATTENDEES.countDocuments({
+                Database.ATTENDEE.countDocuments({
                     allergies: { $size: 0 },
                     dietaryRestrictions: { $size: 0 },
                 }),
-                Database.ATTENDEES.countDocuments({
+                Database.ATTENDEE.countDocuments({
                     allergies: { $size: 0 },
                     dietaryRestrictions: { $ne: [] },
                 }),
-                Database.ATTENDEES.countDocuments({
+                Database.ATTENDEE.countDocuments({
                     allergies: { $ne: [] },
                     dietaryRestrictions: { $size: 0 },
                 }),
-                Database.ATTENDEES.countDocuments({
+                Database.ATTENDEE.countDocuments({
                     allergies: { $ne: [] },
                     dietaryRestrictions: { $ne: [] },
                 }),
-                Database.ATTENDEES.aggregate([
+                Database.ATTENDEE.aggregate([
                     {
                         $unwind: "$allergies",
                     },
@@ -129,7 +129,7 @@ statsRouter.get(
                         },
                     },
                 ]),
-                Database.ATTENDEES.aggregate([
+                Database.ATTENDEE.aggregate([
                     {
                         $unwind: "$dietaryRestrictions",
                     },