From 38fa0fae1d46b188cc6b55089cbd2227b32297d3 Mon Sep 17 00:00:00 2001
From: Syed Ali Shahbaz <52925846+alishaz-polymath@users.noreply.github.com>
Date: Fri, 27 Sep 2024 07:36:32 +0400
Subject: [PATCH] fix: insights UI/UX (#16610)

* remove old code remnant

* -

* WIP

* type change

* --

* typefix

* fix type

* fix type

* change type name

* add basewhere to eventsByStatus

* add basewhere to the rest

* fix rendering null popular event list item

* URL params for start and endtime to have YYYY-MM-DD format

* remove console log

* resolve suggestion

---------

Co-authored-by: Udit Takkar <53316345+Udit-takkar@users.noreply.github.com>
---
 apps/web/public/static/locales/en/common.json |    4 +
 .../components/AverageEventDurationChart.tsx  |    5 +-
 .../insights/components/BookingKPICards.tsx   |    1 +
 .../components/PopularEventsTable.tsx         |   27 +-
 .../insights/context/FiltersProvider.tsx      |    6 +-
 .../features/insights/filters/DateSelect.tsx  |  128 ++-
 packages/features/insights/filters/index.tsx  |    2 +-
 .../features/insights/server/trpc-router.ts   | 1019 +++++------------
 .../form/date-range-picker/Calendar.tsx       |   12 +-
 .../date-range-picker/DateRangePicker.tsx     |    6 +
 10 files changed, 425 insertions(+), 785 deletions(-)

diff --git a/apps/web/public/static/locales/en/common.json b/apps/web/public/static/locales/en/common.json
index 25f060ccf8..ece75ba18d 100644
--- a/apps/web/public/static/locales/en/common.json
+++ b/apps/web/public/static/locales/en/common.json
@@ -2618,5 +2618,9 @@
   "you_are_unauthorized_to_make_this_change_to_the_booking": "You are unauthorized to make this change to the booking",
   "hide_calendar_event_details": "Hide calendar event details on shared calendars",
   "description_hide_calendar_event_details": "When a calendar is shared, events are visible to readers but their details are hidden from those without write access.",
+  "last_number_of_days": "last {{count}} days",
+  "month_to_date": "month to date",
+  "year_to_date": "year to date",
+  "custom_range": "custom range",
   "ADD_NEW_STRINGS_ABOVE_THIS_LINE_TO_PREVENT_MERGE_CONFLICTS": "↑↑↑↑↑↑↑↑↑↑↑↑↑ Add your new strings above here ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑"
 }
