cal/lib/events/EventManager.ts

import { Credential } from "@prisma/client";
import async from "async";
import merge from "lodash/merge";
import { v5 as uuidv5 } from "uuid";

import { CalendarEvent, createEvent, updateEvent } from "@lib/calendarClient";
import { dailyCreateMeeting, dailyUpdateMeeting } from "@lib/dailyVideoClient";
import EventAttendeeMail from "@lib/emails/EventAttendeeMail";
import EventAttendeeRescheduledMail from "@lib/emails/EventAttendeeRescheduledMail";
import { LocationType } from "@lib/location";
import prisma from "@lib/prisma";
import { createMeeting, updateMeeting, VideoCallData } from "@lib/videoClient";

export interface EventResult {
  type: string;
  success: boolean;
  uid: string;
  createdEvent?: unknown;
  updatedEvent?: unknown;
  originalEvent: CalendarEvent;
  videoCallData?: VideoCallData;
}

export interface CreateUpdateResult {
  results: Array<EventResult>;
  referencesToCreate: Array<PartialReference>;
}

export interface PartialBooking {
  id: number;
  references: Array<PartialReference>;
}

export interface PartialReference {
  id?: number;
  type: string;
  uid: string;
  meetingId?: string;
  meetingPassword?: string;
  meetingUrl?: string;
}

interface GetLocationRequestFromIntegrationRequest {
  location: string;
}

//const to idenfity a daily event location
const dailyLocation = "integrations:daily";

export default class EventManager {
  calendarCredentials: Array<Credential>;
  videoCredentials: Array<Credential>;

  /**
   * Takes an array of credentials and initializes a new instance of the EventManager.
   *
   * @param credentials
   */
  constructor(credentials: Array<Credential>) {
    this.calendarCredentials = credentials.filter((cred) => cred.type.endsWith("_calendar"));
    this.videoCredentials = credentials.filter((cred) => cred.type.endsWith("_video"));

    //for  Daily.co video, temporarily pushes a credential for the daily-video-client

    const hasDailyIntegration = process.env.DAILY_API_KEY;
    const dailyCredential: Credential = {
      id: +new Date().getTime(),
      type: "daily_video",
      key: { apikey: process.env.DAILY_API_KEY },
      userId: +new Date().getTime(),
    };
    if (hasDailyIntegration) {
      this.videoCredentials.push(dailyCredential);
    }
  }

  /**
   * Takes a CalendarEvent and creates all necessary integration entries for it.
   * When a video integration is chosen as the event's location, a video integration
   * event will be scheduled for it as well.
   * An optional uid can be set to override the auto-generated uid.
   *
   * @param event
   * @param maybeUid
   */
  public async create(event: CalendarEvent, maybeUid?: string): Promise<CreateUpdateResult> {
    event = EventManager.processLocation(event);
    const isDedicated = EventManager.isDedicatedIntegration(event.location);

    let results: Array<EventResult> = [];
    let optionalVideoCallData: VideoCallData | undefined = undefined;

    // If and only if event type is a dedicated meeting, create a dedicated video meeting.
    if (isDedicated) {
      const result = await this.createVideoEvent(event, maybeUid);
      if (result.videoCallData) {
        optionalVideoCallData = result.videoCallData;
      }
      results.push(result);
    } else {
      await EventManager.sendAttendeeMail("new", results, event, maybeUid);
    }

    // Now create all calendar events. If this is a dedicated integration event,
    // don't send a mail right here, because it has already been sent.
    results = results.concat(
      await this.createAllCalendarEvents(event, isDedicated, maybeUid, optionalVideoCallData)
    );

    const referencesToCreate: Array<PartialReference> = results.map((result: EventResult) => {
      const isDailyResult = result.type === "daily";
      if (isDailyResult) {
        return {
          type: result.type,
          uid: result.createdEvent.name.toString(),
          meetingId: result.videoCallData?.id.toString(),
          meetingPassword: result.videoCallData?.password,
          meetingUrl: result.videoCallData?.url,
        };
      }
      if (!isDailyResult) {
        return {
          type: result.type,
          uid: result.createdEvent.id.toString(),
          meetingId: result.videoCallData?.id.toString(),
          meetingPassword: result.videoCallData?.password,
          meetingUrl: result.videoCallData?.url,
        };
      }
    });

    return {
      results,
      referencesToCreate,
    };
  }

