I112 public events get route

controllers/events.ts

@@ -2,7 +2,11 @@ import { Event } from '@prisma/client';
 import { Request, Response } from 'express';
 import Boom from '@hapi/boom';
 import prisma from '../prisma/prisma';
-import { findEvent, findEventFromCalendar } from '../services/eventsService';
+import {
+  findEvent,
+  findEventFromCalendar,
+  findPublicEvent,
+} from '../services/eventsService';
 
 /**
  * Route used to post event
@@ -44,6 +48,7 @@ const postEvent = async (
       ownerId: userId,
       calendarId: eventData.calendarId,
       eventTypeId: 1,
+      isPrivate: eventData.isPrivate,
       Attendees: {
         createMany: { data: allAttendeesData },
       },
@@ -166,4 +171,29 @@ const getCalendarEvents = async (req: Request, res: Response): Promise<any> => {
   }
 };
 
-export { postEvent, patchEvent, getEvents, getCalendarEvents };
+/**
+ * Get public event start and end time (child events)
+ *
+ * @param req {Object} - Express request object
+ * @param res {Object} - Express response object
+ */
+const getPublicEvents = async (req: Request, res: Response): Promise<any> => {
+  try {
+    const { startTime, endTime } = req.query;
+
+    const eventResponse: any = await findPublicEvent(
+      Number(startTime),
+      Number(endTime)
+    );
+
+    if (!eventResponse) {
+      return res.boom(Boom.notFound('Events not found'));
+    }
+    return res.status(200).send({ data: eventResponse });
+  } catch (err) {
+    logger.error('Error while getting event', { err });
+    return res.boom(Boom.badImplementation());
+  }
+};
+
+export { postEvent, patchEvent, getEvents, getCalendarEvents, getPublicEvents };

middlewares/validators/zod-schemas/events.ts

@@ -13,6 +13,7 @@ const postEventSchema = z.object({
       endTime: z.number(),
       calendarId: z.number(),
       attendees: z.array(z.string()).optional(),
+      isPrivate: z.boolean(),
       // TODO: Recuring event to be added
     })
     .strict(),
@@ -32,6 +33,7 @@ const patchEventSchema = z.object({
       endTime: z.number().optional(),
       calendarId: z.number().optional(),
       attendees: z.array(z.string()).optional(),
+      isPrivate: z.boolean(),
       // TODO: Recuring event to be added
     })
     .strict(),
@@ -53,9 +55,17 @@ const getCalenderEventSchema = z.object({
   }),
 });
 
+const getPublicEventSchema = z.object({
+  query: z.object({
+    startTime: z.preprocess((a) => Number(a), z.number().positive()).optional(),
+    endTime: z.preprocess((a) => Number(a), z.number().positive()).optional(),
+  }),
+});
+
 export {
   postEventSchema,
   patchEventSchema,
   getEventSchema,
   getCalenderEventSchema,
+  getPublicEventSchema,
 };

prisma/schema.prisma

@@ -69,6 +69,7 @@ model Event {
   EventType      EventType?       @relation(fields: [eventTypeId], references: [id])
   calendarId     Int
   Calendar       Calendar?        @relation(fields: [calendarId], references: [id])
+  isPrivate      Boolean          @default(true)
   isDeleted      Boolean          @default(false)
   RecurringEvent RecurringEvent[]
   Attendees      Attendees[]

routes/events.ts

@@ -4,6 +4,7 @@ import {
   getEvents,
   postEvent,
   patchEvent,
+  getPublicEvents,
 } from '../controllers/events';
 import authenticate from '../middlewares/authenticate';
 import { validate } from '../middlewares/validators/validator';
@@ -12,6 +13,7 @@ import {
   getEventSchema,
   postEventSchema,
   patchEventSchema,
+  getPublicEventSchema,
 } from '../middlewares/validators/zod-schemas/events';
 import {
   calendarBelongsToUser,
@@ -21,6 +23,7 @@ import {
 const router = Router();
 
 /* eslint-disable @typescript-eslint/no-misused-promises */
+router.get('/', authenticate, validate(getPublicEventSchema), getPublicEvents);
 router.post(
   '/',
   authenticate,
@@ -49,6 +52,7 @@ router.get(
   calendarBelongsToUser,
   getCalendarEvents
 );
+
 /* eslint-disable @typescript-eslint/no-misused-promises */
 
 export default router;

services/eventsService.ts

@@ -70,6 +70,44 @@ const findEventFromCalendar = async (
   }
 };
 
+const findPublicEvent = async (
+  startTime: number,
+  endTime: number
+): Promise<eventWithAttendees[]> => {
+  try {
+    const whereCondition: {} = {
+      isDeleted: false,
+      isPrivate: false,
+      ...(startTime && { startTime: { gte: new Date(startTime) } }),
+      ...(endTime && { endTime: { lte: new Date(endTime) } }),
+    };
+
+    // TODO: add pagination
+
+    const event: eventWithAttendees[] = await prisma.event.findMany({
+      where: whereCondition,
+      include: {
+        Attendees: {
+          select: {
+            attendee: {
+              select: {
+                email: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    return event;
+  } catch (err) {
+    logger.error('parentEvent: error while finding parent event', {
+      err,
+    });
+    throw err;
+  }
+};
+
 const findCalendarWithId = async (
   calendarId: number
 ): Promise<Calendar | null> => {
@@ -89,6 +127,7 @@ const findEventWithId = async (eventId: number): Promise<Event | null> => {
 export {
   findEvent,
   findEventFromCalendar,
+  findPublicEvent,
   findCalendarWithId,
   findEventWithId,
 };