733 lines
26 KiB
TypeScript
733 lines
26 KiB
TypeScript
/* eslint-disable @typescript-eslint/no-explicit-any */
|
|
import type { Prisma } from "@prisma/client";
|
|
import type { calendar_v3 } from "googleapis";
|
|
import { google } from "googleapis";
|
|
import { RRule } from "rrule";
|
|
import { v4 as uuid } from "uuid";
|
|
|
|
import { MeetLocationType } from "@calcom/app-store/locations";
|
|
import dayjs from "@calcom/dayjs";
|
|
import { CalendarCache } from "@calcom/features/calendar-cache/calendar-cache";
|
|
import type { FreeBusyArgs } from "@calcom/features/calendar-cache/calendar-cache.repository.interface";
|
|
import { getLocation, getRichDescription } from "@calcom/lib/CalEventParser";
|
|
import type CalendarService from "@calcom/lib/CalendarService";
|
|
import {
|
|
APP_CREDENTIAL_SHARING_ENABLED,
|
|
CREDENTIAL_SYNC_ENDPOINT,
|
|
CREDENTIAL_SYNC_SECRET,
|
|
CREDENTIAL_SYNC_SECRET_HEADER_NAME,
|
|
} from "@calcom/lib/constants";
|
|
import { formatCalEvent } from "@calcom/lib/formatCalendarEvent";
|
|
import { getAllCalendars } from "@calcom/lib/google";
|
|
import logger from "@calcom/lib/logger";
|
|
import { safeStringify } from "@calcom/lib/safeStringify";
|
|
import { GoogleRepository } from "@calcom/lib/server/repository/google";
|
|
import prisma from "@calcom/prisma";
|
|
import type {
|
|
Calendar,
|
|
CalendarEvent,
|
|
EventBusyDate,
|
|
IntegrationCalendar,
|
|
NewCalendarEventType,
|
|
} from "@calcom/types/Calendar";
|
|
import type { CredentialPayload } from "@calcom/types/Credential";
|
|
|
|
import { invalidateCredential } from "../../_utils/invalidateCredential";
|
|
import { AxiosLikeResponseToFetchResponse } from "../../_utils/oauth/AxiosLikeResponseToFetchResponse";
|
|
import { OAuthManager } from "../../_utils/oauth/OAuthManager";
|
|
import { getTokenObjectFromCredential } from "../../_utils/oauth/getTokenObjectFromCredential";
|
|
import { markTokenAsExpired } from "../../_utils/oauth/markTokenAsExpired";
|
|
import { OAuth2UniversalSchema } from "../../_utils/oauth/universalSchema";
|
|
import { metadata } from "../_metadata";
|
|
import { getGoogleAppKeys } from "./getGoogleAppKeys";
|
|
|
|
const log = logger.getSubLogger({ prefix: ["app-store/googlecalendar/lib/CalendarService"] });
|
|
|
|
interface GoogleCalError extends Error {
|
|
code?: number;
|
|
}
|
|
|
|
const MS_PER_DAY = 24 * 60 * 60 * 1000;
|
|
const ONE_MONTH_IN_MS = 30 * MS_PER_DAY;
|
|
// eslint-disable-next-line turbo/no-undeclared-env-vars -- GOOGLE_WEBHOOK_URL only for local testing
|
|
const GOOGLE_WEBHOOK_URL_BASE = process.env.GOOGLE_WEBHOOK_URL || process.env.NEXT_PUBLIC_WEBAPP_URL;
|
|
const GOOGLE_WEBHOOK_URL = `${GOOGLE_WEBHOOK_URL_BASE}/api/integrations/googlecalendar/webhook`;
|
|
|
|
export default class GoogleCalendarService implements Calendar {
|
|
private integrationName = "";
|
|
private auth: ReturnType<typeof this.initGoogleAuth>;
|
|
private log: typeof logger;
|
|
private credential: CredentialPayload;
|
|
private myGoogleAuth!: MyGoogleAuth;
|
|
private oAuthManagerInstance!: OAuthManager;
|
|
constructor(credential: CredentialPayload) {
|
|
this.integrationName = "google_calendar";
|
|
this.credential = credential;
|
|
this.auth = this.initGoogleAuth(credential);
|
|
this.log = log.getSubLogger({ prefix: [`[[lib] ${this.integrationName}`] });
|
|
}
|
|
|
|
private async getMyGoogleAuthSingleton() {
|
|
if (this.myGoogleAuth) {
|
|
return this.myGoogleAuth;
|
|
}
|
|
const { client_id, client_secret, redirect_uris } = await getGoogleAppKeys();
|
|
const googleCredentials = OAuth2UniversalSchema.parse(this.credential.key);
|
|
this.myGoogleAuth = new MyGoogleAuth(client_id, client_secret, redirect_uris[0]);
|
|
this.myGoogleAuth.setCredentials(googleCredentials);
|
|
return this.myGoogleAuth;
|
|
}
|
|
|
|
private initGoogleAuth = (credential: CredentialPayload) => {
|
|
const currentTokenObject = getTokenObjectFromCredential(credential);
|
|
const auth = new OAuthManager({
|
|
// Keep it false because we are not using auth.request everywhere. That would be done later as it involves many google calendar sdk functionc calls and needs to be tested well.
|
|
autoCheckTokenExpiryOnRequest: false,
|
|
credentialSyncVariables: {
|
|
APP_CREDENTIAL_SHARING_ENABLED: APP_CREDENTIAL_SHARING_ENABLED,
|
|
CREDENTIAL_SYNC_ENDPOINT: CREDENTIAL_SYNC_ENDPOINT,
|
|
CREDENTIAL_SYNC_SECRET: CREDENTIAL_SYNC_SECRET,
|
|
CREDENTIAL_SYNC_SECRET_HEADER_NAME: CREDENTIAL_SYNC_SECRET_HEADER_NAME,
|
|
},
|
|
resourceOwner: {
|
|
type: "user",
|
|
id: credential.userId,
|
|
},
|
|
appSlug: metadata.slug,
|
|
currentTokenObject,
|
|
fetchNewTokenObject: async ({ refreshToken }: { refreshToken: string | null }) => {
|
|
const myGoogleAuth = await this.getMyGoogleAuthSingleton();
|
|
const fetchTokens = await myGoogleAuth.refreshToken(refreshToken);
|
|
// Create Response from fetchToken.res
|
|
const response = new Response(JSON.stringify(fetchTokens.res?.data ?? null), {
|
|
status: fetchTokens.res?.status,
|
|
statusText: fetchTokens.res?.statusText,
|
|
});
|
|
return response;
|
|
},
|
|
isTokenExpired: async () => {
|
|
const myGoogleAuth = await this.getMyGoogleAuthSingleton();
|
|
return myGoogleAuth.isTokenExpiring();
|
|
},
|
|
isTokenObjectUnusable: async function (response) {
|
|
// TODO: Confirm that if this logic should go to isAccessTokenUnusable
|
|
if (!response.ok || (response.status < 200 && response.status >= 300)) {
|
|
const responseBody = await response.json();
|
|
|
|
if (responseBody.error === "invalid_grant") {
|
|
return {
|
|
reason: "invalid_grant",
|
|
};
|
|
}
|
|
}
|
|
return null;
|
|
},
|
|
isAccessTokenUnusable: async () => {
|
|
// As long as refresh_token is valid, access_token is regenerated and fixed automatically by Google Calendar when a problem with it is detected
|
|
// So, a situation where access_token is invalid but refresh_token is valid should not happen
|
|
return null;
|
|
},
|
|
invalidateTokenObject: () => invalidateCredential(this.credential.id),
|
|
expireAccessToken: async () => {
|
|
await markTokenAsExpired(this.credential);
|
|
},
|
|
updateTokenObject: async (token) => {
|
|
this.myGoogleAuth.setCredentials(token);
|
|
|
|
const { key } = await prisma.credential.update({
|
|
where: {
|
|
id: credential.id,
|
|
},
|
|
data: {
|
|
key: token,
|
|
},
|
|
});
|
|
|
|
// Update cached credential as well
|
|
this.credential.key = key;
|
|
},
|
|
});
|
|
this.oAuthManagerInstance = auth;
|
|
return {
|
|
getMyGoogleAuthWithRefreshedToken: async () => {
|
|
// It would automatically update myGoogleAuth with correct token
|
|
const { token } = await auth.getTokenObjectOrFetch();
|
|
if (!token) {
|
|
throw new Error("Invalid grant for Google Calendar app");
|
|
}
|
|
|
|
const myGoogleAuth = await this.getMyGoogleAuthSingleton();
|
|
return myGoogleAuth;
|
|
},
|
|
};
|
|
};
|
|
|
|
public authedCalendar = async () => {
|
|
const myGoogleAuth = await this.auth.getMyGoogleAuthWithRefreshedToken();
|
|
const calendar = google.calendar({
|
|
version: "v3",
|
|
auth: myGoogleAuth,
|
|
});
|
|
return calendar;
|
|
};
|
|
|
|
private getAttendees = (event: CalendarEvent) => {
|
|
// When rescheduling events we know the external id of the calendar so we can just look for it in the destinationCalendar array.
|
|
const selectedHostDestinationCalendar = event.destinationCalendar?.find(
|
|
(cal) => cal.credentialId === this.credential.id
|
|
);
|
|
const eventAttendees = event.attendees.map(({ id: _id, ...rest }) => ({
|
|
...rest,
|
|
responseStatus: "accepted",
|
|
}));
|
|
const attendees: calendar_v3.Schema$EventAttendee[] = [
|
|
{
|
|
...event.organizer,
|
|
id: String(event.organizer.id),
|
|
responseStatus: "accepted",
|
|
organizer: true,
|
|
// Tried changing the display name to the user but GCal will not let you do that. It will only display the name of the external calendar. Leaving this in just incase it works in the future.
|
|
displayName: event.organizer.name,
|
|
email: selectedHostDestinationCalendar?.externalId ?? event.organizer.email,
|
|
},
|
|
...eventAttendees,
|
|
];
|
|
|
|
if (event.team?.members) {
|
|
// TODO: Check every other CalendarService for team members
|
|
const teamAttendeesWithoutCurrentUser = event.team.members
|
|
.filter((member) => member.email !== this.credential.user?.email)
|
|
.map((m) => {
|
|
const teamMemberDestinationCalendar = event.destinationCalendar?.find(
|
|
(calendar) => calendar.integration === "google_calendar" && calendar.userId === m.id
|
|
);
|
|
return {
|
|
email: teamMemberDestinationCalendar?.externalId ?? m.email,
|
|
displayName: m.name,
|
|
responseStatus: "accepted",
|
|
};
|
|
});
|
|
attendees.push(...teamAttendeesWithoutCurrentUser);
|
|
}
|
|
|
|
return attendees;
|
|
};
|
|
|
|
async createEvent(calEventRaw: CalendarEvent, credentialId: number): Promise<NewCalendarEventType> {
|
|
this.log.debug("Creating event");
|
|
const formattedCalEvent = formatCalEvent(calEventRaw);
|
|
|
|
const payload: calendar_v3.Schema$Event = {
|
|
summary: formattedCalEvent.title,
|
|
description: getRichDescription(formattedCalEvent),
|
|
start: {
|
|
dateTime: formattedCalEvent.startTime,
|
|
timeZone: formattedCalEvent.organizer.timeZone,
|
|
},
|
|
end: {
|
|
dateTime: formattedCalEvent.endTime,
|
|
timeZone: formattedCalEvent.organizer.timeZone,
|
|
},
|
|
attendees: this.getAttendees(formattedCalEvent),
|
|
reminders: {
|
|
useDefault: true,
|
|
},
|
|
guestsCanSeeOtherGuests: !!formattedCalEvent.seatsPerTimeSlot
|
|
? formattedCalEvent.seatsShowAttendees
|
|
: true,
|
|
iCalUID: formattedCalEvent.iCalUID,
|
|
};
|
|
if (calEventRaw.hideCalendarEventDetails) {
|
|
payload.visibility = "private";
|
|
}
|
|
|
|
if (formattedCalEvent.location) {
|
|
payload["location"] = getLocation(formattedCalEvent);
|
|
}
|
|
|
|
if (formattedCalEvent.recurringEvent) {
|
|
const rule = new RRule({
|
|
freq: formattedCalEvent.recurringEvent.freq,
|
|
interval: formattedCalEvent.recurringEvent.interval,
|
|
count: formattedCalEvent.recurringEvent.count,
|
|
});
|
|
|
|
payload["recurrence"] = [rule.toString()];
|
|
}
|
|
|
|
if (formattedCalEvent.conferenceData && formattedCalEvent.location === MeetLocationType) {
|
|
payload["conferenceData"] = formattedCalEvent.conferenceData;
|
|
}
|
|
const calendar = await this.authedCalendar();
|
|
// Find in formattedCalEvent.destinationCalendar the one with the same credentialId
|
|
|
|
const selectedCalendar =
|
|
formattedCalEvent.destinationCalendar?.find((cal) => cal.credentialId === credentialId)?.externalId ||
|
|
"primary";
|
|
|
|
try {
|
|
let event;
|
|
let recurringEventId = null;
|
|
if (formattedCalEvent.existingRecurringEvent) {
|
|
recurringEventId = formattedCalEvent.existingRecurringEvent.recurringEventId;
|
|
const recurringEventInstances = await calendar.events.instances({
|
|
calendarId: selectedCalendar,
|
|
eventId: formattedCalEvent.existingRecurringEvent.recurringEventId,
|
|
});
|
|
if (recurringEventInstances.data.items) {
|
|
const calComEventStartTime = dayjs(formattedCalEvent.startTime)
|
|
.tz(formattedCalEvent.organizer.timeZone)
|
|
.format();
|
|
for (let i = 0; i < recurringEventInstances.data.items.length; i++) {
|
|
const instance = recurringEventInstances.data.items[i];
|
|
const instanceStartTime = dayjs(instance.start?.dateTime)
|
|
.tz(instance.start?.timeZone == null ? undefined : instance.start?.timeZone)
|
|
.format();
|
|
|
|
if (instanceStartTime === calComEventStartTime) {
|
|
event = instance;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!event) {
|
|
event = recurringEventInstances.data.items[0];
|
|
this.log.error(
|
|
"Unable to find matching event amongst recurring event instances",
|
|
safeStringify({ selectedCalendar, credentialId })
|
|
);
|
|
}
|
|
await calendar.events.patch({
|
|
calendarId: selectedCalendar,
|
|
eventId: event.id || "",
|
|
requestBody: {
|
|
location: getLocation(formattedCalEvent),
|
|
description: getRichDescription({
|
|
...formattedCalEvent,
|
|
}),
|
|
},
|
|
});
|
|
}
|
|
} else {
|
|
const eventResponse = await calendar.events.insert({
|
|
calendarId: selectedCalendar,
|
|
requestBody: payload,
|
|
conferenceDataVersion: 1,
|
|
sendUpdates: "none",
|
|
});
|
|
event = eventResponse.data;
|
|
if (event.recurrence) {
|
|
if (event.recurrence.length > 0) {
|
|
recurringEventId = event.id;
|
|
event = await this.getFirstEventInRecurrence(recurringEventId, selectedCalendar, calendar);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (event && event.id && event.hangoutLink) {
|
|
await calendar.events.patch({
|
|
// Update the same event but this time we know the hangout link
|
|
calendarId: selectedCalendar,
|
|
eventId: event.id || "",
|
|
requestBody: {
|
|
description: getRichDescription({
|
|
...formattedCalEvent,
|
|
additionalInformation: { hangoutLink: event.hangoutLink },
|
|
}),
|
|
},
|
|
});
|
|
}
|
|
|
|
return {
|
|
uid: "",
|
|
...event,
|
|
id: event?.id || "",
|
|
thirdPartyRecurringEventId: recurringEventId,
|
|
additionalInfo: {
|
|
hangoutLink: event?.hangoutLink || "",
|
|
},
|
|
type: "google_calendar",
|
|
password: "",
|
|
url: "",
|
|
iCalUID: event?.iCalUID,
|
|
};
|
|
} catch (error) {
|
|
this.log.error(
|
|
"There was an error creating event in google calendar: ",
|
|
safeStringify({ error, selectedCalendar, credentialId })
|
|
);
|
|
throw error;
|
|
}
|
|
}
|
|
async getFirstEventInRecurrence(
|
|
recurringEventId: string | null | undefined,
|
|
selectedCalendar: string,
|
|
calendar: calendar_v3.Calendar
|
|
): Promise<calendar_v3.Schema$Event> {
|
|
const recurringEventInstances = await calendar.events.instances({
|
|
calendarId: selectedCalendar,
|
|
eventId: recurringEventId || "",
|
|
});
|
|
|
|
if (recurringEventInstances.data.items) {
|
|
return recurringEventInstances.data.items[0];
|
|
} else {
|
|
return {} as calendar_v3.Schema$Event;
|
|
}
|
|
}
|
|
|
|
async updateEvent(uid: string, event: CalendarEvent, externalCalendarId: string): Promise<any> {
|
|
const formattedCalEvent = formatCalEvent(event);
|
|
|
|
const payload: calendar_v3.Schema$Event = {
|
|
summary: formattedCalEvent.title,
|
|
description: getRichDescription(formattedCalEvent),
|
|
start: {
|
|
dateTime: formattedCalEvent.startTime,
|
|
timeZone: formattedCalEvent.organizer.timeZone,
|
|
},
|
|
end: {
|
|
dateTime: formattedCalEvent.endTime,
|
|
timeZone: formattedCalEvent.organizer.timeZone,
|
|
},
|
|
attendees: this.getAttendees(formattedCalEvent),
|
|
reminders: {
|
|
useDefault: true,
|
|
},
|
|
guestsCanSeeOtherGuests: !!formattedCalEvent.seatsPerTimeSlot
|
|
? formattedCalEvent.seatsShowAttendees
|
|
: true,
|
|
};
|
|
|
|
if (formattedCalEvent.location) {
|
|
payload["location"] = getLocation(formattedCalEvent);
|
|
}
|
|
|
|
if (formattedCalEvent.conferenceData && formattedCalEvent.location === MeetLocationType) {
|
|
payload["conferenceData"] = formattedCalEvent.conferenceData;
|
|
}
|
|
|
|
const calendar = await this.authedCalendar();
|
|
|
|
const selectedCalendar =
|
|
(externalCalendarId
|
|
? formattedCalEvent.destinationCalendar?.find((cal) => cal.externalId === externalCalendarId)
|
|
?.externalId
|
|
: undefined) || "primary";
|
|
|
|
try {
|
|
const evt = await calendar.events.update({
|
|
calendarId: selectedCalendar,
|
|
eventId: uid,
|
|
sendNotifications: true,
|
|
sendUpdates: "none",
|
|
requestBody: payload,
|
|
conferenceDataVersion: 1,
|
|
});
|
|
|
|
this.log.debug("Updated Google Calendar Event", {
|
|
startTime: evt?.data.start,
|
|
endTime: evt?.data.end,
|
|
});
|
|
|
|
if (evt && evt.data.id && evt.data.hangoutLink && event.location === MeetLocationType) {
|
|
calendar.events.patch({
|
|
// Update the same event but this time we know the hangout link
|
|
calendarId: selectedCalendar,
|
|
eventId: evt.data.id || "",
|
|
requestBody: {
|
|
description: getRichDescription({
|
|
...formattedCalEvent,
|
|
additionalInformation: { hangoutLink: evt.data.hangoutLink },
|
|
}),
|
|
},
|
|
});
|
|
return {
|
|
uid: "",
|
|
...evt.data,
|
|
id: evt.data.id || "",
|
|
additionalInfo: {
|
|
hangoutLink: evt.data.hangoutLink || "",
|
|
},
|
|
type: "google_calendar",
|
|
password: "",
|
|
url: "",
|
|
iCalUID: evt.data.iCalUID,
|
|
};
|
|
}
|
|
return evt?.data;
|
|
} catch (error) {
|
|
this.log.error(
|
|
"There was an error updating event in google calendar: ",
|
|
safeStringify({ error, event: formattedCalEvent, uid })
|
|
);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
async deleteEvent(uid: string, event: CalendarEvent, externalCalendarId?: string | null): Promise<void> {
|
|
const calendar = await this.authedCalendar();
|
|
|
|
const selectedCalendar = externalCalendarId || "primary";
|
|
|
|
try {
|
|
const event = await calendar.events.delete({
|
|
calendarId: selectedCalendar,
|
|
eventId: uid,
|
|
sendNotifications: false,
|
|
sendUpdates: "none",
|
|
});
|
|
return event?.data;
|
|
} catch (error) {
|
|
this.log.error(
|
|
"There was an error deleting event from google calendar: ",
|
|
safeStringify({ error, event, externalCalendarId })
|
|
);
|
|
const err = error as GoogleCalError;
|
|
/**
|
|
* 410 is when an event is already deleted on the Google cal before on cal.com
|
|
* 404 is when the event is on a different calendar
|
|
*/
|
|
if (err.code === 410) return;
|
|
console.error("There was an error contacting google calendar service: ", err);
|
|
if (err.code === 404) return;
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
async fetchAvailability(requestBody: FreeBusyArgs): Promise<calendar_v3.Schema$FreeBusyResponse> {
|
|
const calendar = await this.authedCalendar();
|
|
const apiResponse = await this.oAuthManagerInstance.request(
|
|
async () => new AxiosLikeResponseToFetchResponse(await calendar.freebusy.query({ requestBody }))
|
|
);
|
|
return apiResponse.json;
|
|
}
|
|
|
|
async getCacheOrFetchAvailability(args: FreeBusyArgs): Promise<EventBusyDate[] | null> {
|
|
const { timeMin, timeMax, items } = args;
|
|
let freeBusyResult: calendar_v3.Schema$FreeBusyResponse = {};
|
|
const calendarCache = await CalendarCache.init(null);
|
|
const cached = await calendarCache.getCachedAvailability(this.credential.id, args);
|
|
if (cached) {
|
|
freeBusyResult = cached.value as unknown as calendar_v3.Schema$FreeBusyResponse;
|
|
} else {
|
|
freeBusyResult = await this.fetchAvailability({ timeMin, timeMax, items });
|
|
}
|
|
if (!freeBusyResult.calendars) return null;
|
|
|
|
const result = Object.values(freeBusyResult.calendars).reduce((c, i) => {
|
|
i.busy?.forEach((busyTime) => {
|
|
c.push({
|
|
start: busyTime.start || "",
|
|
end: busyTime.end || "",
|
|
});
|
|
});
|
|
return c;
|
|
}, [] as Prisma.PromiseReturnType<CalendarService["getAvailability"]>);
|
|
return result;
|
|
}
|
|
|
|
async getAvailability(
|
|
dateFrom: string,
|
|
dateTo: string,
|
|
selectedCalendars: IntegrationCalendar[]
|
|
): Promise<EventBusyDate[]> {
|
|
this.log.debug("Getting availability", safeStringify({ dateFrom, dateTo, selectedCalendars }));
|
|
const calendar = await this.authedCalendar();
|
|
const selectedCalendarIds = selectedCalendars
|
|
.filter((e) => e.integration === this.integrationName)
|
|
.map((e) => e.externalId);
|
|
if (selectedCalendarIds.length === 0 && selectedCalendars.length > 0) {
|
|
// Only calendars of other integrations selected
|
|
return [];
|
|
}
|
|
async function getCalIds() {
|
|
if (selectedCalendarIds.length !== 0) return selectedCalendarIds;
|
|
const cals = await getAllCalendars(calendar, ["id"]);
|
|
if (!cals.length) return [];
|
|
return cals.reduce((c, cal) => (cal.id ? [...c, cal.id] : c), [] as string[]);
|
|
}
|
|
|
|
try {
|
|
const calsIds = await getCalIds();
|
|
const originalStartDate = dayjs(dateFrom);
|
|
const originalEndDate = dayjs(dateTo);
|
|
const diff = originalEndDate.diff(originalStartDate, "days");
|
|
|
|
// /freebusy from google api only allows a date range of 90 days
|
|
if (diff <= 90) {
|
|
const freeBusyData = await this.getCacheOrFetchAvailability({
|
|
timeMin: dateFrom,
|
|
timeMax: dateTo,
|
|
items: calsIds.map((id) => ({ id })),
|
|
});
|
|
if (!freeBusyData) throw new Error("No response from google calendar");
|
|
|
|
return freeBusyData;
|
|
} else {
|
|
const busyData = [];
|
|
|
|
const loopsNumber = Math.ceil(diff / 90);
|
|
|
|
let startDate = originalStartDate;
|
|
let endDate = originalStartDate.add(90, "days");
|
|
|
|
for (let i = 0; i < loopsNumber; i++) {
|
|
if (endDate.isAfter(originalEndDate)) endDate = originalEndDate;
|
|
|
|
busyData.push(
|
|
...((await this.getCacheOrFetchAvailability({
|
|
timeMin: startDate.format(),
|
|
timeMax: endDate.format(),
|
|
items: calsIds.map((id) => ({ id })),
|
|
})) || [])
|
|
);
|
|
|
|
startDate = endDate.add(1, "minutes");
|
|
endDate = startDate.add(90, "days");
|
|
}
|
|
return busyData;
|
|
}
|
|
} catch (error) {
|
|
this.log.error(
|
|
"There was an error getting availability from google calendar: ",
|
|
safeStringify({ error, selectedCalendars })
|
|
);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
async listCalendars(): Promise<IntegrationCalendar[]> {
|
|
this.log.debug("Listing calendars");
|
|
const calendar = await this.authedCalendar();
|
|
try {
|
|
const { json: cals } = await this.oAuthManagerInstance.request(
|
|
async () =>
|
|
new AxiosLikeResponseToFetchResponse({
|
|
status: 200,
|
|
statusText: "OK",
|
|
data: {
|
|
items: await getAllCalendars(calendar),
|
|
},
|
|
})
|
|
);
|
|
|
|
if (!cals.items) return [];
|
|
return cals.items.map(
|
|
(cal) =>
|
|
({
|
|
externalId: cal.id ?? "No id",
|
|
integration: this.integrationName,
|
|
name: cal.summary ?? "No name",
|
|
primary: cal.primary ?? false,
|
|
readOnly: !(cal.accessRole === "writer" || cal.accessRole === "owner") && true,
|
|
email: cal.id ?? "",
|
|
} satisfies IntegrationCalendar)
|
|
);
|
|
} catch (error) {
|
|
this.log.error("There was an error getting calendars: ", safeStringify(error));
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
async watchCalendar({ calendarId }: { calendarId: string }) {
|
|
if (!process.env.GOOGLE_WEBHOOK_TOKEN) {
|
|
log.warn("GOOGLE_WEBHOOK_TOKEN is not set, skipping watching calendar");
|
|
return;
|
|
}
|
|
const calendar = await this.authedCalendar();
|
|
const res = await calendar.events.watch({
|
|
// Calendar identifier. To retrieve calendar IDs call the calendarList.list method. If you want to access the primary calendar of the currently logged in user, use the "primary" keyword.
|
|
calendarId,
|
|
requestBody: {
|
|
// A UUID or similar unique string that identifies this channel.
|
|
id: uuid(),
|
|
type: "web_hook",
|
|
address: GOOGLE_WEBHOOK_URL,
|
|
token: process.env.GOOGLE_WEBHOOK_TOKEN,
|
|
params: {
|
|
// The time-to-live in seconds for the notification channel. Default is 604800 seconds.
|
|
ttl: `${Math.round(ONE_MONTH_IN_MS / 1000)}`,
|
|
},
|
|
},
|
|
});
|
|
const response = res.data;
|
|
await GoogleRepository.upsertSelectedCalendar({
|
|
userId: this.credential.userId!,
|
|
externalId: calendarId,
|
|
credentialId: this.credential.id,
|
|
googleChannelId: response?.id,
|
|
googleChannelKind: response?.kind,
|
|
googleChannelResourceId: response?.resourceId,
|
|
googleChannelResourceUri: response?.resourceUri,
|
|
googleChannelExpiration: response?.expiration,
|
|
});
|
|
|
|
return res.data;
|
|
}
|
|
async unwatchCalendar({ calendarId }: { calendarId: string }) {
|
|
const credentialId = this.credential.id;
|
|
const sc = await prisma.selectedCalendar.findFirst({
|
|
where: {
|
|
credentialId,
|
|
externalId: calendarId,
|
|
},
|
|
});
|
|
// Delete the calendar cache to force a fresh cache
|
|
await prisma.calendarCache.deleteMany({ where: { credentialId } });
|
|
const calendar = await this.authedCalendar();
|
|
await calendar.channels
|
|
.stop({
|
|
requestBody: {
|
|
resourceId: sc?.googleChannelResourceId,
|
|
id: sc?.googleChannelId,
|
|
},
|
|
})
|
|
.catch((err) => {
|
|
console.warn(JSON.stringify(err));
|
|
});
|
|
await GoogleRepository.upsertSelectedCalendar({
|
|
userId: this.credential.userId!,
|
|
externalId: calendarId,
|
|
credentialId: this.credential.id,
|
|
googleChannelId: null,
|
|
googleChannelKind: null,
|
|
googleChannelResourceId: null,
|
|
googleChannelResourceUri: null,
|
|
googleChannelExpiration: null,
|
|
});
|
|
}
|
|
|
|
async setAvailabilityInCache(args: FreeBusyArgs, data: calendar_v3.Schema$FreeBusyResponse): Promise<void> {
|
|
const calendarCache = await CalendarCache.init(null);
|
|
await calendarCache.upsertCachedAvailability(this.credential.id, args, JSON.parse(JSON.stringify(data)));
|
|
}
|
|
|
|
async fetchAvailabilityAndSetCache(selectedCalendars: IntegrationCalendar[]) {
|
|
const date = new Date();
|
|
const parsedArgs = {
|
|
/** Expand the start date to the start of the month */
|
|
timeMin: new Date(date.getFullYear(), date.getMonth(), 1, 0, 0, 0, 0).toISOString(),
|
|
/** Expand the end date to the end of the month */
|
|
timeMax: new Date(date.getFullYear(), date.getMonth() + 1, 0, 0, 0, 0, 0).toISOString(),
|
|
items: selectedCalendars.map((sc) => ({ id: sc.externalId })),
|
|
};
|
|
const data = await this.fetchAvailability(parsedArgs);
|
|
await this.setAvailabilityInCache(parsedArgs, data);
|
|
}
|
|
}
|
|
|
|
class MyGoogleAuth extends google.auth.OAuth2 {
|
|
constructor(client_id: string, client_secret: string, redirect_uri: string) {
|
|
super(client_id, client_secret, redirect_uri);
|
|
}
|
|
|
|
isTokenExpiring() {
|
|
return super.isTokenExpiring();
|
|
}
|
|
|
|
async refreshToken(token: string | null | undefined) {
|
|
return super.refreshToken(token);
|
|
}
|
|
}
|