296 lines
9.8 KiB
TypeScript
296 lines
9.8 KiB
TypeScript
import {
|
|
Attendee,
|
|
Booking,
|
|
BookingReference,
|
|
BookingStatus,
|
|
EventType,
|
|
User,
|
|
WebhookTriggerEvents,
|
|
} from "@prisma/client";
|
|
import type { NextApiRequest, NextApiResponse } from "next";
|
|
import { getSession } from "next-auth/react";
|
|
import type { TFunction } from "next-i18next";
|
|
import { z, ZodError } from "zod";
|
|
|
|
import { getCalendar } from "@calcom/app-store/_utils/getCalendar";
|
|
import { CalendarEventBuilder } from "@calcom/core/builders/CalendarEvent/builder";
|
|
import { CalendarEventDirector } from "@calcom/core/builders/CalendarEvent/director";
|
|
import { deleteMeeting } from "@calcom/core/videoClient";
|
|
import dayjs from "@calcom/dayjs";
|
|
import { sendRequestRescheduleEmail } from "@calcom/emails";
|
|
import { isPrismaObjOrUndefined } from "@calcom/lib";
|
|
import { getTranslation } from "@calcom/lib/server/i18n";
|
|
import prisma from "@calcom/prisma";
|
|
import type { CalendarEvent, Person } from "@calcom/types/Calendar";
|
|
|
|
import sendPayload from "@lib/webhooks/sendPayload";
|
|
import getWebhooks from "@lib/webhooks/subscriptions";
|
|
|
|
export type RescheduleResponse = Booking & {
|
|
attendees: Attendee[];
|
|
};
|
|
export type PersonAttendeeCommonFields = Pick<
|
|
User,
|
|
"id" | "email" | "name" | "locale" | "timeZone" | "username"
|
|
>;
|
|
|
|
const rescheduleSchema = z.object({
|
|
bookingId: z.string(),
|
|
rescheduleReason: z.string().optional(),
|
|
});
|
|
|
|
const findUserDataByUserId = async (userId: number) => {
|
|
return await prisma.user.findUniqueOrThrow({
|
|
where: {
|
|
id: userId,
|
|
},
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
username: true,
|
|
email: true,
|
|
timeZone: true,
|
|
locale: true,
|
|
credentials: true,
|
|
destinationCalendar: true,
|
|
teams: true,
|
|
},
|
|
});
|
|
};
|
|
|
|
const handler = async (
|
|
req: NextApiRequest,
|
|
res: NextApiResponse
|
|
): Promise<RescheduleResponse | NextApiResponse | void> => {
|
|
const session = await getSession({ req });
|
|
const {
|
|
bookingId,
|
|
rescheduleReason: cancellationReason,
|
|
}: { bookingId: string; rescheduleReason: string; cancellationReason: string } = req.body;
|
|
let user: Awaited<ReturnType<typeof findUserDataByUserId>>;
|
|
try {
|
|
if (session?.user?.id) {
|
|
user = await findUserDataByUserId(session?.user.id);
|
|
} else {
|
|
return res.status(501).end();
|
|
}
|
|
|
|
const bookingToReschedule = await prisma.booking.findFirstOrThrow({
|
|
select: {
|
|
id: true,
|
|
uid: true,
|
|
userId: true,
|
|
title: true,
|
|
description: true,
|
|
startTime: true,
|
|
endTime: true,
|
|
eventTypeId: true,
|
|
eventType: true,
|
|
location: true,
|
|
attendees: true,
|
|
references: true,
|
|
customInputs: true,
|
|
dynamicEventSlugRef: true,
|
|
dynamicGroupSlugRef: true,
|
|
destinationCalendar: true,
|
|
},
|
|
where: {
|
|
uid: bookingId,
|
|
NOT: {
|
|
status: {
|
|
in: [BookingStatus.CANCELLED, BookingStatus.REJECTED],
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
if (!bookingToReschedule.userId) {
|
|
throw new Error("Booking to reschedule doesn't have an owner.");
|
|
}
|
|
if (!bookingToReschedule.eventType) {
|
|
throw new Error("EventType not found for current booking.");
|
|
}
|
|
|
|
const bookingBelongsToTeam = !!bookingToReschedule.eventType?.teamId;
|
|
if (bookingBelongsToTeam && bookingToReschedule.eventType?.teamId) {
|
|
const userTeamIds = user.teams.map((item) => item.teamId);
|
|
if (userTeamIds.indexOf(bookingToReschedule?.eventType?.teamId) === -1) {
|
|
throw new Error("User isn't a member on the team");
|
|
}
|
|
}
|
|
if (!bookingBelongsToTeam && bookingToReschedule.userId !== user.id) {
|
|
throw new Error("User isn't owner of the current booking");
|
|
}
|
|
|
|
if (bookingToReschedule && user) {
|
|
let event: Partial<EventType> = {};
|
|
if (bookingToReschedule.eventTypeId) {
|
|
event = await prisma.eventType.findFirstOrThrow({
|
|
select: {
|
|
title: true,
|
|
users: true,
|
|
schedulingType: true,
|
|
recurringEvent: true,
|
|
},
|
|
where: {
|
|
id: bookingToReschedule.eventTypeId,
|
|
},
|
|
});
|
|
}
|
|
await prisma.booking.update({
|
|
where: {
|
|
id: bookingToReschedule.id,
|
|
},
|
|
data: {
|
|
rescheduled: true,
|
|
cancellationReason,
|
|
status: BookingStatus.CANCELLED,
|
|
updatedAt: dayjs().toISOString(),
|
|
},
|
|
});
|
|
|
|
const [mainAttendee] = bookingToReschedule.attendees;
|
|
// @NOTE: Should we assume attendees language?
|
|
const tAttendees = await getTranslation(mainAttendee.locale ?? "en", "common");
|
|
const usersToPeopleType = (
|
|
users: PersonAttendeeCommonFields[],
|
|
selectedLanguage: TFunction
|
|
): Person[] => {
|
|
return users?.map((user) => {
|
|
return {
|
|
email: user.email || "",
|
|
name: user.name || "",
|
|
username: user?.username || "",
|
|
language: { translate: selectedLanguage, locale: user.locale || "en" },
|
|
timeZone: user?.timeZone,
|
|
};
|
|
});
|
|
};
|
|
|
|
const userTranslation = await getTranslation(user.locale ?? "en", "common");
|
|
const [userAsPeopleType] = usersToPeopleType([user], userTranslation);
|
|
|
|
const builder = new CalendarEventBuilder();
|
|
builder.init({
|
|
title: bookingToReschedule.title,
|
|
type: event && event.title ? event.title : bookingToReschedule.title,
|
|
startTime: bookingToReschedule.startTime.toISOString(),
|
|
endTime: bookingToReschedule.endTime.toISOString(),
|
|
attendees: usersToPeopleType(
|
|
// username field doesn't exists on attendee but could be in the future
|
|
bookingToReschedule.attendees as unknown as PersonAttendeeCommonFields[],
|
|
tAttendees
|
|
),
|
|
organizer: userAsPeopleType,
|
|
});
|
|
|
|
const director = new CalendarEventDirector();
|
|
director.setBuilder(builder);
|
|
director.setExistingBooking(bookingToReschedule);
|
|
director.setCancellationReason(cancellationReason);
|
|
if (event) {
|
|
await director.buildForRescheduleEmail();
|
|
} else {
|
|
await director.buildWithoutEventTypeForRescheduleEmail();
|
|
}
|
|
|
|
// Handling calendar and videos cancellation
|
|
// This can set previous time as available, until virtual calendar is done
|
|
const credentialsMap = new Map();
|
|
user.credentials.forEach((credential) => {
|
|
credentialsMap.set(credential.type, credential);
|
|
});
|
|
const bookingRefsFiltered: BookingReference[] = bookingToReschedule.references.filter(
|
|
(ref) => !!credentialsMap.get(ref.type)
|
|
);
|
|
bookingRefsFiltered.forEach((bookingRef) => {
|
|
if (bookingRef.uid) {
|
|
if (bookingRef.type.endsWith("_calendar")) {
|
|
const calendar = getCalendar(credentialsMap.get(bookingRef.type));
|
|
|
|
return calendar?.deleteEvent(
|
|
bookingRef.uid,
|
|
builder.calendarEvent,
|
|
bookingRef.externalCalendarId
|
|
);
|
|
} else if (bookingRef.type.endsWith("_video")) {
|
|
return deleteMeeting(credentialsMap.get(bookingRef.type), bookingRef.uid);
|
|
}
|
|
}
|
|
});
|
|
|
|
// Send emails
|
|
await sendRequestRescheduleEmail(builder.calendarEvent, {
|
|
rescheduleLink: builder.rescheduleLink,
|
|
});
|
|
|
|
const evt: CalendarEvent = {
|
|
title: bookingToReschedule?.title,
|
|
type: event && event.title ? event.title : bookingToReschedule.title,
|
|
description: bookingToReschedule?.description || "",
|
|
customInputs: isPrismaObjOrUndefined(bookingToReschedule.customInputs),
|
|
startTime: bookingToReschedule?.startTime ? dayjs(bookingToReschedule.startTime).format() : "",
|
|
endTime: bookingToReschedule?.endTime ? dayjs(bookingToReschedule.endTime).format() : "",
|
|
organizer: userAsPeopleType,
|
|
attendees: usersToPeopleType(
|
|
// username field doesn't exists on attendee but could be in the future
|
|
bookingToReschedule.attendees as unknown as PersonAttendeeCommonFields[],
|
|
tAttendees
|
|
),
|
|
uid: bookingToReschedule?.uid,
|
|
location: bookingToReschedule?.location,
|
|
destinationCalendar:
|
|
bookingToReschedule?.destinationCalendar || bookingToReschedule?.destinationCalendar,
|
|
cancellationReason: `Please reschedule. ${cancellationReason}`, // TODO::Add i18-next for this
|
|
};
|
|
|
|
// Send webhook
|
|
const eventTrigger: WebhookTriggerEvents = "BOOKING_CANCELLED";
|
|
// Send Webhook call if hooked to BOOKING.CANCELLED
|
|
const subscriberOptions = {
|
|
userId: bookingToReschedule.userId,
|
|
eventTypeId: (bookingToReschedule.eventTypeId as number) || 0,
|
|
triggerEvent: eventTrigger,
|
|
};
|
|
const webhooks = await getWebhooks(subscriberOptions);
|
|
const promises = webhooks.map((webhook) =>
|
|
sendPayload(webhook.secret, eventTrigger, new Date().toISOString(), webhook, evt).catch((e) => {
|
|
console.error(
|
|
`Error executing webhook for event: ${eventTrigger}, URL: ${webhook.subscriberUrl}`,
|
|
e
|
|
);
|
|
})
|
|
);
|
|
await Promise.all(promises);
|
|
}
|
|
|
|
return res.status(200).json(bookingToReschedule);
|
|
} catch (error) {
|
|
if (error instanceof Error) {
|
|
throw new Error("Error.request.reschedule " + error?.message);
|
|
}
|
|
}
|
|
};
|
|
|
|
function validate(
|
|
handler: (req: NextApiRequest, res: NextApiResponse) => Promise<RescheduleResponse | NextApiResponse | void>
|
|
) {
|
|
return async (req: NextApiRequest, res: NextApiResponse) => {
|
|
if (req.method === "POST") {
|
|
try {
|
|
rescheduleSchema.parse(req.body);
|
|
} catch (error) {
|
|
if (error instanceof ZodError && error?.name === "ZodError") {
|
|
return res.status(400).json(error?.issues);
|
|
}
|
|
return res.status(402).end();
|
|
}
|
|
} else {
|
|
return res.status(405).end();
|
|
}
|
|
await handler(req, res);
|
|
};
|
|
}
|
|
|
|
export default validate(handler);
|