  /**
   * Takes a calendarEvent and a rescheduleUid and updates the event that has the
   * given uid using the data delivered in the given CalendarEvent.
   *
   * @param event
   * @param rescheduleUid
   */
  public async update(event: CalendarEvent, rescheduleUid: string): Promise<CreateUpdateResult> {
    event = EventManager.processLocation(event);

    // Get details of existing booking.
    const booking = await prisma.booking.findFirst({
      where: {
        uid: rescheduleUid,
      },
      select: {
        id: true,
        references: {
          select: {
            id: true,
            type: true,
            uid: true,
            meetingId: true,
            meetingPassword: true,
            meetingUrl: true,
          },
        },
      },
    });

    const isDedicated =
      EventManager.isDedicatedIntegration(event.location) || event.location === dailyLocation;

    let results: Array<EventResult> = [];
    let optionalVideoCallData: VideoCallData | undefined = undefined;

    // If and only if event type is a dedicated meeting, update the dedicated video meeting.
    if (isDedicated) {
      const result = await this.updateVideoEvent(event, booking);
      if (result.videoCallData) {
        optionalVideoCallData = result.videoCallData;
      }
      results.push(result);
    } else {
      await EventManager.sendAttendeeMail("reschedule", results, event, rescheduleUid);
    }

    // Now update all calendar events. If this is a dedicated integration event,
    // don't send a mail right here, because it has already been sent.
    results = results.concat(
      await this.updateAllCalendarEvents(event, booking, isDedicated, optionalVideoCallData)
    );

    // Now we can delete the old booking and its references.
    const bookingReferenceDeletes = prisma.bookingReference.deleteMany({
      where: {
        bookingId: booking.id,
      },
    });
    const attendeeDeletes = prisma.attendee.deleteMany({
      where: {
        bookingId: booking.id,
      },
    });
    const bookingDeletes = prisma.booking.delete({
      where: {
        uid: rescheduleUid,
      },
    });

    // Wait for all deletions to be applied.
    await Promise.all([bookingReferenceDeletes, attendeeDeletes, bookingDeletes]);

    return {
      results,
      referencesToCreate: [...booking.references],
    };
  }

  /**
   * Creates event entries for all calendar integrations given in the credentials.
   * When noMail is true, no mails will be sent. This is used when the event is
   * a video meeting because then the mail containing the video credentials will be
   * more important than the mails created for these bare calendar events.
   *
   * When the optional uid is set, it will be used instead of the auto generated uid.
   *
   * @param event
   * @param noMail
   * @param maybeUid
   * @param optionalVideoCallData
   * @private
   */

  private createAllCalendarEvents(
    event: CalendarEvent,
    noMail: boolean,
    maybeUid?: string,
    optionalVideoCallData?: VideoCallData
  ): Promise<Array<EventResult>> {
    return async.mapLimit(this.calendarCredentials, 5, async (credential: Credential) => {
      return createEvent(credential, event, noMail, maybeUid, optionalVideoCallData);
    });
  }

  /**
   * Checks which video integration is needed for the event's location and returns
   * credentials for that - if existing.
   * @param event
   * @private
   */

  private getVideoCredential(event: CalendarEvent): Credential | undefined {
    const integrationName = event.location.replace("integrations:", "");

    return this.videoCredentials.find((credential: Credential) => credential.type.includes(integrationName));
  }

  /**
   * Creates a video event entry for the selected integration location.
   *
   * When optional uid is set, it will be used instead of the auto generated uid.
   *
   * @param event
   * @param maybeUid
   * @private
   */
  private createVideoEvent(event: CalendarEvent, maybeUid?: string): Promise<EventResult> {
    const credential = this.getVideoCredential(event);

    const isDaily = event.location === dailyLocation;

    if (credential && !isDaily) {
      return createMeeting(credential, event, maybeUid);
    } else if (isDaily) {
      return dailyCreateMeeting(credential, event, maybeUid);
    } else {
      return Promise.reject("No suitable credentials given for the requested integration name.");
    }
  }

  /**
   * Updates the event entries for all calendar integrations given in the credentials.
   * When noMail is true, no mails will be sent. This is used when the event is
   * a video meeting because then the mail containing the video credentials will be
   * more important than the mails created for these bare calendar events.
   *
   * @param event
   * @param booking
   * @param noMail
   * @private
   */
  private updateAllCalendarEvents(
    event: CalendarEvent,
    booking: PartialBooking,
    noMail: boolean,
    optionalVideoCallData?: VideoCallData
  ): Promise<Array<EventResult>> {
    return async.mapLimit(this.calendarCredentials, 5, async (credential) => {
      const bookingRefUid = booking.references.filter((ref) => ref.type === credential.type)[0]?.uid;
      return updateEvent(credential, bookingRefUid, event, noMail, optionalVideoCallData);
    });
  }

