* WIP-already-reschedule-success-emails-missing * WIP now saving bookingSeatsReferences and identifyin on reschedule/book page * Remove logs and created test * WIP saving progress * Select second slot to pass test * Delete attendee from event * Clean up * Update with main changes * Fix emails not being sent * Changed test end url from success to booking * Remove unused pkg * Fix new booking reschedule * remove log * Renable test * remove unused pkg * rename table name * review changes * Fix and and other test to reschedule with seats * Fix api for cancel booking * Typings * Update [uid].tsx * Abstracted common pattern into maybeGetBookingUidFromSeat * Reverts * Nitpicks * Update handleCancelBooking.ts * Adds missing cascades * Improve booking seats changes (#6858) * Create sendCancelledSeatEmails * Draft attendee cancelled seat email * Send no longer attendee email to attendee * Send email to organizer when attendee cancels * Pass cloned event data to emails * Send booked email for first seat * Add seat reference uid from email link * Query for seatReferenceUId and add to cancel & reschedule links * WIP * Display proper attendee when rescheduling seats * Remove console.logs * Only check for already invited when not rescheduling * WIP sending reschedule email to just single attendee and owner * Merge branch 'main' into send-email-on-seats-attendee-changes * Remove console.logs * Add cloned event to seat emails * Do not show manage link for calendar event * First seat, have both attendees on calendar * WIP refactor booking seats reschedule logic * WIP Refactor handleSeats * Change relation of attendee & seat reference to a one-to-one * Migration with relationship change * Booking page handling unique seat references * Abstract to handleSeats * Remove console.logs and clean up * New migration file, delete on cascade * Check if attendee is already a part of the booking * Move deleting booking logic to `handleSeats` * When owner reschedule, move whole booking * Prevent owner from rescheduling if not enough seats * Add owner reschedule * Send reschedule email when moving to new timeslot * Add event data to reschedule email for seats * Remove DB changes from event manager * When a booking has no attendees then delete * Update calendar when merging bookings * Move both attendees and seat references when merging * Remove guest list from seats booking page * Update original booking when moving an attendee * Delete calendar and video events if no more attendees * Update or delete integrations when attendees cancel * Show no longer attendee if a single attendee cancels * Change booking to accepted if an attendee books on an empty booking * If booking in same slot then just return the booking * Clean up * Clean up * Remove booking select * Typos --------- Co-authored-by: zomars <zomars@me.com> * Fix migration table name * Add missing trpc import * Rename bookingSeatReferences to bookingSeat * Change relationship between Attendee & BookingSeat to one to one * Fix some merge conflicts * Minor merge artifact fixup * Add the right 'Person' type * Check on email, less (although still) editable than name * Removed calEvent.attendeeUniqueId * rename referenceUId -> referenceUid * Squashes migrations * Run cached installs Should still be faster. Ensures prisma client is up to date. * Solve attendee form on booking page * Remove unused code * Some type fixes * Squash migrations * Type fixes * Fix for reschedule/[uid] redirect * Fix e2e test * Solve double declaration of host * Solve lint errors * Drop constraint only if exists * Renamed UId to Uid * Explicit vs. implicit * Attempt to work around text flakiness by adding a little break between animations * Various bugfixes * Persistently apply seatReferenceUid (#7545) * Persistently apply seatReferenceUid * Small ts fix * Setup guards correctly * Type fixes * Fix render 0 in conditional * Test refactoring * Fix type on handleSeats * Fix handle seats conditional * Fix type inference * Update packages/features/bookings/lib/handleNewBooking.ts * Update apps/web/components/booking/pages/BookingPage.tsx * Fix type and missing logic for reschedule * Fix delete of calendar event and booking * Add handleSeats return type * Fix seats booking creation * Fall through normal booking for initial booking, handleSeats for secondary/reschedule * Simplification of fetching booking * Enable seats for round-robin events * A lot harder than I expected * ignore-owner-if-seat-reference-given * Return seatReferenceUid when second seat * negate userIsOwner * Fix booking seats with a link without bookingUid * Needed a time check otherwise the attendee will be in the older booking * Can't open dialog twice in test.. * Allow passing the booking ID from the server * Fixed isCancelled check, fixed test * Delete through cascade instead of multiple deletes --------- Co-authored-by: Joe Au-Yeung <j.auyeung419@gmail.com> Co-authored-by: Peer Richelsen <peer@cal.com> Co-authored-by: zomars <zomars@me.com> Co-authored-by: Joe Au-Yeung <65426560+joeauyeung@users.noreply.github.com> Co-authored-by: Alex van Andel <me@alexvanandel.com> Co-authored-by: Efraín Rochín <roae.85@gmail.com> Co-authored-by: Peer Richelsen <peeroke@gmail.com>
444 lines
13 KiB
TypeScript
444 lines
13 KiB
TypeScript
import { EventTypeCustomInputType } from "@prisma/client";
|
|
import type { UnitTypeLongPlural } from "dayjs";
|
|
import z, { ZodNullable, ZodObject, ZodOptional } from "zod";
|
|
|
|
/* eslint-disable no-underscore-dangle */
|
|
import type {
|
|
objectInputType,
|
|
objectOutputType,
|
|
ZodNullableDef,
|
|
ZodOptionalDef,
|
|
ZodRawShape,
|
|
ZodTypeAny,
|
|
} from "zod";
|
|
|
|
import { appDataSchemas } from "@calcom/app-store/apps.schemas.generated";
|
|
import dayjs from "@calcom/dayjs";
|
|
import { fieldsSchema as formBuilderFieldsSchema } from "@calcom/features/form-builder/FormBuilderFieldsSchema";
|
|
import { slugify } from "@calcom/lib/slugify";
|
|
|
|
// Let's not import 118kb just to get an enum
|
|
export enum Frequency {
|
|
YEARLY = 0,
|
|
MONTHLY = 1,
|
|
WEEKLY = 2,
|
|
DAILY = 3,
|
|
HOURLY = 4,
|
|
MINUTELY = 5,
|
|
SECONDLY = 6,
|
|
}
|
|
|
|
export const RequiresConfirmationThresholdUnits: z.ZodType<UnitTypeLongPlural> = z.enum(["hours", "minutes"]);
|
|
|
|
export const EventTypeMetaDataSchema = z
|
|
.object({
|
|
smartContractAddress: z.string().optional(),
|
|
blockchainId: z.number().optional(),
|
|
multipleDuration: z.number().array().optional(),
|
|
giphyThankYouPage: z.string().optional(),
|
|
apps: z.object(appDataSchemas).partial().optional(),
|
|
additionalNotesRequired: z.boolean().optional(),
|
|
disableSuccessPage: z.boolean().optional(),
|
|
requiresConfirmationThreshold: z
|
|
.object({
|
|
time: z.number(),
|
|
unit: RequiresConfirmationThresholdUnits,
|
|
})
|
|
.optional(),
|
|
config: z
|
|
.object({
|
|
useHostSchedulesForTeamEvent: z.boolean().optional(),
|
|
})
|
|
.optional(),
|
|
})
|
|
.nullable();
|
|
|
|
export const eventTypeBookingFields = formBuilderFieldsSchema;
|
|
export const BookingFieldType = eventTypeBookingFields.element.shape.type.Enum;
|
|
export type BookingFieldType = typeof BookingFieldType extends z.Values<infer T> ? T[number] : never;
|
|
|
|
// Validation of user added bookingFields' responses happen using `getBookingResponsesSchema` which requires `eventType`.
|
|
// So it is a dynamic validation and thus entire validation can't exist here
|
|
export const bookingResponses = z
|
|
.object({
|
|
email: z.string(),
|
|
name: z.string(),
|
|
guests: z.array(z.string()).optional(),
|
|
notes: z.string().optional(),
|
|
location: z
|
|
.object({
|
|
optionValue: z.string(),
|
|
value: z.string(),
|
|
})
|
|
.optional(),
|
|
smsReminderNumber: z.string().optional(),
|
|
rescheduleReason: z.string().optional(),
|
|
})
|
|
.nullable();
|
|
|
|
export const eventTypeLocations = z.array(
|
|
z.object({
|
|
// TODO: Couldn't find a way to make it a union of types from App Store locations
|
|
// Creating a dynamic union by iterating over the object doesn't seem to make TS happy
|
|
type: z.string(),
|
|
address: z.string().optional(),
|
|
link: z.string().url().optional(),
|
|
displayLocationPublicly: z.boolean().optional(),
|
|
hostPhoneNumber: z.string().optional(),
|
|
})
|
|
);
|
|
|
|
// Matching RRule.Options: rrule/dist/esm/src/types.d.ts
|
|
export const recurringEventType = z
|
|
.object({
|
|
dtstart: z.date().optional(),
|
|
interval: z.number(),
|
|
count: z.number(),
|
|
freq: z.nativeEnum(Frequency),
|
|
until: z.date().optional(),
|
|
tzid: z.string().optional(),
|
|
})
|
|
.nullable();
|
|
|
|
// dayjs iso parsing is very buggy - cant use :( - turns ISO string into Date object
|
|
export const iso8601 = z.string().transform((val, ctx) => {
|
|
const time = Date.parse(val);
|
|
if (!time) {
|
|
ctx.addIssue({
|
|
code: z.ZodIssueCode.custom,
|
|
message: "Invalid ISO Date",
|
|
});
|
|
}
|
|
const d = new Date();
|
|
d.setTime(time);
|
|
return d;
|
|
});
|
|
|
|
export const intervalLimitsType = z
|
|
.object({
|
|
PER_DAY: z.number().optional(),
|
|
PER_WEEK: z.number().optional(),
|
|
PER_MONTH: z.number().optional(),
|
|
PER_YEAR: z.number().optional(),
|
|
})
|
|
.nullable();
|
|
|
|
export const eventTypeSlug = z.string().transform((val) => slugify(val.trim()));
|
|
|
|
export const stringToDate = z.string().transform((a) => new Date(a));
|
|
|
|
export const stringOrNumber = z.union([
|
|
z.string().transform((v, ctx) => {
|
|
const parsed = parseInt(v);
|
|
if (isNaN(parsed)) {
|
|
ctx.addIssue({
|
|
code: z.ZodIssueCode.custom,
|
|
message: "Not a number",
|
|
});
|
|
}
|
|
return parsed;
|
|
}),
|
|
z.number().int(),
|
|
]);
|
|
|
|
export const stringToDayjs = z.string().transform((val) => dayjs(val));
|
|
|
|
export const bookingCreateBodySchema = z.object({
|
|
end: z.string(),
|
|
eventTypeId: z.number(),
|
|
eventTypeSlug: z.string().optional(),
|
|
rescheduleUid: z.string().optional(),
|
|
recurringEventId: z.string().optional(),
|
|
start: z.string(),
|
|
timeZone: z.string(),
|
|
user: z.union([z.string(), z.array(z.string())]).optional(),
|
|
language: z.string(),
|
|
bookingUid: z.string().optional(),
|
|
metadata: z.record(z.string()),
|
|
hasHashedBookingLink: z.boolean().optional(),
|
|
hashedLink: z.string().nullish(),
|
|
ethSignature: z.string().optional(),
|
|
seatReferenceUid: z.string().optional(),
|
|
});
|
|
|
|
export const requiredCustomInputSchema = z.union([
|
|
// string must be given & nonempty
|
|
z.string().trim().min(1),
|
|
// boolean must be true if set.
|
|
z.boolean().refine((v) => v === true),
|
|
]);
|
|
|
|
export type BookingCreateBody = z.input<typeof bookingCreateBodySchema>;
|
|
|
|
export const bookingConfirmPatchBodySchema = z.object({
|
|
bookingId: z.number(),
|
|
confirmed: z.boolean(),
|
|
recurringEventId: z.string().optional(),
|
|
reason: z.string().optional(),
|
|
});
|
|
|
|
// `responses` is merged with it during handleNewBooking call because `responses` schema is dynamic and depends on eventType
|
|
export const extendedBookingCreateBody = bookingCreateBodySchema.merge(
|
|
z.object({
|
|
noEmail: z.boolean().optional(),
|
|
recurringCount: z.number().optional(),
|
|
allRecurringDates: z.string().array().optional(),
|
|
currentRecurringIndex: z.number().optional(),
|
|
appsStatus: z
|
|
.array(
|
|
z.object({
|
|
appName: z.string(),
|
|
success: z.number(),
|
|
failures: z.number(),
|
|
type: z.string(),
|
|
errors: z.string().array(),
|
|
warnings: z.string().array().optional(),
|
|
})
|
|
)
|
|
.optional(),
|
|
})
|
|
);
|
|
|
|
// It has only the legacy props that are part of `responses` now. The API can still hit old props
|
|
export const bookingCreateSchemaLegacyPropsForApi = z.object({
|
|
email: z.string(),
|
|
name: z.string(),
|
|
guests: z.array(z.string()).optional(),
|
|
notes: z.string().optional(),
|
|
location: z.string(),
|
|
smsReminderNumber: z.string().optional().nullable(),
|
|
rescheduleReason: z.string().optional(),
|
|
customInputs: z.array(z.object({ label: z.string(), value: z.union([z.string(), z.boolean()]) })),
|
|
});
|
|
|
|
// This is the schema that is used for the API. It has all the legacy props that are part of `responses` now.
|
|
export const bookingCreateBodySchemaForApi = extendedBookingCreateBody.merge(
|
|
bookingCreateSchemaLegacyPropsForApi
|
|
);
|
|
|
|
export const schemaBookingCancelParams = z.object({
|
|
id: z.number().optional(),
|
|
uid: z.string().optional(),
|
|
allRemainingBookings: z.boolean().optional(),
|
|
cancellationReason: z.string().optional(),
|
|
seatReferenceUid: z.string().optional(),
|
|
});
|
|
|
|
export const vitalSettingsUpdateSchema = z.object({
|
|
connected: z.boolean().optional(),
|
|
selectedParam: z.string().optional(),
|
|
sleepValue: z.number().optional(),
|
|
});
|
|
|
|
export const createdEventSchema = z
|
|
.object({
|
|
id: z.string(),
|
|
password: z.union([z.string(), z.undefined()]),
|
|
onlineMeetingUrl: z.string().nullable(),
|
|
})
|
|
.passthrough();
|
|
|
|
export const userMetadata = z
|
|
.object({
|
|
proPaidForByTeamId: z.number().optional(),
|
|
stripeCustomerId: z.string().optional(),
|
|
vitalSettings: vitalSettingsUpdateSchema.optional(),
|
|
isPremium: z.boolean().optional(),
|
|
sessionTimeout: z.number().optional(), // Minutes
|
|
defaultConferencingApp: z
|
|
.object({
|
|
appSlug: z.string().default("daily-video").optional(),
|
|
appLink: z.string().optional(),
|
|
})
|
|
.optional(),
|
|
})
|
|
.nullable();
|
|
|
|
export const teamMetadataSchema = z
|
|
.object({
|
|
requestedSlug: z.string(),
|
|
paymentId: z.string(),
|
|
subscriptionId: z.string().nullable(),
|
|
subscriptionItemId: z.string().nullable(),
|
|
})
|
|
.partial()
|
|
.nullable();
|
|
|
|
export const bookingMetadataSchema = z
|
|
.object({
|
|
videoCallUrl: z.string().optional(),
|
|
})
|
|
.and(z.record(z.string()))
|
|
.nullable();
|
|
|
|
export const customInputOptionSchema = z.array(
|
|
z.object({
|
|
label: z.string(),
|
|
type: z.string(),
|
|
})
|
|
);
|
|
|
|
export const customInputSchema = z.object({
|
|
id: z.number(),
|
|
eventTypeId: z.number(),
|
|
label: z.string(),
|
|
type: z.nativeEnum(EventTypeCustomInputType),
|
|
options: customInputOptionSchema.optional().nullable(),
|
|
required: z.boolean(),
|
|
placeholder: z.string(),
|
|
hasToBeCreated: z.boolean().optional(),
|
|
});
|
|
|
|
export type CustomInputSchema = z.infer<typeof customInputSchema>;
|
|
|
|
export const recordingItemSchema = z.object({
|
|
id: z.string(),
|
|
room_name: z.string(),
|
|
start_ts: z.number(),
|
|
status: z.string(),
|
|
max_participants: z.number(),
|
|
duration: z.number(),
|
|
share_token: z.string(),
|
|
});
|
|
|
|
export const recordingItemsSchema = z.array(recordingItemSchema);
|
|
|
|
export type RecordingItemSchema = z.infer<typeof recordingItemSchema>;
|
|
|
|
export const getRecordingsResponseSchema = z.union([
|
|
z.object({
|
|
total_count: z.number(),
|
|
data: recordingItemsSchema,
|
|
}),
|
|
z.object({}),
|
|
]);
|
|
|
|
export type GetRecordingsResponseSchema = z.infer<typeof getRecordingsResponseSchema>;
|
|
|
|
/**
|
|
* Ensures that it is a valid HTTP URL
|
|
* It automatically avoids
|
|
* - XSS attempts through javascript:alert('hi')
|
|
* - mailto: links
|
|
*/
|
|
export const successRedirectUrl = z
|
|
.union([
|
|
z.literal(""),
|
|
z
|
|
.string()
|
|
.url()
|
|
.regex(/^http(s)?:\/\/.*/),
|
|
])
|
|
.optional();
|
|
|
|
export const RoutingFormSettings = z
|
|
.object({
|
|
emailOwnerOnSubmission: z.boolean(),
|
|
})
|
|
.nullable();
|
|
|
|
export const DeploymentTheme = z
|
|
.object({
|
|
brand: z.string().default("#292929"),
|
|
textBrand: z.string().default("#ffffff"),
|
|
darkBrand: z.string().default("#fafafa"),
|
|
textDarkBrand: z.string().default("#292929"),
|
|
bookingHighlight: z.string().default("#10B981"),
|
|
bookingLightest: z.string().default("#E1E1E1"),
|
|
bookingLighter: z.string().default("#ACACAC"),
|
|
bookingLight: z.string().default("#888888"),
|
|
bookingMedian: z.string().default("#494949"),
|
|
bookingDark: z.string().default("#313131"),
|
|
bookingDarker: z.string().default("#292929"),
|
|
fontName: z.string().default("Cal Sans"),
|
|
fontSrc: z.string().default("https://cal.com/cal.ttf"),
|
|
})
|
|
.optional();
|
|
|
|
export type ZodDenullish<T extends ZodTypeAny> = T extends ZodNullable<infer U> | ZodOptional<infer U>
|
|
? ZodDenullish<U>
|
|
: T;
|
|
|
|
export type ZodDenullishShape<T extends ZodRawShape> = {
|
|
[k in keyof T]: ZodDenullish<T[k]>;
|
|
};
|
|
|
|
export const denullish = <T extends ZodTypeAny>(schema: T): ZodDenullish<T> =>
|
|
(schema instanceof ZodNullable || schema instanceof ZodOptional
|
|
? denullish((schema._def as ZodNullableDef | ZodOptionalDef).innerType)
|
|
: schema) as ZodDenullish<T>;
|
|
|
|
type UnknownKeysParam = "passthrough" | "strict" | "strip";
|
|
|
|
/**
|
|
* @see https://github.com/3x071c/lsg-remix/blob/e2a9592ba3ec5103556f2cf307c32f08aeaee32d/app/lib/util/zod.ts
|
|
*/
|
|
export function denullishShape<
|
|
T extends ZodRawShape,
|
|
UnknownKeys extends UnknownKeysParam = "strip",
|
|
Catchall extends ZodTypeAny = ZodTypeAny,
|
|
Output = objectOutputType<T, Catchall>,
|
|
Input = objectInputType<T, Catchall>
|
|
>(
|
|
obj: ZodObject<T, UnknownKeys, Catchall, Output, Input>
|
|
): ZodObject<ZodDenullishShape<T>, UnknownKeys, Catchall> {
|
|
const a = entries(obj.shape).map(([field, schema]) => [field, denullish(schema)] as const) as {
|
|
[K in keyof T]: [K, ZodDenullish<T[K]>];
|
|
}[keyof T][];
|
|
return new ZodObject({
|
|
...obj._def,
|
|
shape: () => fromEntries(a) as unknown as ZodDenullishShape<T>, // TODO: Safely assert type
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Like Object.entries, but with actually useful typings
|
|
* @param obj The object to turn into a tuple array (`[key, value][]`)
|
|
* @returns The constructed tuple array from the given object
|
|
* @see https://github.com/3x071c/lsg-remix/blob/e2a9592ba3ec5103556f2cf307c32f08aeaee32d/app/lib/util/entries.ts
|
|
*/
|
|
export const entries = <O extends Record<string, unknown>>(
|
|
obj: O
|
|
): {
|
|
readonly [K in keyof O]: [K, O[K]];
|
|
}[keyof O][] => {
|
|
return Object.entries(obj) as {
|
|
[K in keyof O]: [K, O[K]];
|
|
}[keyof O][];
|
|
};
|
|
|
|
/**
|
|
* Returns a type with all readonly notations removed (traverses recursively on an object)
|
|
*/
|
|
type DeepWriteable<T> = T extends Readonly<{
|
|
-readonly [K in keyof T]: T[K];
|
|
}>
|
|
? {
|
|
-readonly [K in keyof T]: DeepWriteable<T[K]>;
|
|
}
|
|
: T; /* Make it work with readonly types (this is not strictly necessary) */
|
|
|
|
type FromEntries<T> = T extends [infer Keys, unknown][]
|
|
? { [K in Keys & PropertyKey]: Extract<T[number], [K, unknown]>[1] }
|
|
: never;
|
|
|
|
/**
|
|
* Like Object.fromEntries, but with actually useful typings
|
|
* @param arr The tuple array (`[key, value][]`) to turn into an object
|
|
* @returns Object constructed from the given entries
|
|
* @see https://github.com/3x071c/lsg-remix/blob/e2a9592ba3ec5103556f2cf307c32f08aeaee32d/app/lib/util/fromEntries.ts
|
|
*/
|
|
export const fromEntries = <
|
|
E extends [PropertyKey, unknown][] | ReadonlyArray<readonly [PropertyKey, unknown]>
|
|
>(
|
|
entries: E
|
|
): FromEntries<DeepWriteable<E>> => {
|
|
return Object.fromEntries(entries) as FromEntries<DeepWriteable<E>>;
|
|
};
|
|
|
|
export const getAccessLinkResponseSchema = z.object({
|
|
download_link: z.string().url(),
|
|
});
|
|
|
|
export type GetAccessLinkResponseSchema = z.infer<typeof getAccessLinkResponseSchema>;
|