Save user events

src/controllers/event.controller.ts

@@ -2,26 +2,36 @@ import { Context, ObjectId, RouterContext, Status } from '../../deps.ts';
 import { eventService } from '../services/event.service.ts';
 import { generateEvents } from '../services/openai.service.ts';
 import { eventFilterSchema, FullEvent } from 'models/event.model.ts';
+import { verifyToken } from '../utils/token.utils.ts';
+import { Payload } from '../../deps.ts';
+import { userService } from '../services/user.service.ts';
 
 export const getAllEvents = async (ctx: Context) => {
-  const params = ctx.request.url.searchParams;
+  const auth = ctx.request.headers.get('Authorization');
+  const token = auth && auth.split(' ')[1];
+
+  let userId: string | null = null;
+  if (token) {
+    try {
+      const user: Payload = await verifyToken(token);
+      userId = user._id as string;
+    } catch (error) {
+      console.warn('Invalid token in /events: ' + error);
+    }
+  }
 
+  const params = ctx.request.url.searchParams;
   const rawModes = params.getAll('mode');
-
   const normalizedModes = rawModes
     .flatMap((param) => param.split(','))
     .map((mode) => mode.trim().toLowerCase())
-    .filter(Boolean); // removes empty strings
+    .filter(Boolean);
 
   const parseResult = eventFilterSchema.safeParse({
     mode: normalizedModes.length > 0 ? normalizedModes : undefined,
   });
 
-  let allEvents;
-  if (parseResult.success) {
-    console.log(parseResult.data);
-    allEvents = await eventService.getAllEvents(parseResult.data);
-  } else {
+  if (!parseResult.success) {
     ctx.response.status = Status.BadRequest;
     ctx.response.body = {
       error: 'Invalid query parameters',
@@ -30,7 +40,21 @@ export const getAllEvents = async (ctx: Context) => {
     return;
   }
 
-  ctx.response.body = allEvents;
+  try {
+    const [allEvents, savedEvents] = await Promise.all([
+      eventService.getAllEvents(parseResult.data),
+      userId ? userService.getUserEvents(userId) : Promise.resolve([]),
+    ]);
+
+    ctx.response.body = {
+      events: allEvents,
+      savedEventIds: savedEvents.map((x) => x._id),
+    };
+  } catch (err) {
+    console.error('Error fetching combined event data:', err);
+    ctx.response.status = Status.InternalServerError;
+    ctx.response.body = { error: 'Internal server error' };
+  }
 };
 
 export const getEventById = async (ctx: RouterContext<'/:id'>) => {
@@ -64,8 +88,8 @@ export const updateEventById = async (ctx: RouterContext<'/:id'>) => {
   }
 
   const id: string = ctx.params.id;
-  const event: FullEvent = await ctx.request.body.json();
-
+  const event: Partial<FullEvent> = await ctx.request.body.json();
+  console.log(event);
   if (!ObjectId.isValid(id)) {
     ctx.response.status = Status.BadRequest;
     ctx.response.body = `Invalid event id "${id}"`;

src/controllers/user.controller.ts

@@ -1,8 +1,9 @@
 // deno-lint-ignore-file require-await
-import { Context, RouterContext } from '../../deps.ts';
+import { Context, Payload, RouterContext } from '../../deps.ts';
 import { userService } from '../services/user.service.ts';
 import { Status } from '../../deps.ts';
 import { toSafeUser } from 'models/user.model.ts';
+
 export const getUserProfile = async (ctx: Context) => {
   // TODO: Get user data from ctx.state.user
   ctx.response.body = { message: 'Get user profile' };
@@ -17,7 +18,7 @@ export const deleteUserAccount = async (ctx: Context) => {
   // TODO: Call userService.deleteUser(ctx.state.user.id)
   ctx.response.body = { message: 'Delete user account' };
 };
-export const getAllUsers = async (ctx: RouterContext<'/:role'>) => {
+export const getAllUsers = async (ctx: RouterContext<'/getUsers:role'>) => {
   const role = ctx.params.role;
 
   if (role !== 'user' && role !== 'admin' && role !== 'all') {
@@ -40,3 +41,23 @@ export const getAllUsers = async (ctx: RouterContext<'/:role'>) => {
     }
   }
 };
+
+export const handleUserEvents = async (ctx: Context) => {
+  try {
+    const user: Payload = ctx.state.user;
+
+    if (!user || !user._id) {
+      ctx.response.status = Status.Unauthorized;
+      ctx.response.body = { message: 'Unauthorized: Invalid token' };
+      return;
+    }
+    const body = await ctx.request.body.json();
+    const { eventId, active } = body;
+    const userId = user._id as string;
+
+    await userService.handleUserEvents(eventId, userId, active);
+    return ctx.response.body = 'User event handled';
+  } catch (error) {
+    console.error('Issue saving user events: ' + error);
+  }
+};

src/routes/user.routes.ts

@@ -1,19 +1,13 @@
 import { Router } from '../../deps.ts';
 import protectAdmin from '../middleware/requireAdmin.ts';
 import ProtectRoute from '../middleware/protectRoute.ts';
-import { getAllUsers } from '../controllers/user.controller.ts';
-const router = new Router();
-
-// Routes under /users
+import {
+  getAllUsers,
+  handleUserEvents,
+} from '../controllers/user.controller.ts';
 
-// Temporary stub for testing
-router.get('/', (ctx) => {
-  ctx.response.body = 'User route root';
-});
-router.get('/:role', ProtectRoute, protectAdmin, getAllUsers);
-// -> to controllers
-// router.get("/me", getUserProfile)
-// router.put("/me", updateUserProfile)
-// router.delete("/me", deleteUserAccount)
+const router = new Router();
 
+router.get('/getUsers:role', ProtectRoute, protectAdmin, getAllUsers);
+router.post('/saveUserEvents', ProtectRoute, handleUserEvents);
 export default router;

src/services/event.service.ts

@@ -32,7 +32,7 @@ const getEventById = async (id: string): Promise<FullEvent | null> => {
   return await events.findOne({ _id: new ObjectId(id) });
 };
 
-const updateEventById = async (id: string, event: FullEvent) => {
+const updateEventById = async (id: string, event: Partial<FullEvent>) => {
   return await events.updateOne({ _id: new ObjectId(id) }, { $set: event });
 };
 

src/services/user.service.ts

@@ -6,10 +6,12 @@
 import 'https://deno.land/std@0.224.0/dotenv/load.ts';
 import { db } from '../database/connect.ts';
 import { UserInDB } from 'models/user.model.ts';
-import { hash, OptionalId } from '../../deps.ts';
+import { hash, ObjectId, OptionalId } from '../../deps.ts';
 import { NewUser } from 'models/user.model.ts';
+import { FullEvent } from '../../shared/src/models/event.model.ts';
 
 const users = db.collection<OptionalId<UserInDB>>('users');
+const events = db.collection<FullEvent>('events');
 
 const getAllUsers = async (
   role: 'user' | 'admin' | 'all',
@@ -18,10 +20,6 @@ const getAllUsers = async (
   return await users.find(query).toArray();
 };
 
-export const userService = {
-  getAllUsers,
-};
-
 const _createAdmin = async () => {
   const passwordHash = await hash('supersecretadminpassword');
   const userToInsert: NewUser = {
@@ -37,3 +35,39 @@ const _createAdmin = async () => {
 
   console.log('Admin created:', result);
 };
+
+const handleUserEvents = async (
+  eventId: string,
+  userId: string,
+  saving: boolean,
+) => {
+  console.log(saving);
+  if (saving === true) {
+    await users.updateOne(
+      { _id: new ObjectId(userId) },
+      { $addToSet: { saved_events: new ObjectId(eventId) } },
+    );
+  } else {
+    await users.updateOne(
+      { _id: new ObjectId(userId) },
+      { $pull: { saved_events: new ObjectId(eventId) } },
+    );
+  }
+};
+
+const getUserEvents = async (userId: string) => {
+  const user = await users.findOne({ _id: new ObjectId(userId) });
+  const savedEvents = user?.saved_events ?? [];
+  const eventsList = await events.find({ _id: { $in: savedEvents } }).toArray();
+  return eventsList;
+};
+
+export const userService = {
+  getAllUsers,
+  handleUserEvents,
+  getUserEvents,
+};
+/*
+User clicks heart. Event target id? This is passed to backend via post request. Route grabs this. Calls this function via the
+user controller. Save the id which should reference
+*/