@sellout/models 0.0.57 → 0.0.59

package/src/utils/AnalyticsUtil.ts

@@ -0,0 +1,838 @@
+import IAnalytics, {
+  AnalyticsDurationEnum,
+  AnalyticsIntervalEnum,
+  AnalyticsTypeEnum,
+  AnalyticsValueTypeEnum,
+  ICoordinate,
+} from "../interfaces/IAnalytics";
+import IOrder from "../interfaces/IOrder";
+import IOrderTicket from "../interfaces/IOrderTicket";
+import IOrderUpgrade from "../interfaces/IOrderUpgrade";
+import { OrderTypeEnum } from "../interfaces/IOrderType";
+import * as Time from "@sellout/utils/.dist/time";
+import * as Price from '@sellout/utils/.dist/price';
+
+interface IDuration {
+  startsAt: number;
+  endsAt: number;
+}
+
+const sum = (array: number[]) => (array.length ? array.pop() + sum(array) : 0);
+
+const makeArray = (intervalNum: number) => new Array(intervalNum).fill(0);
+
+type SumFn = (orders: IOrder[]) => number;
+
+const makeCoordinates = (
+  orders: IOrder[],
+  intervalInfo: IntervalInfo,
+  sumFn: SumFn
+) => {
+  const { startDate, intervalLength, intervalNum, interval } = intervalInfo;
+
+  const coordinates =  makeArray(intervalNum).map((_, index) => {
+    // set x to beginning second of interval
+    let x: number;
+    switch(interval) {
+      case AnalyticsIntervalEnum.Hour:
+        x = Time.getStartOfHour(index * intervalLength + startDate);
+        break;
+      case AnalyticsIntervalEnum.Day:
+        x = Time.getStartOfDay(index * intervalLength + startDate);
+        break;
+      case AnalyticsIntervalEnum.Week:
+        x = Time.getStartOfWeek(index * intervalLength + startDate);
+        break;
+      case AnalyticsIntervalEnum.Month:
+        x = Time.getStartOfMonth(index * intervalLength + startDate);
+        break;
+      case AnalyticsIntervalEnum.Year:
+        x = Time.getStartOfYear(index * intervalLength + startDate);
+        break;
+      default:
+        x = Time.getStartOfDay(index * intervalLength + startDate);
+        break;
+    }
+
+    const y = sumFn(orders
+      .filter((order) => {
+        const createdAt = order.createdAt as number;
+        return x <= createdAt && createdAt < x + intervalLength;
+      }));
+
+    return {
+      x,
+      y,
+    };
+  });
+
+  // quick solution to remove duplicated coordinates
+  // real issue is probably above..
+  const uniqueCoords = Array.from(new Set(coordinates.map(a => a.x)))
+    .map(x => {
+      return coordinates.find(a => a.x === x)
+    });
+  return uniqueCoords as ICoordinate[];
+};
+
+const makeAnalytics = (
+  type: AnalyticsTypeEnum,
+  orders: IOrder[],
+  intervalInfo: IntervalInfo,
+  valueType: AnalyticsValueTypeEnum,
+  coordinatesSumFn: SumFn,
+  segmentTypes?: string[],
+  segmentCoordinatesHOSumFn?: (segmentType: string) => SumFn
+) => {
+  const { interval, intervalOptions } = intervalInfo;
+  const segments =
+    segmentTypes?.map(
+      (segmentType: string): IAnalytics => {
+        const coordinates = segmentCoordinatesHOSumFn
+          ? makeCoordinates(
+            orders,
+            intervalInfo,
+            segmentCoordinatesHOSumFn(segmentType)
+          )
+          : [];
+
+        const segment: IAnalytics = {
+          label: segmentType,
+          interval: interval,
+          intervalOptions: intervalOptions,
+          coordinates,
+          segments: [],
+          type: valueType,
+        };
+
+        return segment;
+      }
+    ) ?? [];
+
+  const coordinates = makeCoordinates(orders, intervalInfo, coordinatesSumFn);
+
+  const analytics: IAnalytics = {
+    label: type,
+    interval: interval,
+    intervalOptions: intervalOptions,
+    coordinates,
+    segments,
+    type: valueType,
+  };
+
+  return analytics;
+};
+
+const intervalMap = {
+  [AnalyticsIntervalEnum.Hour]: 60 * 60,
+  [AnalyticsIntervalEnum.Day]: 60 * 60 * 24,
+  [AnalyticsIntervalEnum.Week]: 60 * 60 * 24 * 7,
+  [AnalyticsIntervalEnum.Month]: 60 * 60 * 24 * 30,
+  [AnalyticsIntervalEnum.Year]: 60 * 60 * 24 * 365,
+};
+
+const orderedIntervals = [
+  AnalyticsIntervalEnum.Hour,
+  AnalyticsIntervalEnum.Day,
+  AnalyticsIntervalEnum.Week,
+  AnalyticsIntervalEnum.Month,
+  AnalyticsIntervalEnum.Year,
+];
+
+const maxDuration = (interval: AnalyticsIntervalEnum): number => {
+  return intervalMap[interval] * 60;
+}
+
+const getIntervalFromDuration = (duration: number): AnalyticsIntervalEnum => {
+  const maxHour = maxDuration(AnalyticsIntervalEnum.Hour);
+  const maxDay = maxDuration(AnalyticsIntervalEnum.Day);
+  const maxWeek = maxDuration(AnalyticsIntervalEnum.Week);
+  const maxMonth = maxDuration(AnalyticsIntervalEnum.Month);
+
+  if(duration <= maxHour) {
+    return AnalyticsIntervalEnum.Hour;
+  } else if(duration <= maxDay) {
+    return AnalyticsIntervalEnum.Day;
+  } else if(duration <= maxWeek) {
+    return AnalyticsIntervalEnum.Week
+  } else if(duration <= maxMonth) {
+    return AnalyticsIntervalEnum.Month;
+  } else {
+    return AnalyticsIntervalEnum.Year;
+  }
+}
+
+type IntervalInfo = {
+  startDate: number;
+  endDate: number;
+  duration: number;
+  interval: AnalyticsIntervalEnum;
+  intervalOptions: AnalyticsIntervalEnum[];
+  intervalLength: number;
+  intervalNum: number;
+};
+
+const getIntervalInfo = (
+  orders: IOrder[],
+  startDate?: number,
+  endDate?: number,
+  interval?: AnalyticsIntervalEnum,
+): IntervalInfo => {
+  startDate = startDate || orders[orders.length - 1]?.createdAt as number || Time.getStartOfCurrentDay();
+  endDate = endDate || orders[0]?.createdAt as number || Time.getEndOfCurrentDay();
+
+  const duration = endDate - startDate; // duration in seconds
+
+  if(!interval) {
+    interval = getIntervalFromDuration(duration);
+  }
+
+  const intervalLength = intervalMap[interval];
+  const intervalNum = Math.ceil(duration / intervalLength);
+  const intervalOptions = [interval];
+  const altIntervalIndex = orderedIntervals.indexOf(interval) + 1;
+  const altInterval = orderedIntervals[altIntervalIndex];
+  if (altInterval) intervalOptions.push(altInterval);
+
+  return {
+    startDate,
+    endDate,
+    duration,
+    interval,
+    intervalOptions,
+    intervalLength,
+    intervalNum,
+  };
+};
+
+export default {
+  fromOrders(
+    type: AnalyticsTypeEnum,
+    orders: IOrder[],
+    showSegments: boolean,
+    startDate?: number,
+    endDate?: number,
+    interval?: AnalyticsIntervalEnum,
+  ): IAnalytics {
+
+    const intervalInfo = getIntervalInfo(orders, startDate, endDate, interval);
+
+    switch (type) {
+      case AnalyticsTypeEnum.Overview:
+        return this.overview(type, orders, intervalInfo);
+
+      case AnalyticsTypeEnum.TotalSales:
+        return this.totalSales(type, orders, intervalInfo, showSegments);
+
+      case AnalyticsTypeEnum.TicketSales:
+        return this.ticketSales(type, orders, intervalInfo, showSegments);
+
+      case AnalyticsTypeEnum.TicketsSold:
+        return this.ticketsSold(type, orders, intervalInfo, showSegments);
+
+      case AnalyticsTypeEnum.TicketComps:
+        return this.ticketComps(type, orders, intervalInfo, showSegments);
+
+      case AnalyticsTypeEnum.UpgradeSales:
+        return this.upgradeSales(type, orders, intervalInfo, showSegments);
+
+      case AnalyticsTypeEnum.UpgradesSold:
+        return this.upgradesSold(type, orders, intervalInfo, showSegments);
+
+      case AnalyticsTypeEnum.TicketComps:
+        return this.ticketComps(type, orders, intervalInfo, showSegments);
+
+      case AnalyticsTypeEnum.Promotions:
+        return this.promotions(type, orders, intervalInfo, showSegments);
+
+      case AnalyticsTypeEnum.TotalOrders:
+        return this.totalOrders(type, orders, intervalInfo);
+
+      default:
+        return {
+          label: type,
+          interval: interval,
+          intervalOptions: [],
+          coordinates: [{ x: 0, y: 0}],
+          segments: [],
+          type: AnalyticsValueTypeEnum.Quantity,
+        } as IAnalytics;
+    }
+  },
+
+  overview(
+    type: AnalyticsTypeEnum,
+    orders: IOrder[],
+    intervalInfo: IntervalInfo,
+  ): IAnalytics {
+    const coordinatesSumFn = (orders: IOrder[]) =>
+      orders
+        .filter(order => order.type === OrderTypeEnum.Paid)
+        .reduce((cur, order) => cur + sum(order.tickets.map(ticket => ticket.price)) + sum(order.upgrades.map(upgrade => upgrade.price)), 0);
+
+    const coordinates = makeCoordinates(orders, intervalInfo, coordinatesSumFn);
+    const { interval, intervalOptions } = intervalInfo;
+
+
+    let segments: IAnalytics[] = [];
+    const coordinatesSumFn2 = (orders: IOrder[]) =>
+    orders
+      .filter(order => order.type === OrderTypeEnum.Paid)
+      .reduce((cur, order) => cur + order.tickets.length, 0);
+    const segmentCoordinates = makeCoordinates(orders, intervalInfo, coordinatesSumFn2);
+    let segment: IAnalytics = {
+      label: 'Tickets Sold',
+      interval: interval,
+      intervalOptions: intervalOptions,
+      coordinates: segmentCoordinates,
+      segments: [],
+      type: AnalyticsValueTypeEnum.Quantity,
+    };
+    segments.push(segment);
+    const coordinatesSumFn3 = (orders: IOrder[]) => orders.length;
+    const segmentCoordinates2 = makeCoordinates(orders, intervalInfo, coordinatesSumFn3);
+    segment = {
+      label: 'Orders',
+      interval: interval,
+      intervalOptions: intervalOptions,
+      coordinates: segmentCoordinates2,
+      segments: [],
+      type: AnalyticsValueTypeEnum.Quantity,
+    };
+    segments.push(segment);
+
+    const analytics: IAnalytics = {
+      label: 'Total Sales',
+      interval: interval,
+      intervalOptions: intervalOptions,
+      coordinates,
+      segments,
+      type: AnalyticsValueTypeEnum.Currency,
+    };
+
+    return analytics;
+  },
+
+  totalSales(
+    type: AnalyticsTypeEnum,
+    orders: IOrder[],
+    intervalInfo: IntervalInfo,
+    showSegments: boolean,
+  ): IAnalytics {
+    const coordinatesSumFn = (orders: IOrder[]) =>
+      orders
+        .filter(order => order.type === OrderTypeEnum.Paid)
+        .reduce((cur, order) => cur + sum(order.tickets.map(ticket => ticket.price)) + sum(order.upgrades.map(upgrade => upgrade.price)), 0);
+
+    let segmentTypes;
+    let segmentCoordinatesHOSumFn;
+    // if (showSegments) {
+    //   segmentTypes = Object.keys(
+    //     orders
+    //       .reduce((cur, next: IOrder) => {
+    //         return cur.concat(next.tickets);
+    //       }, [] as IOrderTicket[])
+    //       .reduce((cur, next: IOrderTicket) => {
+    //         cur[next.name] = true;
+    //         return cur;
+    //       }, {})
+    //   );
+
+    //   segmentCoordinatesHOSumFn = (segmentType: string) => (orders: IOrder[]) =>
+    //     orders
+    //       .filter(order => order.type === OrderTypeEnum.Paid)
+    //       .reduce((cur, order) => cur + sum(
+    //         order.tickets
+    //           .filter((ticket) => ticket.name === segmentType)
+    //           .map((ticket) => ticket.price)), 0);
+    // }
+
+
+    return makeAnalytics(
+      type,
+      orders,
+      intervalInfo,
+      AnalyticsValueTypeEnum.Currency,
+      coordinatesSumFn,
+      segmentTypes,
+      segmentCoordinatesHOSumFn
+    );
+  },
+
+  ticketSales(
+    type: AnalyticsTypeEnum,
+    orders: IOrder[],
+    intervalInfo: IntervalInfo,
+    showSegments: boolean,
+  ): IAnalytics {
+    const coordinatesSumFn = (orders: IOrder[]) =>
+      orders
+        .filter(order => order.type === OrderTypeEnum.Paid)
+        .reduce((cur, order) => cur + sum(order.tickets.map(ticket => ticket.price)), 0);
+
+    let segmentTypes;
+    let segmentCoordinatesHOSumFn;
+    if (showSegments) {
+      segmentTypes = Object.keys(
+        orders
+          .reduce((cur, next: IOrder) => {
+            return cur.concat(next.tickets);
+          }, [] as IOrderTicket[])
+          .reduce((cur, next: IOrderTicket) => {
+            cur[next.name] = true;
+            return cur;
+          }, {})
+      );
+
+      segmentCoordinatesHOSumFn = (segmentType: string) => (orders: IOrder[]) =>
+        orders
+          .filter(order => order.type === OrderTypeEnum.Paid)
+          .reduce((cur, order) => cur + sum(
+            order.tickets
+              .filter((ticket) => ticket.name === segmentType)
+              .map((ticket) => ticket.price)), 0);
+    }
+
+    return makeAnalytics(
+      type,
+      orders,
+      intervalInfo,
+      AnalyticsValueTypeEnum.Currency,
+      coordinatesSumFn,
+      segmentTypes,
+      segmentCoordinatesHOSumFn
+    );
+  },
+
+  ticketsSold(
+    type: AnalyticsTypeEnum,
+    orders: IOrder[],
+    intervalInfo: IntervalInfo,
+    showSegments: boolean,
+  ): IAnalytics {
+    const coordinatesSumFn = (orders: IOrder[]) =>
+      orders
+        .filter(order => order.type === OrderTypeEnum.Paid)
+        .reduce((cur, order) => cur + order.tickets.length, 0);
+
+    let segmentTypes;
+    let segmentCoordinatesHOSumFn;
+    if (showSegments) {
+      segmentTypes = Object.keys(
+        orders
+          .reduce((cur, next: IOrder) => {
+            return cur.concat(next.tickets);
+          }, [] as IOrderTicket[])
+          .reduce((cur, next: IOrderTicket) => {
+            cur[next.name] = true;
+            return cur;
+          }, {})
+      );
+
+      segmentCoordinatesHOSumFn = (segmentType: string) => (orders: IOrder[]) =>
+        orders
+          .filter(order => order.type === OrderTypeEnum.Paid)
+          .reduce((cur, order) =>
+            cur + order.tickets.filter((ticket) => ticket.name === segmentType).length, 0);
+    }
+
+    return makeAnalytics(
+      type,
+      orders,
+      intervalInfo,
+      AnalyticsValueTypeEnum.Quantity,
+      coordinatesSumFn,
+      segmentTypes,
+      segmentCoordinatesHOSumFn
+    );
+  },
+
+  ticketComps(
+    type: AnalyticsTypeEnum,
+    orders: IOrder[],
+    intervalInfo: IntervalInfo,
+    showSegments: boolean,
+  ): IAnalytics {
+    const coordinatesSumFn = (orders: IOrder[]) =>
+      orders
+        .filter(order => order.type === OrderTypeEnum.Complimentary)
+        .reduce((cur, order) => cur + order.tickets.length, 0);
+
+    let segmentTypes;
+    let segmentCoordinatesHOSumFn;
+    if (showSegments) {
+      segmentTypes = Object.keys(
+        orders
+          .reduce((cur, next: IOrder) => {
+            return cur.concat(next.tickets);
+          }, [] as IOrderTicket[])
+          .reduce((cur, next: IOrderTicket) => {
+            cur[next.name] = true;
+            return cur;
+          }, {})
+      );
+
+      segmentCoordinatesHOSumFn = (segmentType: string) => (orders: IOrder[]) =>
+        orders
+          .filter(order => order.type === OrderTypeEnum.Complimentary)
+          .reduce((cur, order) =>
+            cur + order.tickets.filter((ticket) => ticket.name === segmentType).length, 0);
+    }
+
+
+    return makeAnalytics(
+      type,
+      orders,
+      intervalInfo,
+      AnalyticsValueTypeEnum.Quantity,
+      coordinatesSumFn,
+      segmentTypes,
+      segmentCoordinatesHOSumFn
+    );
+  },
+
+  upgradeSales(
+    type: AnalyticsTypeEnum,
+    orders: IOrder[],
+    intervalInfo: IntervalInfo,
+    showSegments: boolean,
+  ): IAnalytics {
+    const coordinatesSumFn = (orders: IOrder[]) =>
+      orders
+        .filter(order => order.type === OrderTypeEnum.Paid)
+        .reduce((cur, order) => cur + sum(order.upgrades.map(upgrade => upgrade.price)), 0);
+
+    let segmentTypes;
+    let segmentCoordinatesHOSumFn;
+    if (showSegments) {
+      segmentTypes = Object.keys(
+        orders
+          .reduce((cur, next: IOrder) => {
+            return cur.concat(next.upgrades);
+          }, [] as IOrderUpgrade[])
+          .reduce((cur, next: IOrderUpgrade) => {
+            cur[next.name] = true;
+            return cur;
+          }, {})
+      );
+
+      segmentCoordinatesHOSumFn = (segmentType: string) => (orders: IOrder[]) =>
+        orders
+          .filter(order => order.type === OrderTypeEnum.Paid)
+          .reduce((cur, order) => cur + sum(
+            order.upgrades
+              .filter((upgrade) => upgrade.name === segmentType)
+              .map((upgrade) => upgrade.price)), 0);
+    }
+
+
+    return makeAnalytics(
+      type,
+      orders,
+      intervalInfo,
+      AnalyticsValueTypeEnum.Currency,
+      coordinatesSumFn,
+      segmentTypes,
+      segmentCoordinatesHOSumFn
+    );
+  },
+
+  upgradesSold(
+    type: AnalyticsTypeEnum,
+    orders: IOrder[],
+    intervalInfo: IntervalInfo,
+    showSegments: boolean,
+  ): IAnalytics {
+    const coordinatesSumFn = (orders: IOrder[]) =>
+      orders
+        .filter(order => order.type === OrderTypeEnum.Paid)
+        .reduce((cur, order) => cur + order.upgrades.length, 0);
+
+    let segmentTypes;
+    let segmentCoordinatesHOSumFn;
+    if (showSegments) {
+      segmentTypes = Object.keys(
+        orders
+          .reduce((cur, next: IOrder) => {
+            return cur.concat(next.upgrades);
+          }, [] as IOrderUpgrade[])
+          .reduce((cur, next: IOrderUpgrade) => {
+            cur[next.name] = true;
+            return cur;
+          }, {})
+      );
+  
+      segmentCoordinatesHOSumFn = (segmentType: string) => (orders: IOrder[]) =>
+        orders
+          .filter(order => order.type === OrderTypeEnum.Paid)
+          .reduce((cur, order) =>
+            cur + order.upgrades.filter((upgrade) => upgrade.name === segmentType).length, 0);
+    }
+
+    return makeAnalytics(
+      type,
+      orders,
+      intervalInfo,
+      AnalyticsValueTypeEnum.Quantity,
+      coordinatesSumFn,
+      segmentTypes,
+      segmentCoordinatesHOSumFn
+    );
+  },
+
+  upgradeComps(
+    type: AnalyticsTypeEnum,
+    orders: IOrder[],
+    intervalInfo: IntervalInfo,
+    showSegments: boolean,
+  ): IAnalytics {
+    const coordinatesSumFn = (orders: IOrder[]) =>
+      orders
+        .reduce((cur, order) =>
+          cur + order.upgrades.filter(upgrade => upgrade.price === 0).length,
+          0);
+
+    let segmentTypes;
+    let segmentCoordinatesHOSumFn;
+    if (showSegments) {
+      segmentTypes = Object.keys(
+        orders
+          .reduce((cur, next: IOrder) => {
+            return cur.concat(next.tickets);
+          }, [] as IOrderTicket[])
+          .reduce((cur, next: IOrderTicket) => {
+            cur[next.name] = true;
+            return cur;
+          }, {})
+      );
+  
+      segmentCoordinatesHOSumFn = (segmentType: string) => (orders: IOrder[]) =>
+        orders
+          .reduce((cur, order) =>
+            cur + order.upgrades.filter((upgrade) => upgrade.name === segmentType && upgrade.price === 0).length, 0);
+    }
+
+    return makeAnalytics(
+      type,
+      orders,
+      intervalInfo,
+      AnalyticsValueTypeEnum.Quantity,
+      coordinatesSumFn,
+      segmentTypes,
+      segmentCoordinatesHOSumFn
+    );
+  },
+
+  promotions(
+    type: AnalyticsTypeEnum,
+    orders: IOrder[],
+    intervalInfo: IntervalInfo,
+    showSegments: boolean,
+  ): IAnalytics {
+    const coordinatesSumFn = (orders: IOrder[]) =>
+      orders.filter(order => Boolean(order.promotionCode))
+        .length
+
+    let segmentTypes;
+    let segmentCoordinatesHOSumFn;
+    if (showSegments) {
+      segmentTypes = Object.keys(
+        orders.reduce((cur, next: IOrder) => {
+          if (next.promotionCode) cur[next.promotionCode] = true;
+          return cur;
+        }, {})
+      );
+
+      segmentCoordinatesHOSumFn = (segmentType: string) => (orders: IOrder[]) =>
+        orders
+          .filter(order => order.promotionCode === segmentType)
+          .length;
+    }
+
+    return makeAnalytics(
+      type,
+      orders,
+      intervalInfo,
+      AnalyticsValueTypeEnum.Quantity,
+      coordinatesSumFn,
+      segmentTypes,
+      segmentCoordinatesHOSumFn
+    );
+  },
+
+  totalOrders(
+    type: AnalyticsTypeEnum,
+    orders: IOrder[],
+    intervalInfo: IntervalInfo,
+  ): IAnalytics {
+    const coordinatesSumFn = (orders: IOrder[]) => orders.length;
+
+    return makeAnalytics(
+      type,
+      orders,
+      intervalInfo,
+      AnalyticsValueTypeEnum.Quantity,
+      coordinatesSumFn
+    );
+  },
+
+  // Returns start and end date
+  durationToUnix(duration: AnalyticsDurationEnum): IDuration {
+    type DurationEnumToDurationMap = Record<
+      AnalyticsDurationEnum,
+      () => IDuration
+    >;
+
+    const durations: DurationEnumToDurationMap = {
+      [AnalyticsDurationEnum.AllTime]: () => {
+        const duration: IDuration = {
+          startsAt: 0,
+          endsAt: 0,
+        };
+        return duration;
+      },
+      [AnalyticsDurationEnum.Today]: () => {
+        const duration: IDuration = {
+          startsAt: Time.getStartOfCurrentDay(),
+          endsAt: Time.getEndOfCurrentDay()
+        };
+        return duration;
+      },
+      [AnalyticsDurationEnum.OneWeek]: () => {
+        const duration: IDuration = {
+          startsAt: Time.now() - Time.DAY * 7,
+          endsAt: Time.now(),
+        };
+        return duration;
+      },
+      [AnalyticsDurationEnum.OneMonth]: () => {
+        const duration: IDuration = {
+          startsAt: Time.now() - Time.DAY * 30,
+          endsAt: Time.now(),
+        };
+        return duration;
+      },
+      [AnalyticsDurationEnum.MonthToDate]: () => {
+        const duration: IDuration = {
+          startsAt: Time.getStartOfCurrentMonth(),
+          endsAt: Time.now(),
+        };
+        return duration;
+      },
+      [AnalyticsDurationEnum.YearToDate]: () => {
+        const duration: IDuration = {
+          startsAt: Time.getStartOfCurrentYear(),
+          endsAt: Time.now(),
+        };
+        return duration;
+      },
+      [AnalyticsDurationEnum.OneYear]: () => {
+        const duration: IDuration = {
+          startsAt: Time.now() - Time.DAY * 365,
+          endsAt: Time.now(),
+        };
+        return duration;
+      },
+      [AnalyticsDurationEnum.Custom]: () => {
+        const duration: IDuration = {
+          startsAt: 0,
+          endsAt: 0,
+        };
+        return duration;
+      },
+    };
+
+    return durations[duration]();
+  },
+
+  // Returns available intervals
+  durationIntervals(interval: AnalyticsDurationEnum): AnalyticsIntervalEnum[] {
+    type AnalyticsDurationToIntervalMap = Record<
+      AnalyticsDurationEnum,
+      () => AnalyticsIntervalEnum[]
+    >;
+
+    const intervals: AnalyticsDurationToIntervalMap = {
+      [AnalyticsDurationEnum.AllTime]: (): AnalyticsIntervalEnum[] => {
+        return [];
+      },
+      [AnalyticsDurationEnum.Today]: (): AnalyticsIntervalEnum[] => {
+        return [AnalyticsIntervalEnum.Hour];
+      },
+      [AnalyticsDurationEnum.OneWeek]: (): AnalyticsIntervalEnum[] => {
+        return [AnalyticsIntervalEnum.Day];
+      },
+      [AnalyticsDurationEnum.OneMonth]: (): AnalyticsIntervalEnum[] => {
+        return [AnalyticsIntervalEnum.Day, AnalyticsIntervalEnum.Week];
+      },
+      [AnalyticsDurationEnum.MonthToDate]: (): AnalyticsIntervalEnum[] => {
+        return [AnalyticsIntervalEnum.Day, AnalyticsIntervalEnum.Week];
+      },
+      [AnalyticsDurationEnum.YearToDate]: (): AnalyticsIntervalEnum[] => {
+        return [AnalyticsIntervalEnum.Week, AnalyticsIntervalEnum.Month];
+      },
+      [AnalyticsDurationEnum.OneYear]: (): AnalyticsIntervalEnum[] => {
+        return [AnalyticsIntervalEnum.Week, AnalyticsIntervalEnum.Month];
+      },
+      [AnalyticsDurationEnum.Custom]: (): AnalyticsIntervalEnum[] => {
+        return [];
+      },
+    };
+
+    return intervals[interval]();
+  },
+
+  getDateFormat(time: any, interval: AnalyticsIntervalEnum) {
+    switch(interval) {
+      case AnalyticsIntervalEnum.Hour:
+        return Time.format(time, 'h:mma');
+      case AnalyticsIntervalEnum.Day:
+        return Time.format(time, 'MMM DD');
+      case AnalyticsIntervalEnum.Week:
+        return `${Time.format(time, 'MMM DD')} - ${Time.format(time + (Time.DAY * 7), 'MMM DD')}`;
+      case AnalyticsIntervalEnum.Month:
+        return Time.format(time, 'MMM YYYY');
+      case AnalyticsIntervalEnum.Year:
+        return Time.format(time, 'YYYY');
+      default:
+        return Time.format(time, 'MMM DD');
+    }
+  },
+
+  getTotalValue(coords: ICoordinate[]) {
+    if (!coords) {
+      return 0;
+    }
+    return coords.reduce((acc, next) => {
+      return acc += next.y;
+    }, 0);
+  },
+
+  getDisplayMetric(data: IAnalytics, hoverIndex?: number) {
+    let val = 0;
+    if (data.coordinates) {
+      if (hoverIndex === undefined) {
+        val = this.getTotalValue(data.coordinates);
+      } else {
+        let coord = data?.coordinates.find((coord: ICoordinate) => coord.x === hoverIndex);
+        if (coord) val = coord.y;
+      }
+    }
+    if (data.type === AnalyticsValueTypeEnum.Currency) {
+      return `$${Price.output(val)}`;
+    }
+    return val?.toString();
+  },
+
+  getMaxXVal(dataArray: ICoordinate[]) {
+    return dataArray.reduce((max: number, p: ICoordinate) => p.x > max ? p.x : max, 0);
+  },
+
+  getMinXVal(dataArray: ICoordinate[]) {
+    return dataArray.reduce((min: number, p: ICoordinate) => p.x < min ? p.x : min, Infinity)
+  },
+
+  getMaxYVal(dataArray: ICoordinate[]) {
+    return dataArray.reduce((max: number, p: ICoordinate) => p.y > max ? p.y : max, 0);
+  }
+};