first commit

calcom/apps/web/pages/api/cron/bookingReminder.ts

@@ -0,0 +1,146 @@
+import type { NextApiRequest, NextApiResponse } from "next";
+
+import dayjs from "@calcom/dayjs";
+import { sendOrganizerRequestReminderEmail } from "@calcom/emails";
+import { getCalEventResponses } from "@calcom/features/bookings/lib/getCalEventResponses";
+import { isPrismaObjOrUndefined, parseRecurringEvent } from "@calcom/lib";
+import { getTranslation } from "@calcom/lib/server/i18n";
+import prisma, { bookingMinimalSelect } from "@calcom/prisma";
+import { BookingStatus, ReminderType } from "@calcom/prisma/enums";
+import type { CalendarEvent } from "@calcom/types/Calendar";
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  const apiKey = req.headers.authorization || req.query.apiKey;
+  if (process.env.CRON_API_KEY !== apiKey) {
+    res.status(401).json({ message: "Not authenticated" });
+    return;
+  }
+  if (req.method !== "POST") {
+    res.status(405).json({ message: "Invalid method" });
+    return;
+  }
+
+  const reminderIntervalMinutes = [48 * 60, 24 * 60, 3 * 60];
+  let notificationsSent = 0;
+  for (const interval of reminderIntervalMinutes) {
+    const bookings = await prisma.booking.findMany({
+      where: {
+        status: BookingStatus.PENDING,
+        createdAt: {
+          lte: dayjs().add(-interval, "minutes").toDate(),
+        },
+        // Only send reminders if the event hasn't finished
+        endTime: { gte: new Date() },
+        OR: [
+          // no payment required
+          {
+            payment: { none: {} },
+          },
+          // paid but awaiting approval
+          {
+            payment: { some: {} },
+            paid: true,
+          },
+        ],
+      },
+      select: {
+        ...bookingMinimalSelect,
+        location: true,
+        user: {
+          select: {
+            id: true,
+            email: true,
+            name: true,
+            username: true,
+            locale: true,
+            timeZone: true,
+            destinationCalendar: true,
+          },
+        },
+        eventType: {
+          select: {
+            recurringEvent: true,
+            bookingFields: true,
+          },
+        },
+        responses: true,
+        uid: true,
+        destinationCalendar: true,
+      },
+    });
+
+    const reminders = await prisma.reminderMail.findMany({
+      where: {
+        reminderType: ReminderType.PENDING_BOOKING_CONFIRMATION,
+        referenceId: {
+          in: bookings.map((b) => b.id),
+        },
+        elapsedMinutes: {
+          gte: interval,
+        },
+      },
+    });
+
+    for (const booking of bookings.filter((b) => !reminders.some((r) => r.referenceId == b.id))) {
+      const { user } = booking;
+      const name = user?.name || user?.username;
+      if (!user || !name || !user.timeZone) {
+        console.error(`Booking ${booking.id} is missing required properties for booking reminder`, { user });
+        continue;
+      }
+
+      const tOrganizer = await getTranslation(user.locale ?? "en", "common");
+
+      const attendeesListPromises = booking.attendees.map(async (attendee) => {
+        return {
+          name: attendee.name,
+          email: attendee.email,
+          timeZone: attendee.timeZone,
+          language: {
+            translate: await getTranslation(attendee.locale ?? "en", "common"),
+            locale: attendee.locale ?? "en",
+          },
+        };
+      });
+
+      const attendeesList = await Promise.all(attendeesListPromises);
+      const selectedDestinationCalendar = booking.destinationCalendar || user.destinationCalendar;
+      const evt: CalendarEvent = {
+        type: booking.title,
+        title: booking.title,
+        description: booking.description || undefined,
+        customInputs: isPrismaObjOrUndefined(booking.customInputs),
+        ...getCalEventResponses({
+          bookingFields: booking.eventType?.bookingFields ?? null,
+          booking,
+        }),
+        location: booking.location ?? "",
+        startTime: booking.startTime.toISOString(),
+        endTime: booking.endTime.toISOString(),
+        organizer: {
+          id: user.id,
+          email: booking?.userPrimaryEmail ?? user.email,
+          name,
+          timeZone: user.timeZone,
+          language: { translate: tOrganizer, locale: user.locale ?? "en" },
+        },
+        attendees: attendeesList,
+        uid: booking.uid,
+        recurringEvent: parseRecurringEvent(booking.eventType?.recurringEvent),
+        destinationCalendar: selectedDestinationCalendar ? [selectedDestinationCalendar] : [],
+      };
+
+      await sendOrganizerRequestReminderEmail(evt);
+
+      await prisma.reminderMail.create({
+        data: {
+          referenceId: booking.id,
+          reminderType: ReminderType.PENDING_BOOKING_CONFIRMATION,
+          elapsedMinutes: interval,
+        },
+      });
+      notificationsSent++;
+    }
+  }
+  res.status(200).json({ notificationsSent });
+}