diff --git a/packages/features/insights/components/AverageEventDurationChart.tsx b/packages/features/insights/components/AverageEventDurationChart.tsx
index aca9a5136d..86888a4ef8 100644
--- a/packages/features/insights/components/AverageEventDurationChart.tsx
+++ b/packages/features/insights/components/AverageEventDurationChart.tsx
@@ -14,13 +14,14 @@ export const AverageEventDurationChart = () => {
   const { filter } = useFilterContext();
   const { dateRange, selectedMemberUserId, isAll, initialConfig } = filter;
   const [startDate, endDate] = dateRange;
-  const { selectedTeamId: teamId, selectedUserId } = filter;
+  const { selectedTeamId: teamId, selectedUserId, selectedEventTypeId } = filter;
   const initialConfigIsReady = !!(initialConfig?.teamId || initialConfig?.userId || initialConfig?.isAll);
   const { data, isSuccess, isPending } = trpc.viewer.insights.averageEventDuration.useQuery(
     {
       startDate: startDate.toISOString(),
       endDate: endDate.toISOString(),
-      teamId: teamId ?? undefined,
+      teamId,
+      eventTypeId: selectedEventTypeId ?? undefined,
       memberUserId: selectedMemberUserId ?? undefined,
       userId: selectedUserId ?? undefined,
       isAll,
diff --git a/packages/features/insights/components/BookingKPICards.tsx b/packages/features/insights/components/BookingKPICards.tsx
index e9cc929b90..81cf50a16b 100644
--- a/packages/features/insights/components/BookingKPICards.tsx
+++ b/packages/features/insights/components/BookingKPICards.tsx
@@ -11,6 +11,7 @@ import { KPICard } from "./KPICard";
 export const BookingKPICards = () => {
   const { t } = useLocale();
   const { filter } = useFilterContext();
+
   const { dateRange, selectedEventTypeId, selectedUserId, selectedMemberUserId, isAll, initialConfig } =
     filter;
   const initialConfigIsReady = !!(initialConfig?.teamId || initialConfig?.userId || initialConfig?.isAll);
diff --git a/packages/features/insights/components/PopularEventsTable.tsx b/packages/features/insights/components/PopularEventsTable.tsx
index 2ec8b3cde1..59f6b23255 100644
--- a/packages/features/insights/components/PopularEventsTable.tsx
+++ b/packages/features/insights/components/PopularEventsTable.tsx
@@ -10,7 +10,8 @@ import { LoadingInsight } from "./LoadingInsights";
 export const PopularEventsTable = () => {
   const { t } = useLocale();
   const { filter } = useFilterContext();
-  const { dateRange, selectedMemberUserId, selectedUserId, isAll, initialConfig } = filter;
+  const { dateRange, selectedMemberUserId, selectedUserId, isAll, initialConfig, selectedEventTypeId } =
+    filter;
   const [startDate, endDate] = dateRange;
   const { selectedTeamId: teamId } = filter;
 
@@ -20,6 +21,7 @@ export const PopularEventsTable = () => {
       endDate: endDate.toISOString(),
       teamId: teamId ?? undefined,
       userId: selectedUserId ?? undefined,
+      eventTypeId: selectedEventTypeId ?? undefined,
       memberUserId: selectedMemberUserId ?? undefined,
       isAll,
     },
@@ -41,16 +43,19 @@ export const PopularEventsTable = () => {
       <Title className="text-emphasis">{t("popular_events")}</Title>
       <Table className="mt-5">
         <TableBody>
-          {data.map((item) => (
-            <TableRow key={item.eventTypeId}>
-              <TableCell className="text-default">{item.eventTypeName}</TableCell>
-              <TableCell>
-                <Text className="text-default text-right">
-                  <strong>{item.count}</strong>
-                </Text>
-              </TableCell>
-            </TableRow>
-          ))}
+          {data.map(
+            (item) =>
+              item.eventTypeId && (
+                <TableRow key={item.eventTypeId}>
+                  <TableCell className="text-default">{item.eventTypeName}</TableCell>
+                  <TableCell>
+                    <Text className="text-default text-right">
+                      <strong>{item.count}</strong>
+                    </Text>
+                  </TableCell>
+                </TableRow>
+              )
+          )}
         </TableBody>
       </Table>
       {data.length === 0 && (
diff --git a/packages/features/insights/context/FiltersProvider.tsx b/packages/features/insights/context/FiltersProvider.tsx
index 091a0688fd..ec557a9730 100644
--- a/packages/features/insights/context/FiltersProvider.tsx
+++ b/packages/features/insights/context/FiltersProvider.tsx
@@ -60,7 +60,7 @@ export function FiltersProvider({ children }: { children: React.ReactNode }) {
     dateRange: [
       startTimeParsed ? dayjs(startTimeParsed) : dayjs().subtract(1, "week"),
       endTimeParsed ? dayjs(endTimeParsed) : dayjs(),
-      "w",
+      !startTimeParsed && !endTimeParsed ? "w" : null,
     ],
     selectedTimeView: "week",
     selectedUserId: userIdParsed || null,
@@ -131,8 +131,8 @@ export function FiltersProvider({ children }: { children: React.ReactNode }) {
           setParamsIfDefined("userId", selectedUserId || initialConfig?.userId);
           setParamsIfDefined("eventTypeId", selectedEventTypeId);
           setParamsIfDefined("isAll", isAll || initialConfig?.isAll);
-          setParamsIfDefined("startTime", startTime?.toISOString());
-          setParamsIfDefined("endTime", endTime?.toISOString());
+          setParamsIfDefined("startTime", startTime?.format("YYYY-MM-DD"));
+          setParamsIfDefined("endTime", endTime?.format("YYYY-MM-DD"));
           setParamsIfDefined("filter", selectedFilter?.[0]);
           router.push(`${pathname}?${newSearchParams.toString()}`);
         },
diff --git a/packages/features/insights/filters/DateSelect.tsx b/packages/features/insights/filters/DateSelect.tsx
index d16630bfdb..3f340dae74 100644
--- a/packages/features/insights/filters/DateSelect.tsx
+++ b/packages/features/insights/filters/DateSelect.tsx
@@ -1,68 +1,102 @@
-import { DateRangePicker } from "@tremor/react";
+import { useState } from "react";
 
 import dayjs from "@calcom/dayjs";
 import { useLocale } from "@calcom/lib/hooks/useLocale";
+import { DateRangePicker } from "@calcom/ui";
+import { Select } from "@calcom/ui";
 
 import { useFilterContext } from "../context/provider";
 import "./DateSelect.css";
 
-type RangeType = "tdy" | "w" | "t" | "m" | "y" | undefined | null;
-
 export const DateSelect = () => {
   const { t } = useLocale();
+  const presetOptions = [
+    { label: t("today"), value: "tdy" },
+    { label: t("last_number_of_days", { count: 7 }), value: "w" },
+    { label: t("last_number_of_days", { count: 30 }), value: "t" },
+    { label: t("month_to_date"), value: "m" },
+    { label: t("year_to_date"), value: "y" },
+    { label: t("custom_range"), value: null },
+  ];
+
   const { filter, setConfigFilters } = useFilterContext();
   const currentDate = dayjs();
-  const [startDate, endDate, range] = filter?.dateRange || [null, null, null];
+  const [initialStartDate, initialEndDate, range] = filter?.dateRange || [null, null, null];
+  const [startDate, setStartDate] = useState(initialStartDate);
+  const [endDate, setEndDate] = useState(initialEndDate);
   const startValue = startDate?.toDate() || null;
   const endValue = endDate?.toDate() || null;
+  const [selectedPreset, setSelectedPreset] = useState(presetOptions.find((c) => c.value === range));
+
+  const updateDateRange = (val: string | null) => {
+    setSelectedPreset(presetOptions.find((c) => c.value === val));
+    let startDate = dayjs();
+    let endDate = dayjs();
+
+    switch (val) {
+      case "tdy": // Today
+        startDate = dayjs().startOf("day");
+        endDate = dayjs().endOf("day");
+        break;
+      case "w": // Last 7 days
+        startDate = dayjs().subtract(7, "day").startOf("day");
+        endDate = dayjs().endOf("day");
+        break;
+      case "t": // Last 30 days
+        startDate = dayjs().subtract(30, "day").startOf("day");
+        endDate = dayjs().endOf("day");
+        break;
+      case "m": // Month to Date
+        startDate = dayjs().startOf("month");
+        endDate = dayjs().endOf("day");
+        break;
+      case "y": // Year to Date
+        startDate = dayjs().startOf("year");
+        endDate = dayjs().endOf("day");
+        break;
+      default:
+        break;
+    }
+    // Update the datepicker date selection
+    setStartDate(startDate);
+    setEndDate(endDate);
+    // Update the configuration filter
+    setConfigFilters({
+      dateRange: [dayjs(startDate), dayjs(endDate), val],
+    });
+  };
+
   return (
-    <div className="custom-date max-w-96 w-full sm:w-auto">
+    <div className="ml me-2 ms-2 inline-flex space-x-2 rtl:space-x-reverse">
       <DateRangePicker
-        value={[startValue, endValue, range]}
-        defaultValue={[startValue, endValue, range]}
-        onValueChange={(datesArray) => {
-          const [selected, ...rest] = datesArray;
-          const [start, end, range] = datesArray;
-          // If range has value and it's of type RangeType
-
-          if (
-            range &&
-            (range === "tdy" || range === "w" || range === "t" || range === "m" || range === "y")
-          ) {
-            setConfigFilters({
-              dateRange: [dayjs(start).startOf("d"), dayjs(end).endOf("d"), range],
-            });
-
-            return;
-          } else if (start && !end) {
-            // If only start time has value that means selected date should push to dateRange with last value null
-            const currentDates = filter.dateRange;
-            if (currentDates && currentDates.length > 0) {
-              // remove last position of array
-              currentDates.pop();
-              // push new value to array
-              currentDates.push(dayjs(selected));
-              // if lenght > 2 then remove first value
-              if (currentDates.length > 2) {
-                currentDates.shift();
-              }
-              setConfigFilters({
-                dateRange: [currentDates[0], currentDates[1], null],
-              });
-            }
-
-            return;
-          }
-
-          // If range has value and it's of type RangeType
+        dates={{
+          startDate: startValue,
+          endDate: endValue,
         }}
-        options={undefined}
-        enableDropdown={true}
-        placeholder={t("select_date_range")}
-        enableYearPagination={true}
         minDate={currentDate.subtract(2, "year").toDate()}
         maxDate={currentDate.toDate()}
-        color="gray"
+        disabled={false}
+        onDatesChange={({ startDate, endDate }) => {
+          setConfigFilters({
+            dateRange: [dayjs(startDate), dayjs(endDate), null],
+          });
+          setStartDate(dayjs(startDate));
+          setEndDate(dayjs(endDate));
+          setSelectedPreset(presetOptions.find((c) => c.value === null));
+        }}
+      />
+      <Select
+        variant="default"
+        data-testid="insights-preset"
+        options={presetOptions}
+        value={selectedPreset}
+        className="w-40 capitalize text-black"
+        defaultValue={selectedPreset}
+        onChange={(e) => {
+          if (e) {
+            updateDateRange(e.value);
+          }
+        }}
       />
     </div>
   );
diff --git a/packages/features/insights/filters/index.tsx b/packages/features/insights/filters/index.tsx
index 3edae81c6e..0cb29db884 100644
--- a/packages/features/insights/filters/index.tsx
+++ b/packages/features/insights/filters/index.tsx
@@ -72,7 +72,7 @@ export const Filters = () => {
           />
         </Tooltip>
       </ButtonGroup> */}
-      <div className="flex flex-col-reverse gap-2 sm:flex-row sm:flex-nowrap sm:justify-between">
+      <div className="flex flex-col-reverse sm:flex-row sm:flex-nowrap sm:justify-between">
         <Download />
         <DateSelect />
       </div>
diff --git a/packages/features/insights/server/trpc-router.ts b/packages/features/insights/server/trpc-router.ts
index f821318ab0..304ce8f454 100644
--- a/packages/features/insights/server/trpc-router.ts
+++ b/packages/features/insights/server/trpc-router.ts
@@ -5,6 +5,7 @@ import { z } from "zod";
 import dayjs from "@calcom/dayjs";
 import { rawDataInputSchema } from "@calcom/features/insights/server/raw-data.schema";
 import { randomString } from "@calcom/lib/random";
+import type { readonlyPrisma } from "@calcom/prisma";
 import authedProcedure from "@calcom/trpc/server/procedures/authedProcedure";
 import { router } from "@calcom/trpc/server/trpc";
 
@@ -17,6 +18,117 @@ const UserBelongsToTeamInput = z.object({
   isAll: z.boolean().optional(),
 });
 
+type BuildBaseWhereConditionCtxType = {
+  userIsOwnerAdminOfParentTeam: boolean;
+  userOrganizationId: number | null;
+  insightsDb: typeof readonlyPrisma;
+};
+
+interface BuildBaseWhereConditionType {
+  teamId?: number | null;
+  eventTypeId?: number;
+  memberUserId?: number;
+  userId?: number;
+  isAll?: boolean;
+  ctx: BuildBaseWhereConditionCtxType;
+}
+
+const buildBaseWhereCondition = async ({
+  teamId,
+  eventTypeId,
+  memberUserId,
+  userId,
+  isAll,
+  ctx,
+}: BuildBaseWhereConditionType): Promise<{
+  whereCondition: Prisma.BookingTimeStatusWhereInput;
+  isEmptyResponse?: boolean;
+}> => {
+  let whereCondition: Prisma.BookingTimeStatusWhereInput = {};
+  // EventType Filter
+  if (eventTypeId) whereCondition.OR = [{ eventTypeId }, { eventParentId: eventTypeId }];
+  // User/Member filter
+  if (memberUserId) whereCondition.userId = memberUserId;
+  if (userId) {
+    whereCondition.teamId = null;
+    whereCondition.userId = userId;
+  }
+  // organization-wide queries condition
+  if (isAll && ctx.userIsOwnerAdminOfParentTeam && ctx.userOrganizationId) {
+    const teamsFromOrg = await ctx.insightsDb.team.findMany({
+      where: {
+        parentId: ctx.userOrganizationId,
+      },
+      select: {
+        id: true,
+      },
+    });
+    if (teamsFromOrg.length === 0) return { whereCondition, isEmptyResponse: true };
+
+    const teamConditional = {
+      id: {
+        in: [ctx.userOrganizationId, ...teamsFromOrg.map((t) => t.id)],
+      },
+    };
+    const usersFromOrg = await ctx.insightsDb.membership.findMany({
+      where: {
+        team: teamConditional,
+        accepted: true,
+      },
+      select: {
+        userId: true,
+      },
+    });
+    const userIdsFromOrg = usersFromOrg.map((u) => u.userId);
+    whereCondition = {
+      ...whereCondition,
+      OR: [
+        {
+          teamId: {
+            in: [ctx.userOrganizationId, ...teamsFromOrg.map((t) => t.id)],
+          },
+          isTeamBooking: true,
+        },
+        {
+          userId: {
+            in: userIdsFromOrg,
+          },
+          isTeamBooking: false,
+        },
+      ],
+    };
+  }
+
+  if (teamId && !isAll && !eventTypeId) {
+    const usersFromTeam = await ctx.insightsDb.membership.findMany({
+      where: {
+        teamId: teamId,
+        accepted: true,
+      },
+      select: {
+        userId: true,
+      },
+    });
+    const userIdsFromTeam = usersFromTeam.map((u) => u.userId);
+    whereCondition = {
+      ...whereCondition,
+      OR: [
+        {
+          teamId,
+          isTeamBooking: true,
+        },
+        {
+          userId: {
+            in: userIdsFromTeam,
+          },
+          isTeamBooking: false,
+        },
+      ],
+    };
+  }
+  return { whereCondition };
+};
+
 const buildHashMapForUsers = <
   T extends { avatarUrl: string | null; id: number; username: string | null; [key: string]: unknown }
 >(
@@ -143,7 +255,7 @@ export const insightsRouter = router({
   eventsByStatus: userBelongsToTeamProcedure
     .input(
       z.object({
-        teamId: z.coerce.number().optional().nullable(),
+        teamId: z.coerce.number().nullish(),
         startDate: z.string(),
         endDate: z.string(),
         eventTypeId: z.coerce.number().optional(),
@@ -158,100 +270,20 @@ export const insightsRouter = router({
         throw new TRPCError({ code: "UNAUTHORIZED" });
       }
 
-      let whereConditional: Prisma.BookingTimeStatusWhereInput = {};
-      let teamConditional: Prisma.TeamWhereInput = {};
+      const r = await buildBaseWhereCondition({
+        teamId,
+        eventTypeId,
+        memberUserId,
+        userId,
+        isAll,
+        ctx: {
+          userIsOwnerAdminOfParentTeam: ctx.user.isOwnerAdminOfParentTeam,
+          userOrganizationId: ctx.user.organizationId,
+          insightsDb: ctx.insightsDb,
+        },
+      });
 
-      if (eventTypeId) {
-        whereConditional["OR"] = [
-          {
-            eventTypeId,
-          },
-          {
-            eventParentId: eventTypeId,
-          },
-        ];
-      }
-      if (memberUserId) {
-        whereConditional["userId"] = memberUserId;
-      }
-      if (userId) {
-        whereConditional["teamId"] = null;
-        whereConditional["userId"] = userId;
-      }
-
-      if (isAll && ctx.user.isOwnerAdminOfParentTeam && ctx.user.organizationId) {
-        const teamsFromOrg = await ctx.insightsDb.team.findMany({
-          where: {
-            parentId: ctx.user.organizationId,
-          },
-          select: {
-            id: true,
-          },
-        });
-        if (teamsFromOrg.length === 0) {
-          return emptyResponseEventsByStatus;
-        }
-        teamConditional = {
-          id: {
-            in: [ctx.user.organizationId, ...teamsFromOrg.map((t) => t.id)],
-          },
-        };
-        const usersFromOrg = await ctx.insightsDb.membership.findMany({
-          where: {
-            team: teamConditional,
-            accepted: true,
-          },
-          select: {
-            userId: true,
-          },
-        });
-        const userIdsFromOrg = usersFromOrg.map((u) => u.userId);
-        whereConditional = {
-          ...whereConditional,
-          OR: [
-            {
-              teamId: {
-                in: [ctx.user.organizationId, ...teamsFromOrg.map((t) => t.id)],
-              },
-              isTeamBooking: true,
-            },
-            {
-              userId: {
-                in: userIdsFromOrg,
-              },
-              isTeamBooking: false,
-            },
-          ],
-        };
-      }
-
-      if (teamId && !isAll) {
-        const usersFromTeam = await ctx.insightsDb.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,
-            },
-          ],
-        };
-      }
+      const { whereCondition: whereConditional } = r;
 
       const baseWhereCondition = {
         ...whereConditional,
@@ -272,7 +304,6 @@ export const insightsRouter = router({
           gte: lastPeriodStartDate.toDate(),
           lte: lastPeriodEndDate.toDate(),
         },
-        teamId: teamId,
       };
 
       const [
@@ -364,7 +395,7 @@ export const insightsRouter = router({
   eventsTimeline: userBelongsToTeamProcedure
     .input(
       z.object({
-        teamId: z.coerce.number().optional().nullable(),
+        teamId: z.coerce.number().nullish(),
         startDate: z.string(),
         endDate: z.string(),
         eventTypeId: z.coerce.number().optional(),
@@ -406,103 +437,20 @@ export const insightsRouter = router({
           timeView = "day";
         }
       }
+      const r = await buildBaseWhereCondition({
+        teamId,
+        eventTypeId,
+        memberUserId,
+        userId: selfUserId,
+        isAll,
+        ctx: {
+          userIsOwnerAdminOfParentTeam: ctx.user.isOwnerAdminOfParentTeam,
+          userOrganizationId: ctx.user.organizationId,
+          insightsDb: ctx.insightsDb,
+        },
+      });
 
-      let whereConditional: Prisma.BookingTimeStatusWhereInput = {};
-
-      if (isAll && ctx.user.isOwnerAdminOfParentTeam && ctx.user.organizationId) {
-        const teamsFromOrg = await ctx.insightsDb.team.findMany({
-          where: {
-            parentId: user.organizationId,
-          },
-          select: {
-            id: true,
-          },
-        });
-
-        const usersFromOrg = await ctx.insightsDb.membership.findMany({
-          where: {
-            teamId: {
-              in: [ctx.user.organizationId, ...teamsFromOrg.map((t) => t.id)],
-            },
-            accepted: true,
-          },
-          select: {
-            userId: true,
-          },
-        });
-        const userIdsFromOrg = usersFromOrg.map((u) => u.userId);
-
-        whereConditional = {
-          OR: [
-            {
-              teamId: {
-                in: [ctx.user.organizationId, ...teamsFromOrg.map((t) => t.id)],
-              },
-              isTeamBooking: true,
-            },
-            {
-              userId: {
-                in: userIdsFromOrg,
-              },
-              isTeamBooking: false,
-            },
-          ],
-        };
-      }
-
-      if (teamId && !isAll) {
-        const usersFromTeam = await ctx.insightsDb.membership.findMany({
-          where: {
-            teamId,
-            accepted: true,
-          },
-          select: {
-            userId: true,
-          },
-        });
-        const userIdsFromTeams = usersFromTeam.map((u) => u.userId);
-
-        whereConditional = {
-          OR: [
-            {
-              teamId,
-              isTeamBooking: true,
-            },
-            {
-              userId: {
-                in: userIdsFromTeams,
-              },
-              isTeamBooking: false,
-            },
-          ],
-        };
-      }
-
-      if (memberUserId) {
-        whereConditional = {
-          ...whereConditional,
-          userId: memberUserId,
-        };
-      }
-
-      if (eventTypeId && !!whereConditional) {
-        whereConditional = {
-          OR: [
-            {
-              eventTypeId,
-            },
-            {
-              eventParentId: eventTypeId,
-            },
-          ],
-        };
-      }
-
-      if (selfUserId && !!whereConditional) {
-        // In this delete we are deleting the teamId filter
-        whereConditional["userId"] = selfUserId;
-        whereConditional["teamId"] = null;
-      }
+      let { whereCondition: whereConditional } = r;
 
       // Get timeline data
       const timeline = await EventsInsights.getTimeLine(timeView, dayjs(startDate), dayjs(endDate));
@@ -556,7 +504,8 @@ export const insightsRouter = router({
     .input(
       z.object({
         memberUserId: z.coerce.number().optional(),
-        teamId: z.coerce.number().optional().nullable(),
+        eventTypeId: z.coerce.number().optional(),
+        teamId: z.coerce.number().nullish(),
         startDate: z.string(),
         endDate: z.string(),
         userId: z.coerce.number().optional(),
@@ -564,7 +513,7 @@ export const insightsRouter = router({
       })
     )
     .query(async ({ ctx, input }) => {
-      const { teamId, startDate, endDate, memberUserId, userId, isAll } = input;
+      const { teamId, startDate, endDate, memberUserId, userId, isAll, eventTypeId } = input;
 
       const user = ctx.user;
 
@@ -576,94 +525,29 @@ export const insightsRouter = router({
         return [];
       }
 
-      let bookingWhere: Prisma.BookingTimeStatusWhereInput = {
+      const r = await buildBaseWhereCondition({
+        teamId,
+        eventTypeId,
+        memberUserId,
+        userId,
+        isAll,
+        ctx: {
+          userIsOwnerAdminOfParentTeam: ctx.user.isOwnerAdminOfParentTeam,
+          userOrganizationId: ctx.user.organizationId,
+          insightsDb: ctx.insightsDb,
+        },
+      });
+
+      let { whereCondition: bookingWhere } = r;
+
+      bookingWhere = {
+        ...bookingWhere,
         createdAt: {
-          gte: dayjs(startDate).startOf("day").toDate(),
-          lte: dayjs(endDate).endOf("day").toDate(),
+          gte: dayjs(startDate).toISOString(),
+          lte: dayjs(endDate).toISOString(),
         },
       };
 
-      if (isAll && ctx.user.isOwnerAdminOfParentTeam && ctx.user.organizationId) {
-        const teamsFromOrg = await ctx.insightsDb.team.findMany({
-          where: {
-            parentId: user.organizationId,
-          },
-          select: {
-            id: true,
-          },
-        });
-
-        const usersFromOrg = await ctx.insightsDb.membership.findMany({
-          where: {
-            teamId: {
-              in: [ctx.user.organizationId, ...teamsFromOrg.map((t) => t.id)],
-            },
-            accepted: true,
-          },
-          select: {
-            userId: true,
-          },
-        });
-        const userIdsFromOrg = usersFromOrg.map((u) => u.userId);
-
-        bookingWhere = {
-          ...bookingWhere,
-          OR: [
-            {
-              teamId: {
-                in: [ctx.user.organizationId, ...teamsFromOrg.map((t) => t.id)],
-              },
-              isTeamBooking: true,
-            },
-            {
-              userId: {
-                in: userIdsFromOrg,
-              },
-              isTeamBooking: false,
-            },
-          ],
-        };
-      }
-
-      if (teamId && !isAll) {
-        const usersFromTeam = await ctx.insightsDb.membership.findMany({
-          where: {
-            teamId,
-            accepted: true,
-          },
-          select: {
-            userId: true,
-          },
-        });
-        const userIdsFromTeams = usersFromTeam.map((u) => u.userId);
-
-        bookingWhere = {
-          ...bookingWhere,
-          OR: [
-            {
-              teamId,
-              isTeamBooking: true,
-            },
-            {
-              userId: {
-                in: userIdsFromTeams,
-              },
-              isTeamBooking: false,
-            },
-          ],
-        };
-      }
-
-      if (userId) {
-        bookingWhere.userId = userId;
-        // Don't take bookings from any team
-        bookingWhere.teamId = null;
-      }
-
-      if (memberUserId) {
-        bookingWhere.userId = memberUserId;
-      }
-
       const bookingsFromSelected = await ctx.insightsDb.bookingTimeStatus.groupBy({
         by: ["eventTypeId"],
         where: bookingWhere,
@@ -761,7 +645,8 @@ export const insightsRouter = router({
     .input(
       z.object({
         memberUserId: z.coerce.number().optional(),
-        teamId: z.coerce.number().optional().nullable(),
+        eventTypeId: z.coerce.number().optional(),
+        teamId: z.coerce.number().nullish(),
         startDate: z.string(),
         endDate: z.string(),
         userId: z.coerce.number().optional(),
@@ -775,6 +660,7 @@ export const insightsRouter = router({
         endDate: endDateString,
         memberUserId,
         userId,
+        eventTypeId,
         isAll,
       } = input;
 
@@ -789,78 +675,18 @@ export const insightsRouter = router({
       const startDate = dayjs(startDateString);
       const endDate = dayjs(endDateString);
 
-      let whereConditional: Prisma.BookingTimeStatusWhereInput = {
-        createdAt: {
-          gte: dayjs(startDate).startOf("day").toDate(),
-          lte: dayjs(endDate).endOf("day").toDate(),
+      const { whereCondition: whereConditional } = await buildBaseWhereCondition({
+        teamId,
+        eventTypeId,
+        memberUserId,
+        userId,
+        isAll,
+        ctx: {
+          userIsOwnerAdminOfParentTeam: ctx.user.isOwnerAdminOfParentTeam,
+          userOrganizationId: ctx.user.organizationId,
+          insightsDb: ctx.insightsDb,
         },
-      };
-      if (userId) {
-        delete whereConditional.teamId;
-        whereConditional["userId"] = userId;
-      }
-
-      if (isAll && ctx.user.isOwnerAdminOfParentTeam && ctx.user.organizationId) {
-        const teamsFromOrg = await ctx.insightsDb.team.findMany({
-          where: {
-            parentId: ctx.user?.organizationId,
-          },
-          select: {
-            id: true,
-          },
-        });
-        whereConditional = {
-          ...whereConditional,
-          OR: [
-            {
-              teamId: {
-                in: [ctx.user?.organizationId, ...teamsFromOrg.map((t) => t.id)],
-              },
-              isTeamBooking: true,
-            },
-            {
-              userId: ctx.user?.id,
-              isTeamBooking: false,
-            },
-          ],
-        };
-      }
-
-      if (teamId && !isAll) {
-        const usersFromTeam = await ctx.insightsDb.membership.findMany({
-          where: {
-            teamId,
-            accepted: true,
-          },
-          select: {
-            userId: true,
-          },
-        });
-        const userIdsFromTeams = usersFromTeam.map((u) => u.userId);
-
-        whereConditional = {
-          ...whereConditional,
-          OR: [
-            {
-              teamId,
-              isTeamBooking: true,
-            },
-            {
-              userId: {
-                in: userIdsFromTeams,
-              },
-              isTeamBooking: false,
-            },
-          ],
-        };
-      }
-
-      if (memberUserId) {
-        whereConditional = {
-          userId: memberUserId,
-          teamId,
-        };
-      }
+      });
 
       const timeView = EventsInsights.getTimeView("week", startDate, endDate);
       const timeLine = await EventsInsights.getTimeLine("week", startDate, endDate);
@@ -911,22 +737,40 @@ export const insightsRouter = router({
   membersWithMostBookings: userBelongsToTeamProcedure
     .input(
       z.object({
-        teamId: z.coerce.number().nullable().optional(),
+        memberUserId: z.coerce.number().optional(),
+        eventTypeId: z.coerce.number().optional(),
+        teamId: z.coerce.number().nullish(),
         startDate: z.string(),
         endDate: z.string(),
-        eventTypeId: z.coerce.number().optional(),
+        userId: z.coerce.number().optional(),
         isAll: z.boolean().optional(),
       })
     )
     .query(async ({ ctx, input }) => {
-      const { teamId, startDate, endDate, eventTypeId, isAll } = input;
+      const { teamId, startDate, endDate, eventTypeId, isAll, userId, memberUserId } = input;
 
       if (!teamId) {
         return [];
       }
       const user = ctx.user;
 
-      const bookingWhere: Prisma.BookingTimeStatusWhereInput = {
+      const r = await buildBaseWhereCondition({
+        teamId,
+        eventTypeId,
+        memberUserId,
+        userId,
+        isAll,
+        ctx: {
+          userIsOwnerAdminOfParentTeam: ctx.user.isOwnerAdminOfParentTeam,
+          userOrganizationId: ctx.user.organizationId,
+          insightsDb: ctx.insightsDb,
+        },
+      });
+
+      let { whereCondition: bookingWhere } = r;
+
+      bookingWhere = {
+        ...bookingWhere,
         teamId,
         createdAt: {
           gte: dayjs(startDate).startOf("day").toDate(),
@@ -934,81 +778,6 @@ export const insightsRouter = router({
         },
       };
 
-      if (eventTypeId) {
-        bookingWhere["OR"] = [
-          {
-            eventTypeId,
-          },
-          {
-            eventParentId: eventTypeId,
-          },
-        ];
-      }
-
-      if (isAll && user.isOwnerAdminOfParentTeam && user.organizationId) {
-        delete bookingWhere.teamId;
-        const teamsFromOrg = await ctx.insightsDb.team.findMany({
-          where: {
-            parentId: user?.organizationId,
-          },
-          select: {
-            id: true,
-          },
-        });
-        const usersFromTeam = await ctx.insightsDb.membership.findMany({
-          where: {
-            teamId: {
-              in: [user?.organizationId, ...teamsFromOrg.map((t) => t.id)],
-            },
-            accepted: true,
-          },
-          select: {
-            userId: true,
-          },
-        });
-        bookingWhere["OR"] = [
-          {
-            teamId: {
-              in: [user?.organizationId, ...teamsFromOrg.map((t) => t.id)],
-            },
-            isTeamBooking: true,
-          },
-          {
-            userId: {
-              in: usersFromTeam.map((u) => u.userId),
-            },
-            isTeamBooking: false,
-          },
-        ];
-      }
-
-      if (teamId && !isAll) {
-        const usersFromTeam = await ctx.insightsDb.membership.findMany({
-          where: {
-            teamId,
-            accepted: true,
-          },
-          select: {
-            userId: true,
-          },
-        });
-        const userIdsFromTeams = usersFromTeam.map((u) => u.userId);
-        delete bookingWhere.eventTypeId;
-        delete bookingWhere.teamId;
-        bookingWhere["OR"] = [
-          {
-            teamId,
-            isTeamBooking: true,
-          },
-          {
-            userId: {
-              in: userIdsFromTeams,
-            },
-            isTeamBooking: false,
-          },
-        ];
-      }
-
       const bookingsFromTeam = await ctx.insightsDb.bookingTimeStatus.groupBy({
         by: ["userId"],
         where: bookingWhere,
@@ -1061,7 +830,9 @@ export const insightsRouter = router({
   membersWithLeastBookings: userBelongsToTeamProcedure
     .input(
       z.object({
-        teamId: z.coerce.number().nullable().optional(),
+        userId: z.coerce.number().optional(),
+        memberUserId: z.coerce.number().optional(),
+        teamId: z.coerce.number().nullish(),
         startDate: z.string(),
         endDate: z.string(),
         eventTypeId: z.coerce.number().optional(),
@@ -1069,13 +840,29 @@ export const insightsRouter = router({
       })
     )
     .query(async ({ ctx, input }) => {
-      const { teamId, startDate, endDate, eventTypeId, isAll } = input;
+      const { teamId, startDate, endDate, eventTypeId, isAll, userId, memberUserId } = input;
       if (!teamId) {
         return [];
       }
       const user = ctx.user;
 
-      const bookingWhere: Prisma.BookingTimeStatusWhereInput = {
+      const r = await buildBaseWhereCondition({
+        teamId,
+        eventTypeId,
+        memberUserId,
+        userId,
+        isAll,
+        ctx: {
+          userIsOwnerAdminOfParentTeam: ctx.user.isOwnerAdminOfParentTeam,
+          userOrganizationId: ctx.user.organizationId,
+          insightsDb: ctx.insightsDb,
+        },
+      });
+
+      let { whereCondition: bookingWhere } = r;
+
+      bookingWhere = {
+        ...bookingWhere,
         teamId,
         eventTypeId,
         createdAt: {
@@ -1084,69 +871,6 @@ export const insightsRouter = router({
         },
       };
 
-      if (isAll && user.isOwnerAdminOfParentTeam) {
-        delete bookingWhere.teamId;
-        const teamsFromOrg = await ctx.insightsDb.team.findMany({
-          where: {
-            parentId: user?.organizationId,
-          },
-          select: {
-            id: true,
-          },
-        });
-        const usersFromTeam = await ctx.insightsDb.membership.findMany({
-          where: {
-            teamId: {
-              in: teamsFromOrg.map((t) => t.id),
-            },
-            accepted: true,
-          },
-          select: {
-            userId: true,
-          },
-        });
-
-        bookingWhere["OR"] = [
-          {
-            teamId: {
-              in: teamsFromOrg.map((t) => t.id),
-            },
-            isTeamBooking: true,
-          },
-          {
-            userId: {
-              in: usersFromTeam.map((u) => u.userId),
-            },
-            isTeamBooking: false,
-          },
-        ];
-      }
-
-      if (teamId && !isAll) {
-        const usersFromTeam = await ctx.insightsDb.membership.findMany({
-          where: {
-            teamId,
-            accepted: true,
-          },
-          select: {
-            userId: true,
-          },
-        });
-        const userIdsFromTeams = usersFromTeam.map((u) => u.userId);
-        bookingWhere["OR"] = [
-          {
-            teamId,
-            isTeamBooking: true,
-          },
-          {
-            userId: {
-              in: userIdsFromTeams,
-            },
-            isTeamBooking: false,
-          },
-        ];
-      }
-
       const bookingsFromTeam = await ctx.insightsDb.bookingTimeStatus.groupBy({
         by: ["userId"],
         where: bookingWhere,
@@ -1369,8 +1093,8 @@ export const insightsRouter = router({
   eventTypeList: userBelongsToTeamProcedure
     .input(
       z.object({
-        teamId: z.coerce.number().optional().nullable(),
-        userId: z.coerce.number().optional().nullable(),
+        teamId: z.coerce.number().nullish(),
+        userId: z.coerce.number().nullish(),
         isAll: z.boolean().optional(),
       })
     )
@@ -1479,7 +1203,9 @@ export const insightsRouter = router({
   recentRatings: userBelongsToTeamProcedure
     .input(
       z.object({
-        teamId: z.coerce.number().nullable().optional(),
+        userId: z.coerce.number().optional(),
+        memberUserId: z.coerce.number().optional(),
+        teamId: z.coerce.number().nullish(),
         startDate: z.string(),
         endDate: z.string(),
         eventTypeId: z.coerce.number().optional(),
@@ -1487,13 +1213,29 @@ export const insightsRouter = router({
       })
     )
     .query(async ({ ctx, input }) => {
-      const { teamId, startDate, endDate, eventTypeId, isAll } = input;
+      const { teamId, startDate, endDate, eventTypeId, isAll, userId, memberUserId } = input;
       if (!teamId) {
         return [];
       }
       const user = ctx.user;
 
-      const bookingWhere: Prisma.BookingTimeStatusWhereInput = {
+      const r = await buildBaseWhereCondition({
+        teamId,
+        eventTypeId,
+        memberUserId,
+        userId,
+        isAll,
+        ctx: {
+          userIsOwnerAdminOfParentTeam: ctx.user.isOwnerAdminOfParentTeam,
+          userOrganizationId: ctx.user.organizationId,
+          insightsDb: ctx.insightsDb,
+        },
+      });
+
+      let { whereCondition: bookingWhere } = r;
+
+      bookingWhere = {
+        ...bookingWhere,
         teamId,
         eventTypeId,
         createdAt: {
@@ -1526,6 +1268,7 @@ export const insightsRouter = router({
         });
 
         bookingWhere["OR"] = [
+          ...(bookingWhere.OR || []),
           {
             teamId: {
               in: teamsFromOrg.map((t) => t.id),
@@ -1541,30 +1284,6 @@ export const insightsRouter = router({
         ];
       }
 
-      if (teamId && !isAll) {
-        const usersFromTeam = await ctx.insightsDb.membership.findMany({
-          where: {
-            teamId,
-            accepted: true,
-          },
-          select: {
-            userId: true,
-          },
-        });
-        const userIdsFromTeams = usersFromTeam.map((u) => u.userId);
-        bookingWhere["OR"] = [
-          {
-            teamId,
-            isTeamBooking: true,
-          },
-          {
-            userId: {
-              in: userIdsFromTeams,
-            },
-            isTeamBooking: false,
-          },
-        ];
-      }
       const bookingsFromTeam = await ctx.insightsDb.bookingTimeStatus.findMany({
         where: bookingWhere,
         orderBy: {
@@ -1614,7 +1333,9 @@ export const insightsRouter = router({
   membersWithMostNoShow: userBelongsToTeamProcedure
     .input(
       z.object({
-        teamId: z.coerce.number().nullable().optional(),
+        userId: z.coerce.number().optional(),
+        memberUserId: z.coerce.number().optional(),
+        teamId: z.coerce.number().nullish(),
         startDate: z.string(),
         endDate: z.string(),
         eventTypeId: z.coerce.number().optional(),
@@ -1622,13 +1343,27 @@ export const insightsRouter = router({
       })
     )
     .query(async ({ ctx, input }) => {
-      const { teamId, startDate, endDate, eventTypeId, isAll } = input;
+      const { teamId, startDate, endDate, eventTypeId, isAll, userId, memberUserId } = input;
       if (!teamId) {
         return [];
       }
       const user = ctx.user;
+      const r = await buildBaseWhereCondition({
+        teamId,
+        eventTypeId,
+        memberUserId,
+        userId,
+        isAll,
+        ctx: {
+          userIsOwnerAdminOfParentTeam: ctx.user.isOwnerAdminOfParentTeam,
+          userOrganizationId: ctx.user.organizationId,
+          insightsDb: ctx.insightsDb,
+        },
+      });
+      let { whereCondition: bookingWhere } = r;
 
-      const bookingWhere: Prisma.BookingTimeStatusWhereInput = {
+      bookingWhere = {
+        ...bookingWhere,
         teamId,
         eventTypeId,
         createdAt: {
@@ -1638,68 +1373,6 @@ export const insightsRouter = router({
         noShowHost: true,
       };
 
-      if (isAll && user.isOwnerAdminOfParentTeam) {
-        delete bookingWhere.teamId;
-        const teamsFromOrg = await ctx.insightsDb.team.findMany({
-          where: {
-            parentId: user?.organizationId,
-          },
-          select: {
-            id: true,
-          },
-        });
-        const usersFromTeam = await ctx.insightsDb.membership.findMany({
-          where: {
-            teamId: {
-              in: teamsFromOrg.map((t) => t.id),
-            },
-            accepted: true,
-          },
-          select: {
-            userId: true,
-          },
-        });
-
-        bookingWhere["OR"] = [
-          {
-            teamId: {
-              in: teamsFromOrg.map((t) => t.id),
-            },
-            isTeamBooking: true,
-          },
-          {
-            userId: {
-              in: usersFromTeam.map((u) => u.userId),
-            },
-            isTeamBooking: false,
-          },
-        ];
-      }
-
-      if (teamId && !isAll) {
-        const usersFromTeam = await ctx.insightsDb.membership.findMany({
-          where: {
-            teamId,
-            accepted: true,
-          },
-          select: {
-            userId: true,
-          },
-        });
-        const userIdsFromTeams = usersFromTeam.map((u) => u.userId);
-        bookingWhere["OR"] = [
-          {
-            teamId,
-            isTeamBooking: true,
-          },
-          {
-            userId: {
-              in: userIdsFromTeams,
-            },
-            isTeamBooking: false,
-          },
-        ];
-      }
       const bookingsFromTeam = await ctx.insightsDb.bookingTimeStatus.groupBy({
         by: ["userId"],
         where: bookingWhere,
@@ -1749,7 +1422,9 @@ export const insightsRouter = router({
   membersWithHighestRatings: userBelongsToTeamProcedure
     .input(
       z.object({
-        teamId: z.coerce.number().nullable().optional(),
+        userId: z.coerce.number().optional(),
+        memberUserId: z.coerce.number().optional(),
+        teamId: z.coerce.number().nullish(),
         startDate: z.string(),
         endDate: z.string(),
         eventTypeId: z.coerce.number().optional(),
@@ -1757,13 +1432,27 @@ export const insightsRouter = router({
       })
     )
     .query(async ({ ctx, input }) => {
-      const { teamId, startDate, endDate, eventTypeId, isAll } = input;
+      const { teamId, startDate, endDate, eventTypeId, isAll, memberUserId, userId } = input;
       if (!teamId) {
         return [];
       }
       const user = ctx.user;
 
-      const bookingWhere: Prisma.BookingTimeStatusWhereInput = {
+      const r = await buildBaseWhereCondition({
+        teamId,
+        eventTypeId,
+        memberUserId,
+        userId,
+        isAll,
+        ctx: {
+          userIsOwnerAdminOfParentTeam: ctx.user.isOwnerAdminOfParentTeam,
+          userOrganizationId: ctx.user.organizationId,
+          insightsDb: ctx.insightsDb,
+        },
+      });
+      let { whereCondition: bookingWhere } = r;
+
+      bookingWhere = {
         teamId,
         eventTypeId,
         createdAt: {
@@ -1773,68 +1462,6 @@ export const insightsRouter = router({
         rating: { not: null },
       };
 
-      if (isAll && user.isOwnerAdminOfParentTeam) {
-        delete bookingWhere.teamId;
-        const teamsFromOrg = await ctx.insightsDb.team.findMany({
-          where: {
-            parentId: user?.organizationId,
-          },
-          select: {
-            id: true,
-          },
-        });
-        const usersFromTeam = await ctx.insightsDb.membership.findMany({
-          where: {
-            teamId: {
-              in: teamsFromOrg.map((t) => t.id),
-            },
-            accepted: true,
-          },
-          select: {
-            userId: true,
-          },
-        });
-
-        bookingWhere["OR"] = [
-          {
-            teamId: {
-              in: teamsFromOrg.map((t) => t.id),
-            },
-            isTeamBooking: true,
-          },
-          {
-            userId: {
-              in: usersFromTeam.map((u) => u.userId),
-            },
-            isTeamBooking: false,
-          },
-        ];
-      }
-
-      if (teamId && !isAll) {
-        const usersFromTeam = await ctx.insightsDb.membership.findMany({
-          where: {
-            teamId,
-            accepted: true,
-          },
-          select: {
-            userId: true,
-          },
-        });
-        const userIdsFromTeams = usersFromTeam.map((u) => u.userId);
-        bookingWhere["OR"] = [
-          {
-            teamId,
-            isTeamBooking: true,
-          },
-          {
-            userId: {
-              in: userIdsFromTeams,
-            },
-            isTeamBooking: false,
-          },
-        ];
-      }
       const bookingsFromTeam = await ctx.insightsDb.bookingTimeStatus.groupBy({
         by: ["userId"],
         where: bookingWhere,
@@ -1884,7 +1511,9 @@ export const insightsRouter = router({
   membersWithLowestRatings: userBelongsToTeamProcedure
     .input(
       z.object({
-        teamId: z.coerce.number().nullable().optional(),
+        userId: z.coerce.number().optional(),
+        memberUserId: z.coerce.number().optional(),
+        teamId: z.coerce.number().nullish(),
         startDate: z.string(),
         endDate: z.string(),
         eventTypeId: z.coerce.number().optional(),
@@ -1892,13 +1521,27 @@ export const insightsRouter = router({
       })
     )
     .query(async ({ ctx, input }) => {
-      const { teamId, startDate, endDate, eventTypeId, isAll } = input;
+      const { teamId, startDate, endDate, eventTypeId, isAll, memberUserId, userId } = input;
       if (!teamId) {
         return [];
       }
       const user = ctx.user;
 
-      const bookingWhere: Prisma.BookingTimeStatusWhereInput = {
+      const r = await buildBaseWhereCondition({
+        teamId,
+        eventTypeId,
+        memberUserId,
+        userId,
+        isAll,
+        ctx: {
+          userIsOwnerAdminOfParentTeam: ctx.user.isOwnerAdminOfParentTeam,
+          userOrganizationId: ctx.user.organizationId,
+          insightsDb: ctx.insightsDb,
+        },
+      });
+
+      let { whereCondition: bookingWhere } = r;
+      bookingWhere = {
         teamId,
         eventTypeId,
         createdAt: {
@@ -1908,68 +1551,6 @@ export const insightsRouter = router({
         rating: { not: null },
       };
 
-      if (isAll && user.isOwnerAdminOfParentTeam) {
-        delete bookingWhere.teamId;
-        const teamsFromOrg = await ctx.insightsDb.team.findMany({
-          where: {
-            parentId: user?.organizationId,
-          },
-          select: {
-            id: true,
-          },
-        });
-        const usersFromTeam = await ctx.insightsDb.membership.findMany({
-          where: {
-            teamId: {
-              in: teamsFromOrg.map((t) => t.id),
-            },
-            accepted: true,
-          },
-          select: {
-            userId: true,
-          },
-        });
-
-        bookingWhere["OR"] = [
-          {
-            teamId: {
-              in: teamsFromOrg.map((t) => t.id),
-            },
-            isTeamBooking: true,
-          },
-          {
-            userId: {
-              in: usersFromTeam.map((u) => u.userId),
-            },
-            isTeamBooking: false,
-          },
-        ];
-      }
-
-      if (teamId && !isAll) {
-        const usersFromTeam = await ctx.insightsDb.membership.findMany({
-          where: {
-            teamId,
-            accepted: true,
-          },
-          select: {
-            userId: true,
-          },
-        });
-        const userIdsFromTeams = usersFromTeam.map((u) => u.userId);
-        bookingWhere["OR"] = [
-          {
-            teamId,
-            isTeamBooking: true,
-          },
-          {
-            userId: {
-              in: userIdsFromTeams,
-            },
-            isTeamBooking: false,
-          },
-        ];
-      }
       const bookingsFromTeam = await ctx.insightsDb.bookingTimeStatus.groupBy({
         by: ["userId"],
         where: bookingWhere,
diff --git a/packages/ui/components/form/date-range-picker/Calendar.tsx b/packages/ui/components/form/date-range-picker/Calendar.tsx
index 3a58602edc..69b19a46dd 100644
--- a/packages/ui/components/form/date-range-picker/Calendar.tsx
+++ b/packages/ui/components/form/date-range-picker/Calendar.tsx
@@ -11,10 +11,18 @@ import { buttonClasses } from "../../button/Button";
 
 export type CalendarProps = React.ComponentProps<typeof DayPicker>;
 
-function Calendar({ className, classNames, showOutsideDays = true, ...props }: CalendarProps) {
+function Calendar({
+  className,
+  classNames,
+  fromDate,
+  toDate,
+  showOutsideDays = true,
+  ...props
+}: CalendarProps) {
   return (
     <DayPicker
-      fromDate={new Date()}
+      fromDate={fromDate || new Date()}
+      toDate={toDate || undefined}
       showOutsideDays={showOutsideDays}
       className={cn("p-3", className)}
       classNames={{
diff --git a/packages/ui/components/form/date-range-picker/DateRangePicker.tsx b/packages/ui/components/form/date-range-picker/DateRangePicker.tsx
index 5da010d8af..addd2e981e 100644
--- a/packages/ui/components/form/date-range-picker/DateRangePicker.tsx
+++ b/packages/ui/components/form/date-range-picker/DateRangePicker.tsx
@@ -14,11 +14,15 @@ type DatePickerWithRangeProps = {
   dates: { startDate: Date; endDate?: Date };
   onDatesChange: ({ startDate, endDate }: { startDate?: Date; endDate?: Date }) => void;
   disabled?: boolean;
+  minDate?: Date;
+  maxDate?: Date;
 };
 
 export function DatePickerWithRange({
   className,
   dates,
+  minDate,
+  maxDate,
   onDatesChange,
   disabled,
 }: React.HTMLAttributes<HTMLDivElement> & DatePickerWithRangeProps) {
@@ -56,6 +60,8 @@ export function DatePickerWithRange({
         <PopoverContent className="w-auto p-0" align="start">
           <Calendar
             initialFocus
+            fromDate={minDate}
+            toDate={maxDate}
             mode="range"
             defaultMonth={dates?.startDate}
             selected={{ from: dates?.startDate, to: dates?.endDate }}