Merge branch 'main' into refactor_allow_managed_event_tests_parallel_…

…runs

apps/api/v2/package.json

@@ -25,7 +25,7 @@
  },
  "dependencies": {
  "@calcom/platform-constants": "*",
- "@calcom/platform-libraries": "npm:@calcom/platform-libraries@0.0.27",
+ "@calcom/platform-libraries": "npm:@calcom/platform-libraries@0.0.28",
  "@calcom/platform-libraries-0.0.2": "npm:@calcom/platform-libraries@0.0.2",
  "@calcom/platform-types": "*",
  "@calcom/platform-utils": "*",

apps/api/v2/src/ee/event-types/event-types_2024_06_14/controllers/event-types.controller.e2e-spec.ts

@@ -26,6 +26,7 @@ import {
  EventTypeOutput_2024_06_14,
  UpdateEventTypeInput_2024_06_14,
 } from "@calcom/platform-types";
+import { BookingWindowPeriodInputTypeEnum_2024_06_14 } from "@calcom/platform-types/dist/event-types/event-types_2024_06_14/inputs/enums/booking-window.enum";
 import { SchedulingType } from "@calcom/prisma/enums";
 
 describe("Event types Endpoints", () => {
@@ -214,6 +215,21 @@ describe("Event types Endpoints", () => {
  },
  ],
  scheduleId: firstSchedule.id,
+ bookingLimitsCount: {
+ day: 2,
+ week: 5,
+ },
+ onlyShowFirstAvailableSlot: true,
+ bookingLimitsDuration: {
+ day: 60,
+ week: 100,
+ },
+ offsetStart: 30,
+ bookingWindow: {
+ type: BookingWindowPeriodInputTypeEnum_2024_06_14.calendarDays,
+ value: 30,
+ rolling: true,
+ },
  };
 
  return request(app.getHttpServer())
@@ -232,7 +248,11 @@ describe("Event types Endpoints", () => {
  expect(createdEventType.bookingFields).toEqual(body.bookingFields);
  expect(createdEventType.ownerId).toEqual(user.id);
  expect(createdEventType.scheduleId).toEqual(firstSchedule.id);
-
+ expect(createdEventType.bookingLimitsCount).toEqual(body.bookingLimitsCount);
+ expect(createdEventType.onlyShowFirstAvailableSlot).toEqual(body.onlyShowFirstAvailableSlot);
+ expect(createdEventType.bookingLimitsDuration).toEqual(body.bookingLimitsDuration);
+ expect(createdEventType.offsetStart).toEqual(body.offsetStart);
+ expect(createdEventType.bookingWindow).toEqual(body.bookingWindow);
  eventType = responseBody.data;
  });
  });
@@ -243,6 +263,21 @@ describe("Event types Endpoints", () => {
  const body: UpdateEventTypeInput_2024_06_14 = {
  title: newTitle,
  scheduleId: secondSchedule.id,
+ bookingLimitsCount: {
+ day: 4,
+ week: 10,
+ },
+ onlyShowFirstAvailableSlot: true,
+ bookingLimitsDuration: {
+ day: 100,
+ week: 200,
+ },
+ offsetStart: 50,
+ bookingWindow: {
+ type: BookingWindowPeriodInputTypeEnum_2024_06_14.businessDays,
+ value: 40,
+ rolling: false,
+ },
  };
 
  return request(app.getHttpServer())
@@ -263,9 +298,19 @@ describe("Event types Endpoints", () => {
  expect(updatedEventType.bookingFields).toEqual(eventType.bookingFields);
  expect(updatedEventType.ownerId).toEqual(user.id);
  expect(updatedEventType.scheduleId).toEqual(secondSchedule.id);
+ expect(updatedEventType.bookingLimitsCount).toEqual(body.bookingLimitsCount);
+ expect(updatedEventType.onlyShowFirstAvailableSlot).toEqual(body.onlyShowFirstAvailableSlot);
+ expect(updatedEventType.bookingLimitsDuration).toEqual(body.bookingLimitsDuration);
+ expect(updatedEventType.offsetStart).toEqual(body.offsetStart);
+ expect(updatedEventType.bookingWindow).toEqual(body.bookingWindow);
 
  eventType.title = newTitle;
  eventType.scheduleId = secondSchedule.id;
+ eventType.bookingLimitsCount = updatedEventType.bookingLimitsCount;
+ eventType.onlyShowFirstAvailableSlot = updatedEventType.onlyShowFirstAvailableSlot;
+ eventType.bookingLimitsDuration = updatedEventType.bookingLimitsDuration;
+ eventType.offsetStart = updatedEventType.offsetStart;
+ eventType.bookingWindow = updatedEventType.bookingWindow;
  });
  });
 