calcom/apps/web/pages/api/cron/calendar-cache-cleanup.ts

@@ -0,0 +1,16 @@
+import type { NextApiRequest, NextApiResponse } from "next";
+
+import prisma from "@calcom/prisma";
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  const deleted = await prisma.calendarCache.deleteMany({
+    where: {
+      // Delete all cache entries that expired before now
+      expiresAt: {
+        lte: new Date(Date.now()),
+      },
+    },
+  });
+
+  res.json({ ok: true, count: deleted.count });
+}

calcom/apps/web/pages/api/cron/changeTimeZone.ts

@@ -0,0 +1,173 @@
+import type { NextApiRequest, NextApiResponse } from "next";
+
+import dayjs from "@calcom/dayjs";
+import prisma from "@calcom/prisma";
+import { getDefaultScheduleId } from "@calcom/trpc/server/routers/viewer/availability/util";
+
+const travelScheduleSelect = {
+  id: true,
+  startDate: true,
+  endDate: true,
+  timeZone: true,
+  prevTimeZone: true,
+  user: {
+    select: {
+      id: true,
+      timeZone: true,
+      defaultScheduleId: true,
+    },
+  },
+};
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  const apiKey = req.headers.authorization || req.query.apiKey;
+  if (process.env.CRON_API_KEY !== apiKey) {
+    res.status(401).json({ message: "Not authenticated" });
+    return;
+  }
+
+  if (req.method !== "POST") {
+    res.status(405).json({ message: "Invalid method" });
+    return;
+  }
+
+  let timeZonesChanged = 0;
+
+  const setNewTimeZone = async (timeZone: string, user: { id: number; defaultScheduleId: number | null }) => {
+    await prisma.user.update({
+      where: {
+        id: user.id,
+      },
+      data: {
+        timeZone: timeZone,
+      },
+    });
+
+    const defaultScheduleId = await getDefaultScheduleId(user.id, prisma);
+
+    if (!user.defaultScheduleId) {
+      // set default schedule if not already set
+      await prisma.user.update({
+        where: {
+          id: user.id,
+        },
+        data: {
+          defaultScheduleId,
+        },
+      });
+    }
+
+    await prisma.schedule.updateMany({
+      where: {
+        id: defaultScheduleId,
+      },
+      data: {
+        timeZone: timeZone,
+      },
+    });
+    timeZonesChanged++;
+  };
+
+  /* travelSchedules should be deleted automatically when timezone is set back to original tz,
+    but we do this in case there cron job didn't run for some reason
+  */
+  const schedulesToDelete = await prisma.travelSchedule.findMany({
+    where: {
+      OR: [
+        {
+          startDate: {
+            lt: dayjs.utc().subtract(2, "day").toDate(),
+          },
+          endDate: null,
+        },
+        {
+          endDate: {
+            lt: dayjs.utc().subtract(2, "day").toDate(),
+          },
+        },
+      ],
+    },
+    select: travelScheduleSelect,
+  });
+
+  for (const travelSchedule of schedulesToDelete) {
+    if (travelSchedule.prevTimeZone) {
+      await setNewTimeZone(travelSchedule.prevTimeZone, travelSchedule.user);
+    }
+    await prisma.travelSchedule.delete({
+      where: {
+        id: travelSchedule.id,
+      },
+    });
+  }
+
+  const travelSchedulesCloseToCurrentDate = await prisma.travelSchedule.findMany({
+    where: {
+      OR: [
+        {
+          startDate: {
+            gte: dayjs.utc().subtract(1, "day").toDate(),
+            lte: dayjs.utc().add(1, "day").toDate(),
+          },
+        },
+        {
+          endDate: {
+            gte: dayjs.utc().subtract(1, "day").toDate(),
+            lte: dayjs.utc().add(1, "day").toDate(),
+          },
+        },
+      ],
+    },
+    select: travelScheduleSelect,
+  });
+
+  const travelScheduleIdsToDelete = [];
+
+  for (const travelSchedule of travelSchedulesCloseToCurrentDate) {
+    const userTz = travelSchedule.user.timeZone;
+    const offset = dayjs().tz(userTz).utcOffset();
+
+    // midnight of user's time zone in utc time
+    const startDateUTC = dayjs(travelSchedule.startDate).subtract(offset, "minute");
+    // 23:59 of user's time zone in utc time
+    const endDateUTC = dayjs(travelSchedule.endDate).subtract(offset, "minute");
+    if (
+      !dayjs.utc().isBefore(startDateUTC) &&
+      dayjs.utc().isBefore(endDateUTC) &&
+      !travelSchedule.prevTimeZone
+    ) {
+      // if travel schedule has started and prevTimeZone is not yet set, we need to change time zone
+      await setNewTimeZone(travelSchedule.timeZone, travelSchedule.user);
+
+      if (!travelSchedule.endDate) {
+        travelScheduleIdsToDelete.push(travelSchedule.id);
+      } else {
+        await prisma.travelSchedule.update({
+          where: {
+            id: travelSchedule.id,
+          },
+          data: {
+            prevTimeZone: travelSchedule.user.timeZone,
+          },
+        });
+      }
+    }
+    if (!dayjs.utc().isBefore(endDateUTC)) {
+      if (travelSchedule.prevTimeZone) {
+        // travel schedule ended, change back to original timezone
+        await setNewTimeZone(travelSchedule.prevTimeZone, travelSchedule.user);
+      }
+      travelScheduleIdsToDelete.push(travelSchedule.id);
+    }
+  }
+
+  await prisma.travelSchedule.deleteMany({
+    where: {
+      id: {
+        in: travelScheduleIdsToDelete,
+      },
+    },
+  });
+
+  res.status(200).json({ timeZonesChanged });
+}

