cal.pub0.org/lib/calendarClient.ts

import EventOwnerMail from "./emails/EventOwnerMail";
import EventAttendeeMail from "./emails/EventAttendeeMail";
import {v5 as uuidv5} from 'uuid';
import short from 'short-uuid';
import EventOwnerRescheduledMail from "./emails/EventOwnerRescheduledMail";
import EventAttendeeRescheduledMail from "./emails/EventAttendeeRescheduledMail";

const translator = short();

const {google} = require('googleapis');

const googleAuth = () => {
  const {client_secret, client_id, redirect_uris} = JSON.parse(process.env.GOOGLE_API_CREDENTIALS).web;
  return new google.auth.OAuth2(client_id, client_secret, redirect_uris[0]);
};

function handleErrorsJson(response) {
  if (!response.ok) {
    response.json().then(console.log);
    throw Error(response.statusText);
  }
  return response.json();
}

function handleErrorsRaw(response) {
  if (!response.ok) {
    response.text().then(console.log);
    throw Error(response.statusText);
  }
  return response.text();
}

const o365Auth = (credential) => {

  const isExpired = (expiryDate) => expiryDate < +(new Date());

  const refreshAccessToken = (refreshToken) => fetch('https://login.microsoftonline.com/common/oauth2/v2.0/token', {
    method: 'POST',
    headers: {'Content-Type': 'application/x-www-form-urlencoded'},
    body: new URLSearchParams({
      'scope': 'User.Read Calendars.Read Calendars.ReadWrite',
      'client_id': process.env.MS_GRAPH_CLIENT_ID,
      'refresh_token': refreshToken,
      'grant_type': 'refresh_token',
      'client_secret': process.env.MS_GRAPH_CLIENT_SECRET,
    })
  })
    .then(handleErrorsJson)
    .then((responseBody) => {
      credential.key.access_token = responseBody.access_token;
      credential.key.expiry_date = Math.round((+(new Date()) / 1000) + responseBody.expires_in);
      return credential.key.access_token;
    })

  return {
    getToken: () => !isExpired(credential.key.expiry_date) ? Promise.resolve(credential.key.access_token) : refreshAccessToken(credential.key.refresh_token)
  };
};

interface Person {
  name?: string,
  email: string,
  timeZone: string
}

interface CalendarEvent {
  type: string;
  title: string;
  startTime: string;
  endTime: string;
  description?: string;
  location?: string;
  organizer: Person;
  attendees: Person[];
};

interface CalendarApiAdapter {
  createEvent(event: CalendarEvent): Promise<any>;

  updateEvent(uid: String, event: CalendarEvent);

  deleteEvent(uid: String);

  getAvailability(dateFrom, dateTo): Promise<any>;
}