  /**
   * Updates a single video event.
   *
   * @param event
   * @param booking
   * @private
   */
  private updateVideoEvent(event: CalendarEvent, booking: PartialBooking) {
    const credential = this.getVideoCredential(event);
    const isDaily = event.location === dailyLocation;

    if (credential && !isDaily) {
      const bookingRef = booking.references.filter((ref) => ref.type === credential.type)[0];

      return updateMeeting(credential, bookingRef.uid, event).then((returnVal: EventResult) => {
        // Some video integrations, such as Zoom, don't return any data about the booking when updating it.
        if (returnVal.videoCallData == undefined) {
          returnVal.videoCallData = EventManager.bookingReferenceToVideoCallData(bookingRef);
        }
        return returnVal;
      });
    } else {
      if (isDaily) {
        const bookingRefUid = booking.references.filter((ref) => ref.type === "daily")[0].uid;
        return dailyUpdateMeeting(credential, bookingRefUid, event);
      }
      return Promise.reject("No suitable credentials given for the requested integration name.");
    }
  }

  /**
   * Returns true if the given location describes a dedicated integration that
   * delivers meeting credentials. Zoom, for example, is dedicated, because it
   * needs to be called independently from any calendar APIs to receive meeting
   * credentials. Google Meetings, in contrast, are not dedicated, because they
   * are created while scheduling a regular calendar event by simply adding some
   * attributes to the payload JSON.
   *
   * @param location
   * @private
   */
  private static isDedicatedIntegration(location: string): boolean {
    // Hard-coded for now, because Zoom and Google Meet are both integrations, but one is dedicated, the other one isn't.

    return location === "integrations:zoom" || location === dailyLocation;
  }

  /**
   * Helper function for processLocation: Returns the conferenceData object to be merged
   * with the CalendarEvent.
   *
   * @param locationObj
   * @private
   */
  private static getLocationRequestFromIntegration(locationObj: GetLocationRequestFromIntegrationRequest) {
    const location = locationObj.location;

    if (
      location === LocationType.GoogleMeet.valueOf() ||
      location === LocationType.Zoom.valueOf() ||
      location === LocationType.Daily.valueOf()
    ) {
      const requestId = uuidv5(location, uuidv5.URL);

      return {
        conferenceData: {
          createRequest: {
            requestId: requestId,
          },
        },
        location,
      };
    }

    return null;
  }

  /**
   * Takes a CalendarEvent and adds a ConferenceData object to the event
   * if the event has an integration-related location.
   *
   * @param event
   * @private
   */
  private static processLocation(event: CalendarEvent): CalendarEvent {
    // If location is set to an integration location
    // Build proper transforms for evt object
    // Extend evt object with those transformations
    if (event.location?.includes("integration")) {
      const maybeLocationRequestObject = EventManager.getLocationRequestFromIntegration({
        location: event.location,
      });

      event = merge(event, maybeLocationRequestObject);
    }

    return event;
  }

  /**
   * Accepts a PartialReference object and, if all data is complete,
   * returns a VideoCallData object containing the meeting information.
   *
   * @param reference
   * @private
   */
  private static bookingReferenceToVideoCallData(reference: PartialReference): VideoCallData | undefined {
    let isComplete = true;

    switch (reference.type) {
      case "zoom_video":
        // Zoom meetings in our system should always have an ID, a password and a join URL. In the
        // future, it might happen that we consider making passwords for Zoom meetings optional.
        // Then, this part below (where the password existence is checked) needs to be adapted.
        isComplete =
          reference.meetingId != undefined &&
          reference.meetingPassword != undefined &&
          reference.meetingUrl != undefined;
        break;
      default:
        isComplete = true;
    }

    if (isComplete) {
      return {
        type: reference.type,
        // The null coalescing operator should actually never be used here, because we checked if it's defined beforehand.
        id: reference.meetingId ?? "",
        password: reference.meetingPassword ?? "",
        url: reference.meetingUrl ?? "",
      };
    } else {
      return undefined;
    }
  }

  /**
   * Conditionally sends an email to the attendee.
   *
   * @param type
   * @param results
   * @param event
   * @param maybeUid
   * @private
   */
  private static async sendAttendeeMail(
    type: "new" | "reschedule",
    results: Array<EventResult>,
    event: CalendarEvent,
    maybeUid?: string
  ) {
    if (
      !results.length ||
      !results.some((eRes) => (eRes.createdEvent || eRes.updatedEvent).disableConfirmationEmail)
    ) {
      const metadata: { hangoutLink?: string; conferenceData?: unknown; entryPoints?: unknown } = {};
      if (results.length) {
        // TODO: Handle created event metadata more elegantly
        metadata.hangoutLink = results[0].createdEvent?.hangoutLink;
        metadata.conferenceData = results[0].createdEvent?.conferenceData;
        metadata.entryPoints = results[0].createdEvent?.entryPoints;
      }
      let attendeeMail;
      switch (type) {
        case "reschedule":
          attendeeMail = new EventAttendeeRescheduledMail(event, maybeUid, metadata);
          break;
        case "new":
          attendeeMail = new EventAttendeeMail(event, maybeUid, metadata);
          break;
      }
      try {
        await attendeeMail.sendEmail();
      } catch (e) {
        console.error("attendeeMail.sendEmail failed", e);
      }
    }
  }
}