calcom/apps/web/pages/api/cron/downgradeUsers.ts

@@ -0,0 +1,53 @@
+import type { NextApiRequest, NextApiResponse } from "next";
+import { z } from "zod";
+
+import { updateQuantitySubscriptionFromStripe } from "@calcom/features/ee/teams/lib/payments";
+import prisma from "@calcom/prisma";
+
+const querySchema = z.object({
+  page: z.coerce.number().min(0).optional().default(0),
+});
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  const apiKey = req.headers.authorization || req.query.apiKey;
+  if (process.env.CRON_API_KEY !== apiKey) {
+    res.status(401).json({ message: "Not authenticated" });
+    return;
+  }
+  if (req.method !== "POST") {
+    res.status(405).json({ message: "Invalid method" });
+    return;
+  }
+
+  const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+  const pageSize = 90; // Adjust this value based on the total number of teams and the available processing time
+  let { page: pageNumber } = querySchema.parse(req.query);
+
+  while (true) {
+    const teams = await prisma.team.findMany({
+      where: {
+        slug: {
+          not: null,
+        },
+      },
+      select: {
+        id: true,
+      },
+      skip: pageNumber * pageSize,
+      take: pageSize,
+    });
+
+    if (teams.length === 0) {
+      break;
+    }
+
+    for (const team of teams) {
+      await updateQuantitySubscriptionFromStripe(team.id);
+      await delay(100); // Adjust the delay as needed to avoid rate limiting
+    }
+
+    pageNumber++;
+  }
+
+  res.json({ ok: true });
+}

