import { Credential } from "@prisma/client"; import { z } from "zod"; import dayjs from "@calcom/dayjs"; import { handleErrorsJson } from "@calcom/lib/errors"; import prisma from "@calcom/prisma"; import { Frequency } from "@calcom/prisma/zod-utils"; import type { CalendarEvent } from "@calcom/types/Calendar"; import type { PartialReference } from "@calcom/types/EventManager"; import type { VideoApiAdapter, VideoCallData } from "@calcom/types/VideoApiAdapter"; import { getZoomAppKeys } from "./getZoomAppKeys"; /** @link https://marketplace.zoom.us/docs/api-reference/zoom-api/meetings/meetingcreate */ const zoomEventResultSchema = z.object({ id: z.number(), join_url: z.string(), password: z.string().optional().default(""), }); export type ZoomEventResult = z.infer; export const zoomMeetingsSchema = z.object({ next_page_token: z.string(), page_count: z.number(), page_number: z.number(), page_size: z.number(), total_records: z.number(), meetings: z.array( z.object({ agenda: z.string(), created_at: z.string(), duration: z.number(), host_id: z.string(), id: z.number(), join_url: z.string(), pmi: z.string(), start_time: z.string(), timezone: z.string(), topic: z.string(), type: z.number(), uuid: z.string(), }) ), }); // Successful API response const zoomTokenSchema = z.object({ scope: z.string().regex(new RegExp("meeting:write")), expiry_date: z.number(), expires_in: z.number().optional(), // deprecated, purely for backwards compatibility; superseeded by expiry_date. token_type: z.literal("bearer"), access_token: z.string(), refresh_token: z.string(), }); type ZoomToken = z.infer; const isTokenValid = (token: ZoomToken) => (token.expires_in || token.expiry_date) < Date.now(); const zoomAuth = (credential: Credential) => { const refreshAccessToken = async (refreshToken: string) => { const { client_id, client_secret } = await getZoomAppKeys(); const authHeader = "Basic " + Buffer.from(client_id + ":" + client_secret).toString("base64"); return fetch("https://zoom.us/oauth/token", { method: "POST", headers: { Authorization: authHeader, "Content-Type": "application/x-www-form-urlencoded", }, body: new URLSearchParams({ refresh_token: refreshToken, grant_type: "refresh_token", }), }) .then(handleErrorsJson) .then(async (responseBody) => { if (!responseBody.refresh_token) Promise.reject(new Error("Invalid credentials")); // set expiry date as offset from current time. responseBody.expiry_date = Math.round(Date.now() + responseBody.expires_in * 1000); delete responseBody.expires_in; // Store new tokens in database. await prisma.credential.update({ where: { id: credential.id, }, data: { key: responseBody, }, }); return responseBody.access_token; }); }; return { getToken: async () => { let credentialKey: ZoomToken | null = null; try { credentialKey = zoomTokenSchema.parse(credential.key); } catch (error) { // If the parse fails, it means we have an invalid credential saved. We should delete it. await prisma.credential.delete({ where: { id: credential.id } }); // We reject the promise, and should handle the error on the UI return Promise.reject( "This Zoom credential was malformed so we've removed it from the DB. Please add a new Zoom credential" ); } return !isTokenValid(credentialKey) ? Promise.resolve(credentialKey.access_token) : refreshAccessToken(credentialKey.refresh_token); }, }; }; type ZoomRecurrence = { end_date_time?: string; type: 1 | 2 | 3; end_times?: number; repeat_interval?: number; weekly_days?: number; // 1-7 Sunday = 1, Saturday = 7 monthly_day?: number; // 1-31 }; const ZoomVideoApiAdapter = (credential: Credential): VideoApiAdapter => { const translateEvent = (event: CalendarEvent) => { const getRecurrence = ({ recurringEvent, startTime, attendees, }: CalendarEvent): { recurrence: ZoomRecurrence; type: 8 } | undefined => { if (!recurringEvent) { return; } let recurrence: ZoomRecurrence; switch (recurringEvent.freq) { case Frequency.DAILY: recurrence = { type: 1, }; break; case Frequency.WEEKLY: recurrence = { type: 2, weekly_days: dayjs(startTime).tz(attendees[0].timeZone).day() + 1, }; break; case Frequency.MONTHLY: recurrence = { type: 3, monthly_day: dayjs(startTime).tz(attendees[0].timeZone).date(), }; break; default: // Zoom does not support YEARLY, HOURLY or MINUTELY frequencies, don't do anything in those cases. return; } recurrence.repeat_interval = recurringEvent.interval; if (recurringEvent.until) { recurrence.end_date_time = recurringEvent.until.toISOString(); } else { recurrence.end_times = recurringEvent.count; } return { recurrence: { ...recurrence, }, type: 8, }; }; const recurrence = getRecurrence(event); // Documentation at: https://marketplace.zoom.us/docs/api-reference/zoom-api/meetings/meetingcreate return { topic: event.title, type: 2, // Means that this is a scheduled meeting start_time: event.startTime, duration: (new Date(event.endTime).getTime() - new Date(event.startTime).getTime()) / 60000, //schedule_for: "string", TODO: Used when scheduling the meeting for someone else (needed?) timezone: event.attendees[0].timeZone, //password: "string", TODO: Should we use a password? Maybe generate a random one? agenda: event.description, settings: { host_video: true, participant_video: true, cn_meeting: false, // TODO: true if host meeting in China in_meeting: false, // TODO: true if host meeting in India join_before_host: true, mute_upon_entry: false, watermark: false, use_pmi: false, approval_type: 2, audio: "both", auto_recording: "none", enforce_login: false, registrants_email_notification: true, }, ...recurrence, }; }; const fetchZoomApi = async (endpoint: string, options?: RequestInit) => { const auth = zoomAuth(credential); const accessToken = await auth.getToken(); const responseBody = await fetch(`https://api.zoom.us/v2/${endpoint}`, { method: "GET", ...options, headers: { Authorization: "Bearer " + accessToken, ...options?.headers, }, }).then(handleErrorsJson); return responseBody; }; return { getAvailability: async () => { try { // TODO Possibly implement pagination for cases when there are more than 300 meetings already scheduled. const responseBody = await fetchZoomApi("users/me/meetings?type=scheduled&page_size=300"); const data = zoomMeetingsSchema.parse(responseBody); return data.meetings.map((meeting) => ({ start: meeting.start_time, end: new Date(new Date(meeting.start_time).getTime() + meeting.duration * 60000).toISOString(), })); } catch (err) { console.error(err); /* Prevents booking failure when Zoom Token is expired */ return []; } }, createMeeting: async (event: CalendarEvent): Promise => { const response: ZoomEventResult = await fetchZoomApi("users/me/meetings", { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify(translateEvent(event)), }); const result = zoomEventResultSchema.parse(response); if (result.id && result.join_url) { return Promise.resolve({ type: "zoom_video", id: result.id.toString(), password: result.password || "", url: result.join_url, }); } return Promise.reject(new Error("Failed to create meeting. Response is " + JSON.stringify(result))); }, deleteMeeting: async (uid: string): Promise => { await fetchZoomApi(`meetings/${uid}`, { method: "DELETE", }); return Promise.resolve(); }, updateMeeting: async (bookingRef: PartialReference, event: CalendarEvent): Promise => { await fetchZoomApi(`meetings/${bookingRef.uid}`, { method: "PATCH", headers: { "Content-Type": "application/json", }, body: JSON.stringify(translateEvent(event)), }); return Promise.resolve({ type: "zoom_video", id: bookingRef.meetingId as string, password: bookingRef.meetingPassword as string, url: bookingRef.meetingUrl as string, }); }, }; }; export default ZoomVideoApiAdapter;