eslint fixes

lib/calendarClient.ts

@@ -7,44 +7,51 @@ import EventAttendeeRescheduledMail from "./emails/EventAttendeeRescheduledMail"
 
 const translator = short();
 
+// eslint-disable-next-line @typescript-eslint/no-var-requires
 const { google } = require("googleapis");
 import prisma from "./prisma";
 
 const googleAuth = (credential) => {
-  const {client_secret, client_id, redirect_uris} = JSON.parse(process.env.GOOGLE_API_CREDENTIALS).web;
+  const { client_secret, client_id, redirect_uris } = JSON.parse(process.env.GOOGLE_API_CREDENTIALS).web;
   const myGoogleAuth = new google.auth.OAuth2(client_id, client_secret, redirect_uris[0]);
-    myGoogleAuth.setCredentials(credential.key);
+  myGoogleAuth.setCredentials(credential.key);
 
-    const isExpired = () => myGoogleAuth.isTokenExpiring();
+  const isExpired = () => myGoogleAuth.isTokenExpiring();
 
-    const refreshAccessToken = () => myGoogleAuth.refreshToken(credential.key.refresh_token).then(res => {
+  const refreshAccessToken = () =>
+    myGoogleAuth
+      .refreshToken(credential.key.refresh_token)
+      .then((res) => {
         const token = res.res.data;
         credential.key.access_token = token.access_token;
         credential.key.expiry_date = token.expiry_date;
-        return prisma.credential.update({
+        return prisma.credential
+          .update({
             where: {
-                id: credential.id
+              id: credential.id,
             },
             data: {
-                key: credential.key
-            }
-        }).then(() => {
+              key: credential.key,
+            },
+          })
+          .then(() => {
             myGoogleAuth.setCredentials(credential.key);
             return myGoogleAuth;
-        });
-    }).catch(err => {
+          });
+      })
+      .catch((err) => {
         console.error("Error refreshing google token", err);
         return myGoogleAuth;
-    });
+      });
 