calcom/apps/web/pages/api/cron/monthlyDigestEmail.ts

@@ -0,0 +1,315 @@
+import type { Prisma } from "@prisma/client";
+import type { NextApiRequest, NextApiResponse } from "next";
+import { z } from "zod";
+
+import dayjs from "@calcom/dayjs";
+import { sendMonthlyDigestEmails } from "@calcom/emails/email-manager";
+import { EventsInsights } from "@calcom/features/insights/server/events";
+import { getTranslation } from "@calcom/lib/server";
+import prisma from "@calcom/prisma";
+
+const querySchema = z.object({
+  page: z.coerce.number().min(0).optional().default(0),
+});
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  const apiKey = req.headers.authorization || req.query.apiKey;
+
+  if (process.env.CRON_API_KEY !== apiKey) {
+    res.status(401).json({ message: "Not authenticated" });
+    return;
+  }
+
+  if (req.method !== "POST") {
+    res.status(405).json({ message: "Invalid method" });
+    return;
+  }
+
+  const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+  const pageSize = 90; // Adjust this value based on the total number of teams and the available processing time
+  let { page: pageNumber } = querySchema.parse(req.query);
+
+  const firstDateOfMonth = new Date();
+  firstDateOfMonth.setDate(1);
+
+  while (true) {
+    const teams = await prisma.team.findMany({
+      where: {
+        slug: {
+          not: null,
+        },
+        createdAt: {
+          // created before or on the first day of this month
+          lte: firstDateOfMonth,
+        },
+      },
+      select: {
+        id: true,
+        createdAt: true,
+        members: true,
+        name: true,
+      },
+      skip: pageNumber * pageSize,
+      take: pageSize,
+    });
+
+    if (teams.length === 0) {
+      break;
+    }
+
+    for (const team of teams) {
+      const EventData: {
+        Created: number;
+        Completed: number;
+        Rescheduled: number;
+        Cancelled: number;
+        mostBookedEvents: {
+          eventTypeId?: number | null;
+          eventTypeName?: string | null;
+          count?: number | null;
+        }[];
+        membersWithMostBookings: {
+          userId: number | null;
+          user: {
+            id: number;
+            name: string | null;
+            email: string;
+            avatar: string | null;
+            username: string | null;
+          };
+          count: number;
+        }[];
+        admin: { email: string; name: string };
+        team: {
+          name: string;
+          id: number;
+        };
+      } = {
+        Created: 0,
+        Completed: 0,
+        Rescheduled: 0,
+        Cancelled: 0,
+        mostBookedEvents: [],
+        membersWithMostBookings: [],
+        admin: { email: "", name: "" },
+        team: { name: team.name, id: team.id },
+      };
+
+      const userIdsFromTeams = team.members.map((u) => u.userId);
+
+      // Booking Events
+      const whereConditional: Prisma.BookingTimeStatusWhereInput = {
+        OR: [
+          {
+            teamId: team.id,
+          },
+          {
+            userId: {
+              in: userIdsFromTeams,
+            },
+            teamId: null,
+          },
+        ],
+        createdAt: {
+          gte: dayjs(firstDateOfMonth).toISOString(),
+          lte: dayjs(new Date()).toISOString(),
+        },
+      };
+
+      const countGroupedByStatus = await EventsInsights.countGroupedByStatus(whereConditional);
+
+      EventData["Created"] = countGroupedByStatus["_all"];
+      EventData["Completed"] = countGroupedByStatus["completed"];
+      EventData["Rescheduled"] = countGroupedByStatus["rescheduled"];
+      EventData["Cancelled"] = countGroupedByStatus["cancelled"];
+
+      // Most Booked Event Type
+      const bookingWhere: Prisma.BookingTimeStatusWhereInput = {
+        createdAt: {
+          gte: dayjs(firstDateOfMonth).startOf("day").toDate(),
+          lte: dayjs(new Date()).endOf("day").toDate(),
+        },
+        OR: [
+          {
+            teamId: team.id,
+          },
+          {
+            userId: {
+              in: userIdsFromTeams,
+            },
+            teamId: null,
+          },
+        ],
+      };
+
+      const bookingsFromSelected = await prisma.bookingTimeStatus.groupBy({
+        by: ["eventTypeId"],
+        where: bookingWhere,
+        _count: {
+          id: true,
+        },
+        orderBy: {
+          _count: {
+            id: "desc",
+          },
+        },
+        take: 10,
+      });
+
+      const eventTypeIds = bookingsFromSelected
+        .filter((booking) => typeof booking.eventTypeId === "number")
+        .map((booking) => booking.eventTypeId);
+
+      const eventTypeWhereConditional: Prisma.EventTypeWhereInput = {
+        id: {
+          in: eventTypeIds as number[],
+        },
+      };
+
+      const eventTypesFrom = await prisma.eventType.findMany({
+        select: {
+          id: true,
+          title: true,
+          teamId: true,
+          userId: true,
+          slug: true,
+          users: {
+            select: {
+              username: true,
+            },
+          },
+          team: {
+            select: {
+              slug: true,
+            },
+          },
+        },
+        where: eventTypeWhereConditional,
+      });
+
+      const eventTypeHashMap: Map<
+        number,
+        Prisma.EventTypeGetPayload<{
+          select: {
+            id: true;
+            title: true;
+            teamId: true;
+            userId: true;
+            slug: true;
+            users: {
+              select: {
+                username: true;
+              };
+            };
+            team: {
+              select: {
+                slug: true;
+              };
+            };
+          };
+        }>
+      > = new Map();
+      eventTypesFrom.forEach((eventType) => {
+        eventTypeHashMap.set(eventType.id, eventType);
+      });
+
+      EventData["mostBookedEvents"] = bookingsFromSelected.map((booking) => {
+        const eventTypeSelected = eventTypeHashMap.get(booking.eventTypeId ?? 0);
+        if (!eventTypeSelected) {
+          return {};
+        }
+
+        let eventSlug = "";
+        if (eventTypeSelected.userId) {
+          eventSlug = `${eventTypeSelected?.users[0]?.username}/${eventTypeSelected?.slug}`;
+        }
+        if (eventTypeSelected?.team && eventTypeSelected?.team?.slug) {
+          eventSlug = `${eventTypeSelected.team.slug}/${eventTypeSelected.slug}`;
+        }
+        return {
+          eventTypeId: booking.eventTypeId,
+          eventTypeName: eventSlug,
+          count: booking._count.id,
+        };
+      });
+
+      // Most booked members
+      const bookingsFromTeam = await prisma.bookingTimeStatus.groupBy({
+        by: ["userId"],
+        where: bookingWhere,
+        _count: {
+          id: true,
+        },
+        orderBy: {
+          _count: {
+            id: "desc",
+          },
+        },
+        take: 10,
+      });
+
+      const userIds = bookingsFromTeam
+        .filter((booking) => typeof booking.userId === "number")
+        .map((booking) => booking.userId);
+
+      if (userIds.length === 0) {
+        EventData["membersWithMostBookings"] = [];
+      } else {
+        const teamUsers = await prisma.user.findMany({
+          where: {
+            id: {
+              in: userIds as number[],
+            },
+          },
+          select: { id: true, name: true, email: true, avatarUrl: true, username: true },
+        });
+
+        const userHashMap = new Map();
+        teamUsers.forEach((user) => {
+          userHashMap.set(user.id, user);
+        });
+
+        EventData["membersWithMostBookings"] = bookingsFromTeam.map((booking) => {
+          return {
+            userId: booking.userId,
+            user: userHashMap.get(booking.userId),
+            count: booking._count.id,
+          };
+        });
+      }
+
+      // Send mail to all Owners and Admins
+      const mailReceivers = team?.members?.filter(
+        (member) => member.role === "OWNER" || member.role === "ADMIN"
+      );
+
+      const mailsToSend = mailReceivers.map(async (receiver) => {
+        const owner = await prisma.user.findUnique({
+          where: {
+            id: receiver?.userId,
+          },
+        });
+
+        if (owner) {
+          const t = await getTranslation(owner?.locale ?? "en", "common");
+
+          // Only send email if user has allowed to receive monthly digest emails
+          if (owner.receiveMonthlyDigestEmail) {
+            await sendMonthlyDigestEmails({
+              ...EventData,
+              admin: { email: owner?.email ?? "", name: owner?.name ?? "" },
+              language: t,
+            });
+          }
+        }
+      });
+
+      await Promise.all(mailsToSend);
+
+      await delay(100); // Adjust the delay as needed to avoid rate limiting
+    }
+
+    pageNumber++;
+  }
+  res.json({ ok: true });
+}

