Create weekly event recurring instance

src/db.ts

@@ -2,6 +2,8 @@ import mongoose from "mongoose";
 import { MONGO_DB_URL } from "./constants";
 import { logger } from "./libraries";
 
+let session!: mongoose.ClientSession;
+
 export const connect = async (): Promise<void> => {
   try {
     await mongoose.connect(MONGO_DB_URL as string, {
@@ -10,6 +12,7 @@ export const connect = async (): Promise<void> => {
       useFindAndModify: false,
       useNewUrlParser: true,
     });
+    session = await mongoose.startSession();
   } catch (error: unknown) {
     if (error instanceof Error) {
       const errorMessage = error.toString();
@@ -45,5 +48,8 @@ export const connect = async (): Promise<void> => {
 };
 
 export const disconnect = async (): Promise<void> => {
+  session?.endSession();
   await mongoose.connection.close();
 };
+
+export { session };

src/resolvers/Mutation/createEvent.ts

@@ -11,6 +11,8 @@
 import { compareDates } from "../../libraries/validators/compareDates";
 import { EventAttendee } from "../../models/EventAttendee";
 import { cacheEvents } from "../../services/EventCache/cacheEvents";
+import type mongoose from "mongoose";
+import { session } from "../../db";
 
 /**
  * This function enables to create an event.
@@ -119,49 +121,56 @@
     );
   }
 
-  // Creates new event.
-  const createdEvent = await Event.create({
-    ...args.data,
-    creator: currentUser._id,
-    admins: [currentUser._id],
-    organization: organization._id,
-  });
+  session.startTransaction();
 
-  if (createdEvent !== null) {
-    await cacheEvents([createdEvent]);
-  }
+  try {
+    let createdEvent;
 
-  await EventAttendee.create({
-    userId: currentUser._id.toString(),
-    eventId: createdEvent._id,
-  });
+    if (
+      !args.data?.recurring ||
+      (args.data?.recurring && args.data?.recurrance == "ONCE")
+    ) {
+      createdEvent = await generateOnetimeEvent(
+        args,
+        currentUser,
+        organization,
+        session
+      );
+    } else {
+      //Cases for DAILY, WEEKLY, MONTHLY AND YEARLY recurring events
+      switch (args.data?.recurrance) {
+        case "WEEKLY":
+          createdEvent = await generateWeeklyRecurringInstances(
+            args,
+            currentUser,
+            organization,
+            session
+          );
+          break;
+      }
+    }
 
-  /*
-  Adds createdEvent._id to eventAdmin, createdEvents and registeredEvents lists
-  on currentUser's document.
-  */
-  await User.updateOne(
-    {
-      _id: currentUser._id,
-    },
-    {
-      $push: {
-        eventAdmin: createdEvent._id,
-        createdEvents: createdEvent._id,
-        registeredEvents: createdEvent._id,
-      },
+    await session.commitTransaction();
+
+    if (!createdEvent) {
+      throw new Error(requestContext.translate("Failed to create event!"));
     }
-  );
 
+    // Returns the createdEvent.
+    return createdEvent[0].toObject();
+  } catch (error) {
+    await session.abortTransaction();
+    throw error;
+  }
   /* Commenting out this notification code coz we don't use firebase anymore.
 
     for (let i = 0; i < organization.members.length; i++) {
     const user = await User.findOne({
       _id: organization.members[i],
     }).lean();
 
 
 
     // Checks whether both user and user.token exist.
     if (user && user.token) {
       await admin.messaging().send({
@@ -173,8 +182,110 @@
       });
     }
   }
      */
-
-  // Returns the createdEvent.
-  return createdEvent.toObject();
 };
+
+async function associateEventWithUser(
+  currentUser: any,
+  createdEvent: any,
+  session: mongoose.ClientSession
+) {
+  await EventAttendee.create(
+    [
+      {
+        userId: currentUser._id.toString(),
+        eventId: createdEvent._id,
+      },
+    ],
+    { session }
+  );
+
+  await User.updateOne(
+    {
+      _id: currentUser._id,
+    },
+    {
+      $push: {
+        eventAdmin: createdEvent._id,
+        createdEvents: createdEvent._id,
+        registeredEvents: createdEvent._id,
+      },
+    },
+    { session }
+  );
+}
+
+export async function generateOnetimeEvent(
+  args: any,
+  currentUser: any,
+  organization: any,
+  session: mongoose.ClientSession
+) {
+  const createdEvent = await Event.create(
+    [
+      {
+        ...args.data,
+        creator: currentUser._id,
+        admins: [currentUser._id],
+        organization: organization._id,
+      },
+    ],
+    { session }
+  );
+
+  if (createdEvent !== null) {
+    await cacheEvents([createdEvent[0]]);
+  }
+
+  await associateEventWithUser(currentUser, createdEvent[0], session);
+
+  return createdEvent;
+}
+
+export async function generateWeeklyRecurringInstances(
+  args: any,
+  currentUser: any,
+  organization: any,
+  session: mongoose.ClientSession
+) {
+  const recurringEvents = [];
+  const { data } = args;
+
+  const startDate = new Date(data?.startDate);
+  const endDate = new Date(data?.endDate);
+
+  while (startDate <= endDate) {
+    const recurringEventData = {
+      ...data,
+      startDate: new Date(startDate),
+    };
+
+    const createdEvent = {
+      ...recurringEventData,
+      creator: currentUser._id,
+      admins: [currentUser._id],
+      organization: organization._id,
+    };
+
+    recurringEvents.push(createdEvent);
+
+    startDate.setDate(startDate.getDate() + 7);
+  }
+
+  //Bulk insertion in database
+  const createdEvents = await Event.insertMany(recurringEvents, { session });
+
+  const eventsArray = Array.isArray(createdEvents)
+    ? createdEvents
+    : [createdEvents];
+
+  for (const createdEvent of eventsArray) {
+    await associateEventWithUser(currentUser, createdEvent, session);
+
+    if (createdEvent !== null) {
+      await cacheEvents([createdEvent]);
+    }
+  }
+
+  return eventsArray;
+}