@@ -301,6 +346,11 @@ describe("Event types Endpoints", () => {
  expect(fetchedEventType.locations).toEqual(eventType.locations);
  expect(fetchedEventType.bookingFields).toEqual(eventType.bookingFields);
  expect(fetchedEventType.ownerId).toEqual(user.id);
+ expect(fetchedEventType.bookingLimitsCount).toEqual(eventType.bookingLimitsCount);
+ expect(fetchedEventType.onlyShowFirstAvailableSlot).toEqual(eventType.onlyShowFirstAvailableSlot);
+ expect(fetchedEventType.bookingLimitsDuration).toEqual(eventType.bookingLimitsDuration);
+ expect(fetchedEventType.offsetStart).toEqual(eventType.offsetStart);
+ expect(fetchedEventType.bookingWindow).toEqual(eventType.bookingWindow);
  });
 
  it(`/GET/even-types by username`, async () => {
@@ -326,6 +376,11 @@ describe("Event types Endpoints", () => {
  expect(fetchedEventType?.locations).toEqual(eventType.locations);
  expect(fetchedEventType?.bookingFields).toEqual(eventType.bookingFields);
  expect(fetchedEventType?.ownerId).toEqual(user.id);
+ expect(fetchedEventType.bookingLimitsCount).toEqual(eventType.bookingLimitsCount);
+ expect(fetchedEventType.onlyShowFirstAvailableSlot).toEqual(eventType.onlyShowFirstAvailableSlot);
+ expect(fetchedEventType.bookingLimitsDuration).toEqual(eventType.bookingLimitsDuration);
+ expect(fetchedEventType.offsetStart).toEqual(eventType.offsetStart);
+ expect(fetchedEventType.bookingWindow).toEqual(eventType.bookingWindow);
  });
 
  it(`/GET/event-types by username and eventSlug`, async () => {
@@ -346,6 +401,11 @@ describe("Event types Endpoints", () => {
  expect(fetchedEventType?.locations).toEqual(eventType.locations);
  expect(fetchedEventType?.bookingFields).toEqual(eventType.bookingFields);
  expect(fetchedEventType?.ownerId).toEqual(user.id);
+ expect(fetchedEventType.bookingLimitsCount).toEqual(eventType.bookingLimitsCount);
+ expect(fetchedEventType.onlyShowFirstAvailableSlot).toEqual(eventType.onlyShowFirstAvailableSlot);
+ expect(fetchedEventType.bookingLimitsDuration).toEqual(eventType.bookingLimitsDuration);
+ expect(fetchedEventType.offsetStart).toEqual(eventType.offsetStart);
+ expect(fetchedEventType.bookingWindow).toEqual(eventType.bookingWindow);
  });
 
  it(`/GET/:id not existing`, async () => {

apps/api/v2/src/ee/event-types/event-types_2024_06_14/event-types.repository.ts

@@ -13,7 +13,18 @@ import type { PrismaClient } from "@calcom/prisma";
 
 type InputEventTransformed = Omit<
  CreateEventTypeInput_2024_06_14,
- "lengthInMinutes" | "locations" | "bookingFields"
+ | "lengthInMinutes"
+ | "locations"
+ | "bookingFields"
+ | "bookingLimitsCount"
+ | "onlyShowFirstAvailableSlot"
+ | "bookingLimitsDuration"
+ | "offsetStart"
+ | "periodType"
+ | "periodDays"
+ | "periodCountCalendarDays"
+ | "periodStartDate"
+ | "periodEndDate"
 > & {
  length: number;
  slug: string;

apps/api/v2/src/ee/event-types/event-types_2024_06_14/services/event-types.service.ts

@@ -38,7 +38,16 @@ export class EventTypesService_2024_06_14 {
  async createUserEventType(user: UserWithProfile, body: CreateEventTypeInput_2024_06_14) {
  await this.checkCanCreateEventType(user.id, body);
  const eventTypeUser = await this.getUserToCreateEvent(user);
- const bodyTransformed = this.inputEventTypesService.transformInputCreateEventType(body);
+ const {
+ bookingLimits,
+ durationLimits,
+ periodType = undefined,
+ periodDays = undefined,
+ periodCountCalendarDays = undefined,
+ periodStartDate = undefined,
+ periodEndDate = undefined,
+ ...bodyTransformed
+ } = this.inputEventTypesService.transformInputCreateEventType(body);
  const { eventType: eventTypeCreated } = await createEventType({
  input: bodyTransformed,
  ctx: {
@@ -49,6 +58,26 @@ export class EventTypesService_2024_06_14 {
  },
  });
 
+ await updateEventType({
+ input: {
+ id: eventTypeCreated.id,
+ bookingLimits,
+ durationLimits,
+ periodType,
+ periodDays,
+ periodCountCalendarDays,
+ periodStartDate,
+ periodEndDate,
+ ...bodyTransformed,
+ },
+ ctx: {
+ user: eventTypeUser,
+ // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+ // @ts-ignore
+ prisma: this.dbWrite.prisma,
+ },
+ });
+
  const eventType = await this.eventTypesRepository.getEventTypeById(eventTypeCreated.id);
 
  if (!eventType) {
@@ -95,13 +124,16 @@ export class EventTypesService_2024_06_14 {
  ? await this.membershipsRepository.isUserOrganizationAdmin(user.id, organizationId)
  : false;
  const profileId = user.movedToProfile?.id || null;
+ const selectedCalendars = await this.selectedCalendarsRepository.getUserSelectedCalendars(user.id);
  return {
  id: user.id,
  role: user.role,
+ username: user.username,
  organizationId: user.organizationId,
  organization: { isOrgAdmin },
  profile: { id: profileId },
  metadata: user.metadata,
+ selectedCalendars,
  };
  }
 

apps/api/v2/src/ee/event-types/event-types_2024_06_14/services/input-event-types.service.ts

@@ -3,6 +3,8 @@ import { Injectable } from "@nestjs/common";
 import {
  transformApiEventTypeBookingFields,
  transformApiEventTypeLocations,
+ transformApiEventTypeIntervalLimits,
+ transformApiEventTypeFutureBookingLimits,
 } from "@calcom/platform-libraries";
 import { CreateEventTypeInput_2024_06_14, UpdateEventTypeInput_2024_06_14 } from "@calcom/platform-types";
 
@@ -16,27 +18,54 @@ export class InputEventTypesService_2024_06_14 {
  },
  ];
 
- const { lengthInMinutes, locations, bookingFields, ...rest } = inputEventType;
+ const {
+ lengthInMinutes,
+ locations,
+ bookingFields,
+ bookingLimitsCount,
+ bookingLimitsDuration,
+ bookingWindow,
+ ...rest
+ } = inputEventType;
 
  const eventType = {
  ...rest,
  length: lengthInMinutes,
  locations: this.transformInputLocations(locations || defaultLocations),
  bookingFields: this.transformInputBookingFields(bookingFields),
+ bookingLimits: bookingLimitsCount ? this.transformInputIntervalLimits(bookingLimitsCount) : undefined,
+ durationLimits: bookingLimitsDuration
+ ? this.transformInputIntervalLimits(bookingLimitsDuration)
+ : undefined,
+ ...this.transformInputBookingWindow(bookingWindow),
  };
 
  return eventType;
  }
 
  transformInputUpdateEventType(inputEventType: UpdateEventTypeInput_2024_06_14) {
- const { lengthInMinutes, locations, bookingFields, scheduleId, ...rest } = inputEventType;
+ const {
+ lengthInMinutes,
+ locations,
+ bookingFields,
+ scheduleId,
+ bookingLimitsCount,
+ bookingLimitsDuration,
+ bookingWindow,
+ ...rest
+ } = inputEventType;
 
  const eventType = {
  ...rest,
  length: lengthInMinutes,
  locations: locations ? this.transformInputLocations(locations) : undefined,
  bookingFields: bookingFields ? this.transformInputBookingFields(bookingFields) : undefined,
  schedule: scheduleId,
+ bookingLimits: bookingLimitsCount ? this.transformInputIntervalLimits(bookingLimitsCount) : undefined,
+ durationLimits: bookingLimitsDuration
+ ? this.transformInputIntervalLimits(bookingLimitsDuration)
+ : undefined,
+ ...this.transformInputBookingWindow(bookingWindow),
  };
 
  return eventType;
@@ -49,4 +78,13 @@ export class InputEventTypesService_2024_06_14 {
  transformInputBookingFields(inputBookingFields: CreateEventTypeInput_2024_06_14["bookingFields"]) {
  return transformApiEventTypeBookingFields(inputBookingFields);
  }
+
+ transformInputIntervalLimits(inputBookingFields: CreateEventTypeInput_2024_06_14["bookingLimitsCount"]) {
+ return transformApiEventTypeIntervalLimits(inputBookingFields);
+ }
+
+ transformInputBookingWindow(inputBookingWindow: CreateEventTypeInput_2024_06_14["bookingWindow"]) {
+ const res = transformApiEventTypeFutureBookingLimits(inputBookingWindow);
+ return !!res ? res : {};
+ }
 }

apps/api/v2/src/ee/event-types/event-types_2024_06_14/services/output-event-types.service.ts

@@ -11,7 +11,11 @@ import {
  BookingFieldsSchema,
  SystemField,
  UserField,
+ parseBookingLimit,
+ getResponseEventTypeIntervalLimits,
+ getResponseEventTypeFutureBookingLimits,
 } from "@calcom/platform-libraries";
+import { TransformFutureBookingsLimitSchema_2024_06_14 } from "@calcom/platform-types";
 
 type EventTypeRelations = { users: User[]; schedule: Schedule | null };
 type DatabaseEventType = EventType & EventTypeRelations;
@@ -44,6 +48,15 @@ type Input = Pick<
  | "metadata"
  | "users"
  | "scheduleId"
+ | "bookingLimits"
+ | "durationLimits"
+ | "onlyShowFirstAvailableSlot"
+ | "offsetStart"
+ | "periodType"
+ | "periodDays"
+ | "periodCountCalendarDays"
+ | "periodStartDate"
+ | "periodEndDate"
 >;
 
 @Injectable()
@@ -71,6 +84,8 @@ export class OutputEventTypesService_2024_06_14 {
  seatsShowAvailabilityCount,
  isInstantEvent,
  scheduleId,
+ onlyShowFirstAvailableSlot,
+ offsetStart,
  } = databaseEventType;
 
  const locations = this.transformLocations(databaseEventType.locations);
@@ -80,6 +95,15 @@ export class OutputEventTypesService_2024_06_14 {
  const recurringEvent = this.transformRecurringEvent(databaseEventType.recurringEvent);
  const metadata = this.transformMetadata(databaseEventType.metadata) || {};
  const users = this.transformUsers(databaseEventType.users);
+ const bookingLimitsCount = this.transformIntervalLimits(databaseEventType.bookingLimits);
+ const bookingLimitsDuration = this.transformIntervalLimits(databaseEventType.durationLimits);
+ const bookingWindow = this.transformBookingWindow({
+ periodType: databaseEventType.periodType,
+ periodDays: databaseEventType.periodDays,
+ periodCountCalendarDays: databaseEventType.periodCountCalendarDays,
+ periodStartDate: databaseEventType.periodStartDate,
+ periodEndDate: databaseEventType.periodEndDate,
+ } as TransformFutureBookingsLimitSchema_2024_06_14);
 
  return {
  id,
@@ -109,6 +133,11 @@ export class OutputEventTypesService_2024_06_14 {
  isInstantEvent,
  users,
  scheduleId,
+ bookingLimitsCount,
+ bookingLimitsDuration,
+ onlyShowFirstAvailableSlot,
+ offsetStart,
+ bookingWindow,
  };
  }
 
@@ -148,4 +177,13 @@ export class OutputEventTypesService_2024_06_14 {
  };
  });
  }
+
+ transformIntervalLimits(bookingLimits: any) {
+ const bookingLimitsParsed = parseBookingLimit(bookingLimits);
+ return getResponseEventTypeIntervalLimits(bookingLimitsParsed);
+ }
+
+ transformBookingWindow(bookingLimits: TransformFutureBookingsLimitSchema_2024_06_14) {
+ return getResponseEventTypeFutureBookingLimits(bookingLimits);
+ }
 }

apps/api/v2/src/ee/me/me.controller.ts

@@ -7,6 +7,7 @@ import { Permissions } from "@/modules/auth/decorators/permissions/permissions.d
 import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
 import { PermissionsGuard } from "@/modules/auth/guards/permissions/permissions.guard";
 import { UpdateManagedUserInput } from "@/modules/users/inputs/update-managed-user.input";
+import { UsersService } from "@/modules/users/services/users.service";
 import { UserWithProfile, UsersRepository } from "@/modules/users/users.repository";
 import { Controller, UseGuards, Get, Patch, Body } from "@nestjs/common";
 import { ApiTags as DocsTags } from "@nestjs/swagger";
@@ -23,13 +24,14 @@ import { userSchemaResponse } from "@calcom/platform-types";
 export class MeController {
  constructor(
  private readonly usersRepository: UsersRepository,
- private readonly schedulesService: SchedulesService_2024_04_15
+ private readonly schedulesService: SchedulesService_2024_04_15,
+ private readonly usersService: UsersService
  ) {}
 
  @Get("/")
  @Permissions([PROFILE_READ])
  async getMe(@GetUser() user: UserWithProfile): Promise<GetMeOutput> {
- const organization = user?.movedToProfile?.organization;
+ const organization = this.usersService.getUserMainProfile(user)?.organization;
  const me = userSchemaResponse.parse(
  organization
  ? {