fix: use InsightsBookingService for Download button on /insights (calcom#22698)

Author: eunjae-lee

packages/features/insights/filters/Download/Download.tsx

@@ -1,8 +1,10 @@
 import { useState } from "react";
 
 import dayjs from "@calcom/dayjs";
+import { useDataTable } from "@calcom/features/data-table";
 import { downloadAsCsv } from "@calcom/lib/csvUtils";
 import { useLocale } from "@calcom/lib/hooks/useLocale";
+import { CURRENT_TIMEZONE } from "@calcom/lib/timezoneConstants";
 import { trpc } from "@calcom/trpc";
 import type { RouterOutputs } from "@calcom/trpc/react";
 import { Button } from "@calcom/ui/components/button";
@@ -22,7 +24,8 @@ const BATCH_SIZE = 100;
 
 const Download = () => {
   const { t } = useLocale();
-  const { startDate, endDate, teamId, userId, eventTypeId, memberUserId, isAll } = useInsightsParameters();
+  const { timeZone } = useDataTable();
+  const { scope, selectedTeamId, startDate, endDate, eventTypeId, memberUserId } = useInsightsParameters();
   const [isDownloading, setIsDownloading] = useState(false);
   const utils = trpc.useUtils();
 
@@ -34,13 +37,13 @@ const Download = () => {
   const fetchBatch = async (offset: number): Promise<PaginatedResponse | null> => {
     try {
       const result = await utils.viewer.insights.rawData.fetch({
+        scope,
+        selectedTeamId,
         startDate,
         endDate,
-        teamId,
-        userId,
+        timeZone: timeZone || CURRENT_TIMEZONE,
         eventTypeId,
         memberUserId,
-        isAll,
         limit: BATCH_SIZE,
         offset,
       });

packages/features/insights/server/events.ts

@@ -3,8 +3,6 @@ import dayjs from "@calcom/dayjs";
 import { readonlyPrisma as prisma } from "@calcom/prisma";
 import { Prisma } from "@calcom/prisma/client";
 
-import type { RawDataInput } from "./raw-data.schema";
-
 type TimeViewType = "week" | "month" | "year" | "day";
 
 type StatusAggregate = {
@@ -456,298 +454,6 @@ class EventsInsights {
     }
   }
 
-  static getCsvData = async (
-    props: RawDataInput & {
-      organizationId: number | null;
-      isOrgAdminOrOwner: boolean | null;
-    }
-  ) => {
-    // Obtain the where conditional
-    const whereConditional = await this.obtainWhereConditionalForDownload(props);
-    const limit = props.limit ?? 100; // Default batch size
-    const offset = props.offset ?? 0;
-
-    const totalCountPromise = prisma.bookingTimeStatusDenormalized.count({
-      where: whereConditional,
-    });
-
-    const csvDataPromise = prisma.bookingTimeStatusDenormalized.findMany({
-      select: {
-        id: true,
-        uid: true,
-        title: true,
-        createdAt: true,
-        timeStatus: true,
-        eventTypeId: true,
-        eventLength: true,
-        startTime: true,
-        endTime: true,
-        paid: true,
-        userEmail: true,
-        userUsername: true,
-        rating: true,
-        ratingFeedback: true,
-        noShowHost: true,
-      },
-      where: whereConditional,
-      skip: offset,
-      take: limit,
-    });
-
-    const [totalCount, csvData] = await Promise.all([totalCountPromise, csvDataPromise]);
-
-    const uids = csvData.filter((b) => b.uid !== null).map((b) => b.uid as string);
-
-    if (uids.length === 0) {
-      return { data: csvData, total: totalCount };
-    }
-
-    const bookings = await prisma.booking.findMany({
-      where: {
-        uid: {
-          in: uids,
-        },
-      },
-      select: {
-        uid: true,
-        attendees: {
-          select: {
-            name: true,
-            email: true,
-            noShow: true,
-          },
-        },
-        seatsReferences: {
-          select: {
-            attendee: {
-              select: {
-                name: true,
-                email: true,
-                noShow: true,
-              },
-            },
-          },
-        },
-      },
-    });
-
-    const bookingMap = new Map(
-      bookings.map((booking) => {
-        const attendeeList =
-          booking.seatsReferences.length > 0
-            ? booking.seatsReferences.map((ref) => ref.attendee)
-            : booking.attendees;
-
-        // List all no-show guests (name and email)
-        const noShowGuests =
-          attendeeList
-            .filter((attendee) => attendee?.noShow)
-            .map((attendee) => (attendee ? `${attendee.name} (${attendee.email})` : null))
-            .filter(Boolean) // remove null values
-            .join("; ") || null;
-        const noShowGuestsCount = attendeeList.filter((attendee) => attendee?.noShow).length;
-
-        const formattedAttendees = attendeeList
-          .map((attendee) => (attendee ? `${attendee.name} (${attendee.email})` : null))
-          .filter(Boolean);
-
-        return [booking.uid, { attendeeList: formattedAttendees, noShowGuests, noShowGuestsCount }];
-      })
-    );
-
-    const maxAttendees = Math.max(
-      ...Array.from(bookingMap.values()).map((data) => data.attendeeList.length),
-      0
-    );
-
-    const finalBookingMap = new Map(
-      Array.from(bookingMap.entries()).map(([uid, data]) => {
-        const attendeeFields: Record<string, string | null> = {};
-
-        for (let i = 1; i <= maxAttendees; i++) {
-          attendeeFields[`attendee${i}`] = data.attendeeList[i - 1] || null;
-        }
-
-        return [
-          uid,
-          {
-            noShowGuests: data.noShowGuests,
-            noShowGuestsCount: data.noShowGuestsCount,
-            ...attendeeFields,
-          },
-        ];
-      })
-    );
-
-    const data = csvData.map((bookingTimeStatus) => {
-      if (!bookingTimeStatus.uid) {
-        // should not be reached because we filtered above
-        const nullAttendeeFields: Record<string, null> = {};
-        for (let i = 1; i <= maxAttendees; i++) {
-          nullAttendeeFields[`attendee${i}`] = null;
-        }
-
-        return {
-          ...bookingTimeStatus,
-          noShowGuests: null,
-          ...nullAttendeeFields,
-        };
-      }
-
-      const attendeeData = finalBookingMap.get(bookingTimeStatus.uid);
-
-      if (!attendeeData) {
-        const nullAttendeeFields: Record<string, null> = {};
-        for (let i = 1; i <= maxAttendees; i++) {
-          nullAttendeeFields[`attendee${i}`] = null;
-        }
-
-        return {
-          ...bookingTimeStatus,
-          noShowGuests: null,
-          ...nullAttendeeFields,
-        };
-      }
-
-      return {
-        ...bookingTimeStatus,
-        noShowGuests: attendeeData.noShowGuests,
-        noShowGuestsCount: attendeeData.noShowGuestsCount,
-        ...Object.fromEntries(Object.entries(attendeeData).filter(([key]) => key.startsWith("attendee"))),
-      };
-    });
-
-    return { data, total: totalCount };
-  };
-
-  /*
-   * This is meant to be used for all functions inside insights router,
-   * but it's currently used only for CSV download.
-   * Ideally we should have a view that have all of this data
-   * The order where will be from the most specific to the least specific
-   * starting from the top will be:
-   * - memberUserId
-   * - eventTypeId
-   * - userId
-   * - teamId
-   * Generics will be:
-   * - isAll
-   * - startDate
-   * - endDate
-   * @param props
-   * @returns
-   */
-  static obtainWhereConditionalForDownload = async (
-    props: RawDataInput & { organizationId: number | null; isOrgAdminOrOwner: boolean | null }
-  ) => {
-    const {
-      startDate,
-      endDate,
-      teamId,
-      userId,
-      memberUserId,
-      isAll,
-      eventTypeId,
-      organizationId,
-      isOrgAdminOrOwner,
-    } = props;
-
-    // Obtain the where conditional
-    let whereConditional: Prisma.BookingTimeStatusDenormalizedWhereInput = {};
-
-    if (startDate && endDate) {
-      whereConditional.createdAt = {
-        gte: dayjs(startDate).toISOString(),
-        lte: dayjs(endDate).toISOString(),
-      };
-    }
-
-    if (eventTypeId) {
-      whereConditional["eventTypeId"] = eventTypeId;
-    }
-    if (memberUserId) {
-      whereConditional["userId"] = memberUserId;
-    }
-    if (userId) {
-      whereConditional["teamId"] = null;
-      whereConditional["userId"] = userId;
-    }
-
-    if (isAll && isOrgAdminOrOwner && organizationId) {
-      const teamsFromOrg = await prisma.team.findMany({
-        where: {
-          parentId: organizationId,
-        },
-        select: {
-          id: true,
-        },
-      });
-      if (teamsFromOrg.length === 0) {
-        return {};
-      }
-      const teamIds: number[] = [organizationId, ...teamsFromOrg.map((t) => t.id)];
-      const usersFromOrg = await prisma.membership.findMany({
-        where: {
-          teamId: {
-            in: teamIds,
-          },
-          accepted: true,
-        },
-        select: {
-          userId: true,
-        },
-      });
-      const userIdsFromOrg = usersFromOrg.map((u) => u.userId);
-      whereConditional = {
-        ...whereConditional,
-        OR: [
-          {
-            userId: {
-              in: userIdsFromOrg,
-            },
-            isTeamBooking: false,
-          },
-          {
-            teamId: {
-              in: teamIds,
-            },
-            isTeamBooking: true,
-          },
-        ],
-      };
-    }
-
-    if (teamId && !isAll) {
-      const usersFromTeam = await prisma.membership.findMany({
-        where: {
-          teamId: teamId,
-          accepted: true,
-        },
-        select: {
-          userId: true,
-        },
-      });
-      const userIdsFromTeam = usersFromTeam.map((u) => u.userId);
-      whereConditional = {
-        ...whereConditional,
-        OR: [
-          {
-            teamId,
-            isTeamBooking: true,
-          },
-          {
-            userId: {
-              in: userIdsFromTeam,
-            },
-            isTeamBooking: false,
-          },
-        ],
-      };
-    }
-
-    return whereConditional;
-  };
-
   static userIsOwnerAdminOfTeam = async ({
     sessionUserId,
     teamId,