-    return {
-        getToken: () => !isExpired() ? Promise.resolve(myGoogleAuth) : refreshAccessToken()
-    };
+  return {
+    getToken: () => (!isExpired() ? Promise.resolve(myGoogleAuth) : refreshAccessToken()),
+  };
 };
 
 function handleErrorsJson(response) {
   if (!response.ok) {
-    response.json().then(e => console.error("O365 Error", e));
+    response.json().then((e) => console.error("O365 Error", e));
     throw Error(response.statusText);
   }
   return response.json();
@@ -52,41 +59,43 @@ function handleErrorsJson(response) {
 
 function handleErrorsRaw(response) {
   if (!response.ok) {
-    response.text().then(e => console.error("O365 Error", e));
+    response.text().then((e) => console.error("O365 Error", e));
     throw Error(response.statusText);
   }
   return response.text();
 }
 
 const o365Auth = (credential) => {
-  const isExpired = (expiryDate) => expiryDate < Math.round((+(new Date()) / 1000));
+  const isExpired = (expiryDate) => expiryDate < Math.round(+new Date() / 1000);
 
   const refreshAccessToken = (refreshToken) => {
-        return 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 prisma.credential.update({
-                  where: {
-                      id: credential.id
-                  },
-                  data: {
-                      key: credential.key
-                  }
-              }).then(() => credential.key.access_token)
+    return 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 prisma.credential
+          .update({
+            where: {
+              id: credential.id,
+            },
+            data: {
+              key: credential.key,
+            },
           })
-    }
+          .then(() => credential.key.access_token);
+      });
+  };
 
   return {
     getToken: () =>
@@ -128,15 +137,11 @@ interface IntegrationCalendar {
 interface CalendarApiAdapter {
   createEvent(event: CalendarEvent): Promise<any>;
 
-  updateEvent(uid: String, event: CalendarEvent);
+  updateEvent(uid: string, event: CalendarEvent);
 
-  deleteEvent(uid: String);
+  deleteEvent(uid: string);
 
-  getAvailability(
-    dateFrom,
-    dateTo,
-    selectedCalendars: IntegrationCalendar[]
-  ): Promise<any>;
+  getAvailability(dateFrom, dateTo, selectedCalendars: IntegrationCalendar[]): Promise<any>;
 
   listCalendars(): Promise<IntegrationCalendar[]>;
 }
@@ -145,7 +150,7 @@ const MicrosoftOffice365Calendar = (credential): CalendarApiAdapter => {
   const auth = o365Auth(credential);
 
   const translateEvent = (event: CalendarEvent) => {
-    let optional = {};
+    const optional = {};
     if (event.location) {
       optional.location = { displayName: event.location };
     }
@@ -203,12 +208,7 @@ const MicrosoftOffice365Calendar = (credential): CalendarApiAdapter => {
 
   return {
     getAvailability: (dateFrom, dateTo, selectedCalendars) => {
-      const filter =
-        "?$filter=start/dateTime ge '" +
-        dateFrom +
-        "' and end/dateTime le '" +
-        dateTo +
-        "'";
+      const filter = "?$filter=start/dateTime ge '" + dateFrom + "' and end/dateTime le '" + dateTo + "'";
       return auth
         .getToken()
         .then((accessToken) => {
@@ -227,10 +227,7 @@ const MicrosoftOffice365Calendar = (credential): CalendarApiAdapter => {
           ).then((ids: string[]) => {
             const urls = ids.map(
               (calendarId) =>
-                "https://graph.microsoft.com/v1.0/me/calendars/" +
-                calendarId +
-                "/events" +
-                filter
+                "https://graph.microsoft.com/v1.0/me/calendars/" + calendarId + "/events" + filter
             );
             return Promise.all(
               urls.map((url) =>
@@ -249,9 +246,7 @@ const MicrosoftOffice365Calendar = (credential): CalendarApiAdapter => {
                     }))
                   )
               )
-            ).then((results) =>
-              results.reduce((acc, events) => acc.concat(events), [])
-            );
+            ).then((results) => results.reduce((acc, events) => acc.concat(events), []));
           });
         })
         .catch((err) => {
@@ -274,7 +269,7 @@ const MicrosoftOffice365Calendar = (credential): CalendarApiAdapter => {
             disableConfirmationEmail: true,
           }))
       ),
-    deleteEvent: (uid: String) =>
+    deleteEvent: (uid: string) =>
       auth.getToken().then((accessToken) =>
         fetch("https://graph.microsoft.com/v1.0/me/calendar/events/" + uid, {
           method: "DELETE",
@@ -283,7 +278,7 @@ const MicrosoftOffice365Calendar = (credential): CalendarApiAdapter => {
           },
         }).then(handleErrorsRaw)
       ),
-    updateEvent: (uid: String, event: CalendarEvent) =>
+    updateEvent: (uid: string, event: CalendarEvent) =>
       auth.getToken().then((accessToken) =>
         fetch("https://graph.microsoft.com/v1.0/me/calendar/events/" + uid, {
           method: "PATCH",
@@ -299,162 +294,189 @@ const MicrosoftOffice365Calendar = (credential): CalendarApiAdapter => {
 };
 
 const GoogleCalendar = (credential): CalendarApiAdapter => {
-    const auth = googleAuth(credential);
-    const integrationType = "google_calendar";
+  const auth = googleAuth(credential);
+  const integrationType = "google_calendar";
 
-    return {
-        getAvailability: (dateFrom, dateTo, selectedCalendars) => new Promise((resolve, reject) => auth.getToken().then(myGoogleAuth => {
-            const calendar = google.calendar({version: 'v3', auth: myGoogleAuth});
-            const selectedCalendarIds = selectedCalendars.filter(e => e.integration === integrationType).map(e => e.externalId);
-            if (selectedCalendarIds.length == 0 && selectedCalendars.length > 0){
-                // Only calendars of other integrations selected
-                resolve([]);
-                return;
-            }
+  return {
+    getAvailability: (dateFrom, dateTo, selectedCalendars) =>
+      new Promise((resolve, reject) =>
+        auth.getToken().then((myGoogleAuth) => {
+          const calendar = google.calendar({ version: "v3", auth: myGoogleAuth });
+          const selectedCalendarIds = selectedCalendars
+            .filter((e) => e.integration === integrationType)
+            .map((e) => e.externalId);
+          if (selectedCalendarIds.length == 0 && selectedCalendars.length > 0) {
+            // Only calendars of other integrations selected
+            resolve([]);
+            return;
+          }
 
-            (selectedCalendarIds.length == 0
-              ? calendar.calendarList.list().then(cals => cals.data.items.map(cal => cal.id))
-              : Promise.resolve(selectedCalendarIds)).then(calsIds => {
-                    calendar.freebusy.query({
-                        requestBody: {
-                            timeMin: dateFrom,
-                            timeMax: dateTo,
-                            items: calsIds.map(id => ({id: id}))
-                        }
-                    }, (err, apires) => {
-                        if (err) {
-                            reject(err);
-                        }
-                        resolve(
-                            Object.values(apires.data.calendars).flatMap(
-                                (item) => item["busy"]
-                            )
-                        )
-                    });
-                })
-                .catch((err) => {
-                    console.error('There was an error contacting google calendar service: ', err);
+          (selectedCalendarIds.length == 0
+            ? calendar.calendarList.list().then((cals) => cals.data.items.map((cal) => cal.id))
+            : Promise.resolve(selectedCalendarIds)
+          )
+            .then((calsIds) => {
+              calendar.freebusy.query(
+                {
+                  requestBody: {
+                    timeMin: dateFrom,
+                    timeMax: dateTo,
+                    items: calsIds.map((id) => ({ id: id })),
+                  },
+                },
+                (err, apires) => {
+                  if (err) {
                     reject(err);
-                });
-
-    })),
-    createEvent: (event: CalendarEvent) => new Promise((resolve, reject) => auth.getToken().then(myGoogleAuth => {
-      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;
-        }
-
-        if (event.conferenceData) {
-          payload["conferenceData"] = event.conferenceData;
-        }
-
-      const calendar = google.calendar({version: 'v3', auth: myGoogleAuth});
-      calendar.events.insert({
-        auth: myGoogleAuth,
-        calendarId: 'primary',
-        resource: payload,
-      }, function (err, event) {
-        if (err) {
-          console.error('There was an error contacting google calendar service: ', err);
-          return reject(err);
-        }
-        return resolve(event.data);
-      });
-    })),
-    updateEvent: (uid: String, event: CalendarEvent) => new Promise((resolve, reject) => auth.getToken().then(myGoogleAuth => {
-      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.error('There was an error contacting google calendar service: ', err);
-                    return reject(err);
+                  }
+                  resolve(Object.values(apires.data.calendars).flatMap((item) => item["busy"]));
                 }
-                return resolve(event.data);
+              );
+            })
+            .catch((err) => {
+              console.error("There was an error contacting google calendar service: ", err);
+              reject(err);
             });
-        })),
-        deleteEvent: (uid: String) => new Promise( (resolve, reject) => auth.getToken().then(myGoogleAuth => {
-            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.error('There was an error contacting google calendar service: ', err);
-                    return reject(err);
-                }
-                return resolve(event.data);
+        })
+      ),
+    createEvent: (event: CalendarEvent) =>
+      new Promise((resolve, reject) =>
+        auth.getToken().then((myGoogleAuth) => {
+          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;
+          }
+
+          if (event.conferenceData) {
+            payload["conferenceData"] = event.conferenceData;
+          }
+
+          const calendar = google.calendar({ version: "v3", auth: myGoogleAuth });
+          calendar.events.insert(
+            {
+              auth: myGoogleAuth,
+              calendarId: "primary",
+              resource: payload,
+            },
+            function (err, event) {
+              if (err) {
+                console.error("There was an error contacting google calendar service: ", err);
+                return reject(err);
+              }
+              return resolve(event.data);
+            }
+          );
+        })
+      ),
+    updateEvent: (uid: string, event: CalendarEvent) =>
+      new Promise((resolve, reject) =>
+        auth.getToken().then((myGoogleAuth) => {
+          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.error("There was an error contacting google calendar service: ", err);
+                return reject(err);
+              }
+              return resolve(event.data);
+            }
+          );
+        })
+      ),
+    deleteEvent: (uid: string) =>
+      new Promise((resolve, reject) =>
+        auth.getToken().then((myGoogleAuth) => {
+          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.error("There was an error contacting google calendar service: ", err);
+                return reject(err);
+              }
+              return resolve(event.data);
+            }
+          );
+        })
+      ),
+    listCalendars: () =>
+      new Promise((resolve, reject) =>
+        auth.getToken().then((myGoogleAuth) => {
+          const calendar = google.calendar({ version: "v3", auth: myGoogleAuth });
+          calendar.calendarList
+            .list()
+            .then((cals) => {
+              resolve(
+                cals.data.items.map((cal) => {
+                  const calendar: IntegrationCalendar = {
+                    externalId: cal.id,
+                    integration: integrationType,
+                    name: cal.summary,
+                    primary: cal.primary,
+                  };
+                  return calendar;
+                })
+              );
+            })
+            .catch((err) => {
+              console.error("There was an error contacting google calendar service: ", err);
+              reject(err);
             });
-        })),
-        listCalendars: () => new Promise((resolve, reject) => auth.getToken().then(myGoogleAuth => {
-            const calendar = google.calendar({version: 'v3', auth: myGoogleAuth});
-            calendar.calendarList
-              .list()
-              .then(cals => {
-                  resolve(cals.data.items.map(cal => {
-                      const calendar: IntegrationCalendar = {
-                          externalId: cal.id, integration: integrationType, name: cal.summary, primary: cal.primary
-                      }
-                      return calendar;
-                  }))
-              })
-              .catch((err) => {
-                  console.error('There was an error contacting google calendar service: ', err);
-                  reject(err);
-              });
-        }))
-    };
+        })
+      ),
+  };
 };
 
 // factory
