Cleanup & add spec to event router

Author: Timothy-Gonzalez

src/common/schemas.ts

@@ -4,6 +4,13 @@ export const SuccessResponseSchema = z.object({
     success: z.literal(true),
 });
 
+export const UserIdSchema = z.string().openapi("UserId", {
+    description: "Id of a specific user. Can start with github or google.",
+    example: "github1234",
+});
+
+export const EventIdSchema = z.string().openapi("EventId", { example: "event1" });
+
 /**
  * Creates a error object and schema zod given a error type and message
  * @param params the error type and message

src/database/event-db.ts

@@ -5,7 +5,7 @@ import { AuthInfo } from "../services/auth/auth-schemas";
 import { AttendeeFollowing, AttendeeProfile } from "./attendee-db";
 import { AdmissionDecision } from "./admission-db";
 import { MentorOfficeHours } from "./mentor-db";
-import { Event, EventAttendance, EventFollowers } from "./event-db";
+import { Event, EventAttendance, EventFollowers } from "../services/event/event-schemas";
 import { NewsletterSubscription } from "../services/newsletter/newsletter-schemas";
 import { RegistrationApplication } from "./registration-db";
 import { ShopItem } from "../services/shop/shop-schemas";

src/database/models.ts

@@ -36,7 +36,8 @@ import Models from "../../database/models";
 import { RouterError } from "../../middleware/error-handler";
 import specification, { Tag } from "../../middleware/specification";
 import { z } from "zod";
-import { UserIdSchema, UserNotFoundError, UserNotFoundErrorSchema } from "../user/user-schemas";
+import { UserNotFoundError, UserNotFoundErrorSchema } from "../user/user-schemas";
+import { UserIdSchema } from "../../common/schemas";
 
 passport.use(
     Provider.GITHUB,

src/services/auth/auth-router.ts

@@ -1,7 +1,7 @@
 import { prop } from "@typegoose/typegoose";
 import { z } from "zod";
 import { Device } from "../../common/config";
-import { UserIdSchema } from "../user/user-schemas";
+import { UserIdSchema } from "../../common/schemas";
 import { CreateErrorAndSchema } from "../../common/schemas";
 
 export class AuthInfo {

src/services/auth/auth-schemas.ts

@@ -1,6 +1,6 @@
 import { isArrayOfType, isBoolean, isEnumOfType, isNumber, isObject, isString } from "../../common/formatTools";
 import Config from "../../common/config";
-import { Event, Location } from "../../database/event-db";
+import { Event, Location } from "./event-schemas";
 import { PUBLIC_EVENT_TYPE, STAFF_EVENT_TYPE } from "./event-models";
 
 export function isValidEvent(event: Event): boolean {

src/services/event/event-formats.ts

@@ -1,27 +1,43 @@
-import { PUBLIC_EVENT_TYPE, FilteredEventView } from "./event-models";
-import { Event } from "../../database/event-db";
+import { FilterQuery } from "mongoose";
+import { Role } from "../auth/auth-schemas";
+import { Event, PublicEvent } from "./event-schemas";
 
 /**
- * Truncates a InternalEvent object to create an ExternalEvent by omitting
- * the 'isPrivate', 'displayOnStaffCheckIn', and 'isStaff' properties.
- *
- * @param baseEvent The object to convert into a public event.
- * @returns The truncated ExternalEvent object.
+ * Truncates a event into a public event by removing metadata (namely exp)
+ * @param event The event to filter
+ * @returns The filtered event
  */
