@sellout/models 0.0.233 → 0.0.237

package/src/utils/AnalyticsUtil.ts

@@ -14,6 +14,7 @@ import { OrderTypeEnum } from "../interfaces/IOrderType";
 // import { OrderStateEnum } from "../interfaces/IOrderState";
 import * as Time from "@sellout/utils/.dist/time";
 import * as Price from '@sellout/utils/.dist/price';
+// import { number } from "@hapi/joi";
 
 interface IDuration {
   startsAt: number;
@@ -24,7 +25,7 @@ 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;
+type SumFn = (orders: IOrder[]) => any;
 
 const makeCoordinates = (
   orders: IOrder[],
@@ -268,6 +269,13 @@ export default {
       case AnalyticsTypeEnum.UserAnalytics:
         return this.userAnalytics(type, orders, intervalInfo, showSegments);
 
+      case AnalyticsTypeEnum.TicketsScanned:
+        return this.ticketsScanned(type, orders, intervalInfo, showSegments);
+
+      case AnalyticsTypeEnum.UpgradesScanned:
+        return this.upgradesScanned(type, orders, intervalInfo, showSegments);
+      
+
       default:
         return {
           label: type,
@@ -452,7 +460,7 @@ export default {
 
         //   return ordersData
         // }
-        
+
         const ordersData = orders.reduce((cur, order) => {
           let total;
           if (order.type == OrderTypeEnum.RSVP) {
@@ -488,6 +496,7 @@ export default {
       orders
         // .filter(order => order.type === OrderTypeEnum.Paid)
         .reduce((cur, order) => cur + order.tickets.length, 0);
+        
 
     let segmentTypes;
     let segmentCoordinatesHOSumFn;
@@ -521,6 +530,116 @@ export default {
     );
   },
 
+  ticketsScanned(
+    type: AnalyticsTypeEnum,
+    orders: IOrder[],
+    intervalInfo: IntervalInfo,
+    showSegments: boolean,
+  ): IAnalytics {
+    let count = 0;
+    const coordinatesSumFn = (orders: IOrder[]) => orders.reduce((cur, order) => {
+      order?.tickets.map(ticket => {
+        ticket?.scan?.map(a => {
+          if (a.scanned) {
+            count = count + 1
+          }
+        }
+        )
+      })
+      return  count
+    }, 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:any) =>   orders
+        .reduce((cur, order) => {
+          const filteredTickets = order.tickets.filter((ticket) => {
+            return ticket.name === segmentType && ticket?.scan.some(scanData => scanData.scanned === true);
+          });
+      
+          // console.log(filteredTickets);
+      
+          return cur + filteredTickets.length;
+        }, 0);
+            
+    }
+
+    return makeAnalytics(
+      type,
+      orders,
+      intervalInfo,
+      AnalyticsValueTypeEnum.Quantity,
+      coordinatesSumFn ,
+      segmentTypes,
+      segmentCoordinatesHOSumFn
+    );
+  },
+
+  // upgradeScannedCount
+  upgradesScanned(
+    type: AnalyticsTypeEnum,
+    orders: IOrder[],
+    intervalInfo: IntervalInfo,
+    showSegments: boolean,
+  ): IAnalytics {
+    let count = 0;
+    const coordinatesSumFn = (orders: any) => orders.reduce((cur, order) => {
+      order?.upgrades.map(upgrade => {
+        if(upgrade?.scan.scanned){
+           count = count + 1
+        }
+      })
+      return  count
+    }, 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:any) =>   orders
+      .reduce((cur, order) => {
+        const filteredUpgrades = order.upgrades.filter((upgrade) => {
+          return upgrade.name === segmentType && upgrade?.scan.scanned === true;
+        });
+    
+        console.log(filteredUpgrades);
+    
+        return cur + filteredUpgrades.length;
+      }, 0);
+     
+    }
+
+    return makeAnalytics(
+      type,
+      orders,
+      intervalInfo,
+      AnalyticsValueTypeEnum.Quantity,
+      coordinatesSumFn ,
+      segmentTypes,
+      segmentCoordinatesHOSumFn
+    );
+  },
+
   ticketComps(
     type: AnalyticsTypeEnum,
     orders: IOrder[],
@@ -544,8 +663,10 @@ export default {
             cur[next.name] = true;
             return cur;
           }, {})
+          
       );
 
+
       segmentCoordinatesHOSumFn = (segmentType: string) => (orders: IOrder[]) =>
         orders
           .filter(order => order.type === OrderTypeEnum.Complimentary)

package/src/utils/OrderUtil.ts

@@ -236,6 +236,7 @@ export default {
 
     return subTotal || 0
   },
+
   orderSubtotalWithRefund(order) {
     if (order.type === OrderTypeEnum.Complimentary) return 0;
     if (!order.tickets) order.tickets = [];
@@ -325,7 +326,7 @@ export default {
   ticketTypeTotal(order, ticketTypeId) {
     return order.tickets
       .filter(t => t.ticketTypeId === ticketTypeId)
-      .reduce((cur, next) => cur + next.price, 0);
+      .reduce((cur, next) => cur + next.origionalPrice, 0);
   },
   ticketCountsByTicketTypeId(order) {
     return order.tickets.reduce((cur, ticket) => {