const MicrosoftOffice365Calendar = (credential): CalendarApiAdapter => {

  const auth = o365Auth(credential);

  const translateEvent = (event: CalendarEvent) => {

    let optional = {};
    if (event.location) {
      optional.location = {displayName: event.location};
    }

    return {
      subject: event.title,
      body: {
        contentType: 'HTML',
        content: event.description,
      },
      start: {
        dateTime: event.startTime,
        timeZone: event.organizer.timeZone,
      },
      end: {
        dateTime: event.endTime,
        timeZone: event.organizer.timeZone,
      },
      attendees: event.attendees.map(attendee => ({
        emailAddress: {
          address: attendee.email,
          name: attendee.name
        },
        type: "required"
      })),
      ...optional
    }
  };

  return {
    getAvailability: (dateFrom, dateTo) => {
      const payload = {
        schedules: [credential.key.email],
        startTime: {
          dateTime: dateFrom,
          timeZone: 'UTC',
        },
        endTime: {
          dateTime: dateTo,
          timeZone: 'UTC',
        },
        availabilityViewInterval: 60
      };

      return auth.getToken().then(
        (accessToken) => fetch('https://graph.microsoft.com/v1.0/me/calendar/getSchedule', {
          method: 'post',
          headers: {
            'Authorization': 'Bearer ' + accessToken,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify(payload)
        })
          .then(handleErrorsJson)
          .then(responseBody => {
            return responseBody.value[0].scheduleItems.map((evt) => ({
              start: evt.start.dateTime + 'Z',
              end: evt.end.dateTime + 'Z'
            }))
          })
      ).catch((err) => {
        console.log(err);
      });
    },
    createEvent: (event: CalendarEvent) => auth.getToken().then(accessToken => fetch('https://graph.microsoft.com/v1.0/me/calendar/events', {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer ' + accessToken,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(translateEvent(event))
    }).then(handleErrorsJson).then((responseBody) => ({
      ...responseBody,
      disableConfirmationEmail: true,
    }))),
    deleteEvent: (uid: String) => auth.getToken().then(accessToken => fetch('https://graph.microsoft.com/v1.0/me/calendar/events/' + uid, {
      method: 'DELETE',
      headers: {
        'Authorization': 'Bearer ' + accessToken
      }
    }).then(handleErrorsRaw)),
    updateEvent: (uid: String, event: CalendarEvent) => auth.getToken().then(accessToken => fetch('https://graph.microsoft.com/v1.0/me/calendar/events/' + uid, {
      method: 'PATCH',
      headers: {
        'Authorization': 'Bearer ' + accessToken,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(translateEvent(event))
    }).then(handleErrorsRaw)),
  }
};

const GoogleCalendar = (credential): CalendarApiAdapter => {
  const myGoogleAuth = googleAuth();
  myGoogleAuth.setCredentials(credential.key);
  return {
    getAvailability: (dateFrom, dateTo) => new Promise((resolve, reject) => {
      const calendar = google.calendar({version: 'v3', auth: myGoogleAuth});
      calendar.calendarList
        .list()
        .then(cals => {
          calendar.freebusy.query({
            requestBody: {
              timeMin: dateFrom,
              timeMax: dateTo,
              items: cals.data.items
            }
          }, (err, apires) => {
            if (err) {
              reject(err);
            }
            resolve(
              Object.values(apires.data.calendars).flatMap(
                (item) => item["busy"]
              )
            )
          });
        })
        .catch((err) => {
          reject(err);
        });

    }),
    createEvent: (event: CalendarEvent) => new Promise((resolve, reject) => {
      const payload = {
        summary: event.title,
        description: event.description,
        start: {
          dateTime: event.startTime,
          timeZone: event.organizer.timeZone,
        },
        end: {
          dateTime: event.endTime,
          timeZone: event.organizer.timeZone,
        },
        attendees: event.attendees,
        reminders: {
          useDefault: false,
          overrides: [
            {'method': 'email', 'minutes': 60}
          ],
        },
      };

      if (event.location) {
        payload['location'] = event.location;
      }

      const calendar = google.calendar({version: 'v3', auth: myGoogleAuth});
      calendar.events.insert({
        auth: myGoogleAuth,
        calendarId: 'primary',
        resource: payload,
      }, function (err, event) {
        if (err) {
          console.log('There was an error contacting the Calendar service: ' + err);
          return reject(err);
        }
        return resolve(event.data);
      });
    }),
    updateEvent: (uid: String, event: CalendarEvent) => new Promise((resolve, reject) => {
      const payload = {
        summary: event.title,
        description: event.description,
        start: {
          dateTime: event.startTime,
          timeZone: event.organizer.timeZone,
        },
        end: {
          dateTime: event.endTime,
          timeZone: event.organizer.timeZone,
        },
        attendees: event.attendees,
        reminders: {
          useDefault: false,
          overrides: [
            {'method': 'email', 'minutes': 60}
          ],
        },
      };

      if (event.location) {
        payload['location'] = event.location;
      }

      const calendar = google.calendar({version: 'v3', auth: myGoogleAuth});
      calendar.events.update({
        auth: myGoogleAuth,
        calendarId: 'primary',
        eventId: uid,
        sendNotifications: true,
        sendUpdates: 'all',
        resource: payload
      }, function (err, event) {
        if (err) {
          console.log('There was an error contacting the Calendar service: ' + err);
          return reject(err);
        }
        return resolve(event.data);
      });
    }),
    deleteEvent: (uid: String) => new Promise((resolve, reject) => {
      const calendar = google.calendar({version: 'v3', auth: myGoogleAuth});
      calendar.events.delete({
        auth: myGoogleAuth,
        calendarId: 'primary',
        eventId: uid,
        sendNotifications: true,
        sendUpdates: 'all',
      }, function (err, event) {
        if (err) {
          console.log('There was an error contacting the Calendar service: ' + err);
          return reject(err);
        }
        return resolve(event.data);
      });
    })
  };
};

// factory
const calendars = (withCredentials): CalendarApiAdapter[] => withCredentials.map((cred) => {
  switch (cred.type) {
    case 'google_calendar':
      return GoogleCalendar(cred);
    case 'office365_calendar':
      return MicrosoftOffice365Calendar(cred);
    default:
      return; // unknown credential, could be legacy? In any case, ignore
  }
}).filter(Boolean);


const getBusyCalendarTimes = (withCredentials, dateFrom, dateTo) => Promise.all(
  calendars(withCredentials).map(c => c.getAvailability(dateFrom, dateTo))
).then(
  (results) => results.reduce((acc, availability) => acc.concat(availability), [])
);

const createEvent = async (credential, calEvent: CalendarEvent): Promise<any> => {
  const uid: string = translator.fromUUID(uuidv5(JSON.stringify(calEvent), uuidv5.URL));

  const creationResult = credential ? await calendars([credential])[0].createEvent(calEvent) : null;

  const ownerMail = new EventOwnerMail(calEvent, uid);
  const attendeeMail = new EventAttendeeMail(calEvent, uid);
  await ownerMail.sendEmail();

  if (!creationResult || !creationResult.disableConfirmationEmail) {
    await attendeeMail.sendEmail();
  }

  return {
    uid,
    createdEvent: creationResult
  };
};

const updateEvent = async (credential, uidToUpdate: String, calEvent: CalendarEvent): Promise<any> => {
  const newUid: string = translator.fromUUID(uuidv5(JSON.stringify(calEvent), uuidv5.URL));

  const updateResult = credential ? await calendars([credential])[0].updateEvent(uidToUpdate, calEvent) : null;

  const ownerMail = new EventOwnerRescheduledMail(calEvent, newUid);
  const attendeeMail = new EventAttendeeRescheduledMail(calEvent, newUid);
  await ownerMail.sendEmail();

  if (!updateResult || !updateResult.disableConfirmationEmail) {
    await attendeeMail.sendEmail();
  }

  return {
    uid: newUid,
    updatedEvent: updateResult
  };
};

const deleteEvent = (credential, uid: String): Promise<any> => {
  if (credential) {
    return calendars([credential])[0].deleteEvent(uid);
  }

  return Promise.resolve({});
};

export {getBusyCalendarTimes, createEvent, updateEvent, deleteEvent, CalendarEvent};