calendar/packages/trpc/server/routers/viewer/bookings/_router.tsx

import { MembershipRole } from "@calcom/prisma/enums";
import authedProcedure from "../../../procedures/authedProcedure";
import { createTeamPbacProcedure } from "../../../procedures/pbacProcedures";
import publicProcedure from "../../../procedures/publicProcedure";
import { router } from "../../../trpc";
import { ZAddGuestsInputSchema } from "./addGuests.schema";
import { ZConfirmInputSchema } from "./confirm.schema";
import { ZEditLocationInputSchema } from "./editLocation.schema";
import { ZFindInputSchema } from "./find.schema";
import { ZGetInputSchema } from "./get.schema";
import { ZGetBookingAttendeesInputSchema } from "./getBookingAttendees.schema";
import { ZGetBookingDetailsInputSchema } from "./getBookingDetails.schema";
import { ZGetBookingHistoryInputSchema } from "./getBookingHistory.schema";
import { ZGetWrongAssignmentReportsInputSchema } from "./getWrongAssignmentReports.schema";
import { ZHasWrongAssignmentReportInputSchema } from "./hasWrongAssignmentReport.schema";
import { ZReportBookingInputSchema } from "./reportBooking.schema";
import { ZReportWrongAssignmentInputSchema } from "./reportWrongAssignment.schema";
import { ZRequestRescheduleInputSchema } from "./requestReschedule.schema";
import { ZUpdateWrongAssignmentReportStatusInputSchema } from "./updateWrongAssignmentReportStatus.schema";
import { bookingsProcedure } from "./util";

export const bookingsRouter = router({
  get: authedProcedure.input(ZGetInputSchema).query(async ({ input, ctx }) => {
    const { getHandler } = await import("./get.handler");

    return getHandler({
      ctx,
      input,
    });
  }),

  requestReschedule: authedProcedure.input(ZRequestRescheduleInputSchema).mutation(async ({ input, ctx }) => {
    const { requestRescheduleHandler } = await import("./requestReschedule.handler");

    return requestRescheduleHandler({
      ctx,
      input,
      source: "WEBAPP",
    });
  }),

  editLocation: bookingsProcedure.input(ZEditLocationInputSchema).mutation(async ({ input, ctx }) => {
    const { editLocationHandler } = await import("./editLocation.handler");

    return editLocationHandler({
      ctx,
      input,
      actionSource: "WEBAPP",
    });
  }),

  addGuests: authedProcedure.input(ZAddGuestsInputSchema).mutation(async ({ input, ctx }) => {
    const { addGuestsHandler } = await import("./addGuests.handler");

    return addGuestsHandler({
      ctx,
      input,
      actionSource: "WEBAPP",
    });
  }),

  confirm: authedProcedure.input(ZConfirmInputSchema).mutation(async ({ input, ctx }) => {
    const { confirmHandler } = await import("./confirm.handler");

    return confirmHandler({
      ctx,
      input,
    });
  }),

  getBookingAttendees: authedProcedure
    .input(ZGetBookingAttendeesInputSchema)
    .query(async ({ input, ctx }) => {
      const { getBookingAttendeesHandler } = await import("./getBookingAttendees.handler");

      return getBookingAttendeesHandler({
        ctx,
        input,
      });
    }),

  getBookingDetails: authedProcedure.input(ZGetBookingDetailsInputSchema).query(async ({ input, ctx }) => {
    const { getBookingDetailsHandler } = await import("./getBookingDetails.handler");

    return getBookingDetailsHandler({
      ctx,
      input,
    });
  }),

  find: publicProcedure.input(ZFindInputSchema).query(async ({ input, ctx }) => {
    const { getHandler } = await import("./find.handler");

    return getHandler({
      ctx,
      input,
    });
  }),

  reportBooking: authedProcedure.input(ZReportBookingInputSchema).mutation(async ({ input, ctx }) => {
    const { reportBookingHandler } = await import("./reportBooking.handler");

    return reportBookingHandler({
      ctx,
      input,
    });
  }),
  reportWrongAssignment: authedProcedure
    .input(ZReportWrongAssignmentInputSchema)
    .mutation(async ({ input, ctx }) => {
      const { reportWrongAssignmentHandler } = await import("./reportWrongAssignment.handler");

      return reportWrongAssignmentHandler({
        ctx,
        input,
      });
    }),
  hasWrongAssignmentReport: authedProcedure
    .input(ZHasWrongAssignmentReportInputSchema)
    .query(async ({ input, ctx }) => {
      const { hasWrongAssignmentReportHandler } = await import("./hasWrongAssignmentReport.handler");

      return hasWrongAssignmentReportHandler({
        ctx,
        input,
      });
    }),
  getBookingHistory: authedProcedure.input(ZGetBookingHistoryInputSchema).query(async ({ input, ctx }) => {
    const { getBookingHistoryHandler } = await import("./getBookingHistory.handler");

    return getBookingHistoryHandler({
      ctx,
      input,
    });
  }),
  getWrongAssignmentReports: createTeamPbacProcedure("booking.readTeamBookings", [
    MembershipRole.ADMIN,
    MembershipRole.OWNER,
    MembershipRole.MEMBER,
  ])
    .input(ZGetWrongAssignmentReportsInputSchema)
    .query(async ({ input }) => {
      const { getWrongAssignmentReportsHandler } = await import("./getWrongAssignmentReports.handler");

      return getWrongAssignmentReportsHandler({
        input,
      });
    }),
  updateWrongAssignmentReportStatus: authedProcedure
    .input(ZUpdateWrongAssignmentReportStatusInputSchema)
    .mutation(async ({ input, ctx }) => {
      const { updateWrongAssignmentReportStatusHandler } = await import(
        "./updateWrongAssignmentReportStatus.handler"
      );

      return updateWrongAssignmentReportStatusHandler({
        ctx,
        input,
      });
    }),
});