calcom/apps/web/pages/api/cron/syncAppMeta.ts

@@ -0,0 +1,67 @@
+import type { NextApiRequest, NextApiResponse } from "next";
+
+import { getAppWithMetadata } from "@calcom/app-store/_appRegistry";
+import logger from "@calcom/lib/logger";
+import { prisma } from "@calcom/prisma";
+import type { AppCategories, Prisma } from "@calcom/prisma/client";
+
+const isDryRun = process.env.CRON_ENABLE_APP_SYNC !== "true";
+const log = logger.getSubLogger({
+  prefix: ["[api/cron/syncAppMeta]", ...(isDryRun ? ["(dry-run)"] : [])],
+});
+
+/**
+ * syncAppMeta makes sure any app metadata that has been replicated into the database
+ * remains synchronized with any changes made to the app config files.
+ */
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  const apiKey = req.headers.authorization || req.query.apiKey;
+  if (process.env.CRON_API_KEY !== apiKey) {
+    res.status(401).json({ message: "Not authenticated" });
+    return;
+  }
+  if (req.method !== "POST") {
+    res.status(405).json({ message: "Invalid method" });
+    return;
+  }
+
+  log.info(`🧐 Checking DB apps are in-sync with app metadata`);
+
+  const dbApps = await prisma.app.findMany();
+
+  for await (const dbApp of dbApps) {
+    const app = await getAppWithMetadata(dbApp);
+    const updates: Prisma.AppUpdateManyMutationInput = {};
+
+    if (!app) {
+      log.warn(`💀 App ${dbApp.slug} (${dbApp.dirName}) no longer exists.`);
+      continue;
+    }
+
+    // Check for any changes in the app categories (tolerates changes in ordering)
+    if (
+      dbApp.categories.length !== app.categories.length ||
+      !dbApp.categories.every((category) => app.categories.includes(category))
+    ) {
+      updates["categories"] = app.categories as AppCategories[];
+    }
+
+    if (dbApp.dirName !== (app.dirName ?? app.slug)) {
+      updates["dirName"] = app.dirName ?? app.slug;
+    }
+
+    if (Object.keys(updates).length > 0) {
+      log.info(`🔨 Updating app ${dbApp.slug} with ${Object.keys(updates).join(", ")}`);
+      if (!isDryRun) {
+        await prisma.app.update({
+          where: { slug: dbApp.slug },
+          data: updates,
+        });
+      }
+    } else {
+      log.info(`✅ App ${dbApp.slug} is up-to-date and correct`);
+    }
+  }
+
+  res.json({ ok: true });
+}

calcom/apps/web/pages/api/cron/webhookTriggers.ts

@@ -0,0 +1 @@
+export { default } from "@calcom/features/webhooks/lib/cron";

calcom/apps/web/pages/api/cron/workflows/scheduleEmailReminders.ts

@@ -0,0 +1 @@
+export { default } from "@calcom/features/ee/workflows/api/scheduleEmailReminders";

calcom/apps/web/pages/api/cron/workflows/scheduleSMSReminders.ts

@@ -0,0 +1 @@
+export { default } from "@calcom/features/ee/workflows/api/scheduleSMSReminders";

calcom/apps/web/pages/api/cron/workflows/scheduleWhatsappReminders.ts

@@ -0,0 +1 @@
+export { default } from "@calcom/features/ee/workflows/api/scheduleWhatsappReminders";