@@ -472,50 +494,36 @@ const calendars = (withCredentials): CalendarApiAdapter[] =>
     })
     .filter(Boolean);
 
-const getBusyCalendarTimes = (
-  withCredentials,
-  dateFrom,
-  dateTo,
-  selectedCalendars
-) =>
+const getBusyCalendarTimes = (withCredentials, dateFrom, dateTo, selectedCalendars) =>
   Promise.all(
-    calendars(withCredentials).map((c) =>
-      c.getAvailability(dateFrom, dateTo, selectedCalendars)
-    )
+    calendars(withCredentials).map((c) => c.getAvailability(dateFrom, dateTo, selectedCalendars))
   ).then((results) => {
     return results.reduce((acc, availability) => acc.concat(availability), []);
   });
 
 const listCalendars = (withCredentials) =>
-  Promise.all(calendars(withCredentials).map((c) => c.listCalendars())).then(
-    (results) => results.reduce((acc, calendars) => acc.concat(calendars), [])
+  Promise.all(calendars(withCredentials).map((c) => c.listCalendars())).then((results) =>
+    results.reduce((acc, calendars) => acc.concat(calendars), [])
   );
 
-const createEvent = async (
-  credential,
-  calEvent: CalendarEvent
-): Promise<any> => {
-  const uid: string = translator.fromUUID(
-    uuidv5(JSON.stringify(calEvent), uuidv5.URL)
-  );
+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 creationResult = credential ? await calendars([credential])[0].createEvent(calEvent) : null;
 
   const organizerMail = new EventOrganizerMail(calEvent, uid);
   const attendeeMail = new EventAttendeeMail(calEvent, uid);
   try {
     await organizerMail.sendEmail();
   } catch (e) {
-    console.error("organizerMail.sendEmail failed", e)
+    console.error("organizerMail.sendEmail failed", e);
   }
 
   if (!creationResult || !creationResult.disableConfirmationEmail) {
     try {
       await attendeeMail.sendEmail();
     } catch (e) {
-      console.error("attendeeMail.sendEmail failed", e)
+      console.error("attendeeMail.sendEmail failed", e);
     }
   }
 
@@ -525,14 +533,8 @@ const createEvent = async (
   };
 };
 
-const updateEvent = async (
-  credential,
-  uidToUpdate: String,
-  calEvent: CalendarEvent
-): Promise<any> => {
-  const newUid: string = translator.fromUUID(
-    uuidv5(JSON.stringify(calEvent), uuidv5.URL)
-  );
+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)
@@ -543,14 +545,14 @@ const updateEvent = async (
   try {
     await organizerMail.sendEmail();
   } catch (e) {
-    console.error("organizerMail.sendEmail failed", e)
+    console.error("organizerMail.sendEmail failed", e);
   }
 
   if (!updateResult || !updateResult.disableConfirmationEmail) {
     try {
       await attendeeMail.sendEmail();
     } catch (e) {
-      console.error("attendeeMail.sendEmail failed", e)
+      console.error("attendeeMail.sendEmail failed", e);
     }
   }
 
@@ -560,7 +562,7 @@ const updateEvent = async (
   };
 };
 
-const deleteEvent = (credential, uid: String): Promise<any> => {
+const deleteEvent = (credential, uid: string): Promise<any> => {
   if (credential) {
     return calendars([credential])[0].deleteEvent(uid);
   }