-export function createFilteredEventView(baseEvent: Event): FilteredEventView {
-    const publicEvent: FilteredEventView = {
-        eventId: baseEvent.eventId,
-        name: baseEvent.name,
-        description: baseEvent.description,
-        startTime: baseEvent.startTime,
-        endTime: baseEvent.endTime,
-        locations: baseEvent.locations,
-        sponsor: baseEvent.sponsor,
-        eventType: baseEvent.eventType as PUBLIC_EVENT_TYPE,
-        points: baseEvent.points ?? 0,
-        isAsync: baseEvent.isAsync,
-        mapImageUrl: baseEvent.mapImageUrl,
-        isPro: baseEvent.isPro ?? false,
+export function filterEvent(event: Event): PublicEvent {
+    return {
+        eventId: event.eventId,
+        isStaff: event.isStaff,
+        name: event.name,
+        description: event.description,
+        startTime: event.startTime,
+        endTime: event.endTime,
+        eventType: event.eventType,
+        locations: event.locations,
+        isAsync: event.isAsync,
+        mapImageUrl: event.mapImageUrl,
+        sponsor: event.sponsor,
+        points: event.points,
+        isPrivate: event.isPrivate,
+        displayOnStaffCheckIn: event.displayOnStaffCheckIn,
+        isPro: event.isPro,
     };
-    return publicEvent;
+}
+
+/**
+ * Returns a filter query to filter out events that the roles specified cannot access
+ * @param roles The roles to restrict by
+ * @returns A filter query to restrict events based on roles
+ */
+export function restrictEventsByRoles(roles: Role[]): FilterQuery<Event> {
+    if (roles.includes(Role.STAFF)) {
+        return {};
+    } else if (roles.includes(Role.PRO)) {
+        return { isPrivate: false, isStaff: false };
+    } else {
+        return { isPrivate: false, isStaff: false, isPro: false };
+    }
 }

src/services/event/event-lib.ts

@@ -1,6 +1,6 @@
 // Enum representing the type of the event
 
-import { Location } from "../../database/event-db";
+import { Location } from "./event-schemas";
 
 // MEAL, SPEAKER, WORKSHOP, MINIEVENT, QNA, or OTHER
 export enum PUBLIC_EVENT_TYPE {

src/services/event/event-models.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, beforeEach } from "@jest/globals";
-import { EventFollowers } from "../../database/event-db";
+import { EventFollowers } from "./event-schemas";
 import { AttendeeFollowing } from "../../database/attendee-db";
 import Models from "../../database/models";
 import { StatusCode } from "status-code-enum";
@@ -23,9 +23,9 @@ beforeEach(async () => {
 
 describe("GET /event/followers/", () => {
     it("gives an forbidden error for a non-staff user", async () => {
-        const response = await getAsAttendee(`/event/followers/`)
-            .send({ eventId: TESTER_EVENT_FOLLOWERS.eventId })
-            .expect(StatusCode.ClientErrorForbidden);
+        const response = await getAsAttendee(`/event/followers/${TESTER_EVENT_FOLLOWERS.eventId}/`).expect(
+            StatusCode.ClientErrorForbidden,
+        );
 
         expect(JSON.parse(response.text)).toHaveProperty("error", "Forbidden");
     });
@@ -35,17 +35,15 @@ describe("GET /event/followers/", () => {
             eventId: TESTER_EVENT_FOLLOWERS.eventId,
         });
 
-        const response = await getAsStaff(`/event/followers/`)
-            .send({ eventId: TESTER_EVENT_FOLLOWERS.eventId })
-            .expect(StatusCode.ClientErrorNotFound);
+        const response = await getAsStaff(`/event/followers/${TESTER_EVENT_FOLLOWERS.eventId}/`).expect(
+            StatusCode.ClientErrorNotFound,
+        );
 
-        expect(JSON.parse(response.text)).toHaveProperty("error", "EventNotFound");
+        expect(JSON.parse(response.text)).toHaveProperty("error", "NotFound");
     });
 
     it("works for a staff user", async () => {
-        const response = await getAsStaff(`/event/followers/`)
-            .send({ eventId: TESTER_EVENT_FOLLOWERS.eventId })
-            .expect(StatusCode.SuccessOK);
+        const response = await getAsStaff(`/event/followers/${TESTER_EVENT_FOLLOWERS.eventId}/`).expect(StatusCode.SuccessOK);
 
         expect(JSON.parse(response.text)).toMatchObject({
             eventId: TESTER_EVENT_FOLLOWERS.eventId,