@sellout/models 0.0.1

package/src/utils/EventUtil.ts

@@ -0,0 +1,186 @@
+import * as Time from '@sellout/utils/.dist/time';
+
+export default {
+  hasBeenAnnouced(event): boolean {
+    const { schedule: { announceAt } } = event;
+    const now = Time.now();
+    return announceAt < now;
+  }, 
+  isAnnounced(event): boolean {
+    const { schedule: { announceAt, ticketsAt } } = event;
+    const now = Time.now();
+    return announceAt <  now && now < ticketsAt;
+  },
+  isOnSale(event): boolean {
+    const { schedule: { ticketsAt, ticketsEndAt } } = event;
+    const now = Time.now();
+    return ticketsAt < now && now < ticketsEndAt;
+  },
+  isInProgress(event): boolean {
+    const { schedule: { startsAt, endsAt } } = event;
+    const now = Time.now();
+    return startsAt < now && now < endsAt;
+  },
+  saleHasEnded(event): boolean {
+    const { schedule: { ticketsEndAt } } = event;
+    const now = Time.now();
+    return ticketsEndAt < now;
+  },
+  hasEnded(event): boolean {
+    const { schedule: { endsAt } } = event;
+    const now = Time.now();
+    return endsAt < now;
+  },
+  hasActivePreSalePromotions(event): boolean{
+    return event.promotions
+    .filter(promotion => promotion.type === 'Pre-Sale Code')
+    .filter(promotion => promotion.active)
+    .length > 0;
+  },
+  qrCodeEmailAt(event): number {
+    const { performances: [performance] } = event;
+    const { schedule: { doorsAt, startsAt } } = performance;
+
+    if(event.sendQRCode === 'Upon Order') {
+      return Time.now();
+    }
+
+    if(event.sendQRCode === 'Two Weeks Before Show') {
+      const TWO_WEEKS = 14 * 24 * 60 * 60;
+      return startsAt - TWO_WEEKS;
+    }
+
+    return doorsAt - (600);
+  },
+  shouldSendOrderReceipt(event): boolean {
+    const now = Time.now();
+    const qrCodeEmailAt = this.qrCodeEmailAt(event);
+
+    // Never send a receipt if we are 
+    // send a qr code upon order
+    if (event.sendQRCode === 'Upon Order') {
+      return false;
+    }
+
+    // Only send a receipt if QR codes for
+    // the event haven't already gone out
+    if(qrCodeEmailAt > now) {
+      return true;
+    }
+
+    return false;
+  },
+  /****************************************************************************************
+    Venue
+  ****************************************************************************************/
+  venueIds(event): string[] {
+    let venueIds = [event.venueId];
+    event.performances.forEach(performance => {
+      venueIds = venueIds.concat(performance.venueStageId)
+    });
+    venueIds = [...new Set(venueIds)];
+    venueIds = venueIds.filter(v => !!v);
+    return venueIds;
+  },
+  seatingId(event): string {
+    return event._id.replace('_', 'SAMH');
+  },
+  /****************************************************************************************
+    Artist
+  ****************************************************************************************/
+  artistIds(event): string[] {
+    let artistIds = [];
+    event.performances.forEach(performance => {
+      artistIds = artistIds
+        .concat(performance.headliningArtistIds)
+        .concat(performance.openingArtistIds);
+    });    
+    artistIds = [...new Set(artistIds)];
+    artistIds = artistIds.filter(a => !!a);
+    return artistIds;
+  },
+  headliningArtistIds(event): string[] {
+    let artistIds = [];
+    event.performances.forEach(performance => {
+      artistIds = artistIds
+        .concat(performance.headliningArtistIds)
+    });
+    artistIds = [...new Set(artistIds)];
+    artistIds = artistIds.filter(a => !!a);
+    return artistIds;
+  },
+  openingArtistIds(event): string[] {
+    let artistIds = [];
+    event.performances.forEach(performance => {
+      artistIds = artistIds
+        .concat(performance.openingArtistIds);
+    });
+    artistIds = [...new Set(artistIds)];
+    artistIds = artistIds.filter(a => !!a);
+    return artistIds;
+  },
+  /****************************************************************************************
+    Tickets
+  ****************************************************************************************/
+  ticketType(event, ticketTypeId): any {
+    return event.ticketTypes.find(ticketType => ticketType._id === ticketTypeId);
+  },
+  remainingTicketQty(event, ticketTypeId: string | null = null): number {
+    if (ticketTypeId) {
+      let ticketType = event.ticketTypes.find(ticketType => ticketType._id === ticketTypeId);
+      if (!ticketType) return 0;
+      else return ticketType.remainingQty;
+    } else {
+      return event.ticketTypes.reduce((cur, next) => {
+        return cur + next.remainingQty;
+      }, 0);
+    }
+  },
+  remainingQtyByTicketTypes(event): object {
+    return event.ticketTypes.reduce((cur, ticketType) => {
+      cur[ticketType._id] = this.remainingTicketQty(event, ticketType._id);
+      return cur;
+    }, {});
+  },
+  purchaseLimitByTicketTypes(event): object {
+    return event.ticketTypes.reduce((cur, ticketType) => {
+      cur[ticketType._id] = ticketType.purchaseLimit;
+      return cur;
+    }, {});
+  },
+  getCurrentTierId(event, ticketTypeId: string): string {
+    const ticketType = event.ticketTypes.find(t => t._id.toString() === ticketTypeId);
+    const now = Time.now();
+    const tier = ticketType.tiers.find(tier => tier.startsAt < now && now < tier.endsAt);
+    return tier._id;
+  },  
+  /****************************************************************************************
+    Upgrades
+  ****************************************************************************************/
+  upgrade(event, upgradeId): any {
+    return event.upgrades.find(upgrades => upgrades._id === upgradeId);
+  },
+  remainingUpgradeQty(event, upgradeId: string | null = null): number {
+    if (upgradeId) {
+      let upgrade = event.upgrades.find(upgrade => upgrade._id === upgradeId);
+      if (!upgrade) return 0;
+      else return upgrade.remainingQty;
+    } else {
+      return event.upgrades.reduce((cur, next) => {
+        return cur + next.remainingQty;
+      }, 0);
+    }
+  },
+  remainingQtyByUpgrades(event): object {
+    return event.upgrades.reduce((cur, upgrade) => {
+      cur[upgrade._id] = this.remainingUpgradeQty(event, upgrade._id);
+      return cur;
+    }, {});
+  },
+  purchaseLimitByUpgrades(event): object {
+    return event.upgrades.reduce((cur, upgrade) => {
+      cur[upgrade._id] = upgrade.purchaseLimit;
+      return cur;
+    }, {});
+  },
+}

package/src/utils/FeeUtil.ts

@@ -0,0 +1,34 @@
+export default {
+  processingFees(fees) {
+    return fees.filter((fee) => {
+      if (fee.appliedBy === 'Sellout' || fee.appliedBy === 'Stripe') {
+        return true;
+      }
+      return false;
+    });
+  },
+  selloutFees(fees) {
+    return fees.filter((fee) => {
+      if (fee.appliedBy === 'Sellout') {
+        return true;
+      }
+      return false;
+    });
+  },
+  stripeFees(fees) {
+    return fees.filter((fee) => {
+      if (fee.appliedBy === 'Stripe') {
+        return false;
+      }
+      return true;
+    });
+  },
+  promoterFees(fees) {
+    return fees.filter((fee) => {
+      if (fee.appliedBy === 'Sellout' || fee.appliedBy === 'Stripe') {
+        return false;
+      }
+      return true;
+    });
+  },
+};

package/src/utils/OrderUtil.ts

@@ -0,0 +1,226 @@
+import FeeUtil from "./FeeUtil";
+
+export default {
+  /** **************************************************************************************
+  Order
+  *************************************************************************************** */
+  orderTotal(order, fees) {
+    // if (order.type === this.types.Complimentary) return 0;
+    // if (order.type === this.types.RSVP) fees = [];
+
+    if (
+      (!order.tickets || !order.tickets.length) &&
+      (!order.upgrades || !order.upgrades.length)
+    )
+      return 0;
+
+    if (!order.tickets) order.tickets = [];
+    if (!order.upgrades) order.upgrades = [];
+
+    const ticketFees = fees.filter(f => f.appliedTo === "Ticket");
+    const upgradeFees = fees.filter(f => f.appliedTo === "Upgrade");
+    let orderFees = fees.filter(f => f.appliedTo === "Order");
+
+    function applyTicketFee(ticket, fee) {
+      if (fee.filters.includes("Seated") && !ticket.seat) return 0;
+      const noMax = fee.maxAppliedToPrice === 0;
+      if (
+        (fee.minAppliedToPrice <= ticket.price &&
+          ticket.price <= fee.maxAppliedToPrice) ||
+        noMax
+      ) {
+        if (fee.type === "Flat") {
+          return fee.value;
+        }
+        if (fee.type === "Percent") {
+          return (ticket.price * fee.value) / 100;
+        }
+      } else {
+        return 0;
+      }
+    }
+
+    function applyUpgradeFee(upgrade, fee) {
+      const noMax = fee.maxAppliedToPrice === 0;
+      if (
+        (fee.minAppliedToPrice <= upgrade.price &&
+          upgrade.price <= fee.minAppliedToPrice) ||
+        noMax
+      ) {
+        if (fee.type === "Flat") {
+          return fee.value;
+        }
+        if (fee.type === "Percent") {
+          return (upgrade.price * fee.value) / 100;
+        }
+      } else {
+        return 0;
+      }
+    }
+
+    function applyOrderFee(orderSubtotal, fee) {
+      if (fee.type === "Flat") {
+        return orderSubtotal + fee.value;
+      }
+      if (fee.type === "Percent") {
+        return orderSubtotal / (1 - fee.value / 100);
+      }
+    }
+
+    const ticketTotal = order.tickets.reduce(
+      (cur, ticket) => cur + ticket.price,
+      0
+    );
+
+    const ticketFeeTotal = order.tickets.reduce((cur, ticket) => {
+      return (
+        cur +
+        ticketFees.reduce((cur, fee) => cur + applyTicketFee(ticket, fee), 0)
+      );
+    }, 0);
+
+    const upgradeTotal = order.upgrades.reduce(
+      (cur, upgrade) => cur + upgrade.price,
+      0
+    );
+
+    const upgradeFeeTotal = order.upgrades.reduce((cur, upgrade) => {
+      return (
+        cur +
+        upgradeFees.reduce((cur, fee) => cur + applyUpgradeFee(upgrade, fee), 0)
+      );
+    }, 0);
+
+    const orderSubtotal =
+      ticketTotal + ticketFeeTotal + upgradeTotal + upgradeFeeTotal;
+
+    // Order matters here. Flat type fees must be
+    // applied before Percent type fees
+    orderFees = orderFees.sort(({ type }) => {
+      if (type === "Flat") return -1;
+      return 1;
+    });
+
+    const orderTotal = orderFees.reduce((cur, fee) => {
+      return applyOrderFee(cur, fee);
+    }, orderSubtotal);
+
+    return Math.round(orderTotal);
+  },
+  orderTotalWithRefund(order, fees) {
+    return this.orderTotal(order, fees) - (order.refundedAmount || 0);
+  },
+  orderSubtotal(order) {
+    if (!order.tickets) order.tickets = [];
+    if (!order.upgrades) order.upgrades = [];
+
+    const ticketTotal = order.tickets.reduce(
+      (cur, ticket) => cur + ticket.price,
+      0
+    );
+    const upgradeTotal = order.upgrades.reduce(
+      (cur, upgrade) => cur + upgrade.price,
+      0
+    );
+    return ticketTotal + upgradeTotal;
+  },
+  orderFee(order, fees) {
+    if (!order.tickets) order.tickets = [];
+    if (!order.upgrades) order.upgrades = [];
+    return this.orderTotal(order, fees) - this.orderSubtotal(order);
+  },
+  // This one is special because stripe fees
+  // can be applied as a percentage
+  processingFees(order, fees) {
+    if (!order.tickets) order.tickets = [];
+    if (!order.upgrades) order.upgrades = [];
+    const total = this.orderTotal(order, fees);
+    const subtotal = this.orderSubtotal(order);
+    const promoterFees = this.promoterFees(order, fees);
+    return total - subtotal - promoterFees;
+  },
+  selloutFees(order, fees) {
+    if (!order.tickets) order.tickets = [];
+    if (!order.upgrades) order.upgrades = [];
+    fees = FeeUtil.selloutFees(fees);
+    return this.orderTotal(order, fees) - this.orderSubtotal(order);
+  },
+  // This one is special because stripe fees
+  // can be applied as a percentage
+  stripeFees(order, fees) {
+    if (!order.tickets) order.tickets = [];
+    if (!order.upgrades) order.upgrades = [];
+    const total = this.orderTotal(order, fees);
+    const subtotal = this.orderSubtotal(order);
+    const selloutFees = this.selloutFees(order, fees);
+    const promoterFees = this.promoterFees(order, fees);
+    return total - subtotal - selloutFees - promoterFees;
+  },
+  promoterFees(order, fees) {
+    if (!order.tickets) order.tickets = [];
+    if (!order.upgrades) order.upgrades = [];
+    fees = FeeUtil.promoterFees(fees);
+    return this.orderFee(order, fees);
+  },
+  /** **************************************************************************************
+  Ticket
+  *************************************************************************************** */
+  ticketTypeTotal(order, ticketTypeId) {
+    return order.tickets
+      .filter(t => t.ticketTypeId === ticketTypeId)
+      .reduce((cur, next) => cur + next.price, 0);
+  },
+  ticketCountsByTicketTypeId(order) {
+    return order.tickets.reduce((cur, ticket) => {
+      if (cur[ticket.ticketTypeId]) cur[ticket.ticketTypeId]++;
+      else cur[ticket.ticketTypeId] = 1;
+      return cur;
+    }, {});
+  },
+  ticketIsScannable(orderTicket) {
+    if (!orderTicket) return false;
+    let { scan = {}, refund = {} } = orderTicket;
+
+    if (scan.scanned && scan.scannedAt > 0) return false;
+    if (refund.refunded && refund.refundedAt > 0) return false;
+    return true;
+  },
+  seatIsSelected(order, seat) {
+    const allSeats = this.allSeats(order);
+    return allSeats.includes(seat);
+  },
+  allSeats(order) {
+    return order.tickets
+      .filter(ticket => Boolean(ticket.seat))
+      .map(ticket => ticket.seat);
+  },
+  ticketTypeSeats(order, ticketTypeId) {
+    return order.tickets
+      .filter(ticket => ticket.ticketTypeId === ticketTypeId)
+      .filter(ticket => Boolean(ticket.seat))
+      .map(ticket => ticket.seat);
+  },
+  /** **************************************************************************************
+  Upgrade
+  *************************************************************************************** */
+  upgradeTypeTotal(order, upgradeId) {
+    return order.upgrades
+      .filter(t => t.upgradeId === upgradeId)
+      .reduce((cur, next) => cur + next.price, 0);
+  },
+  upgradeCountsByUpgradeId(order) {
+    return order.upgrades.reduce((cur, upgrades) => {
+      if (cur[upgrades.upgradeId]) cur[upgrades.upgradeId]++;
+      else cur[upgrades.upgradeId] = 1;
+      return cur;
+    }, {});
+  },
+  upgradeIsScannable(orderUpgrade) {
+    if (!orderUpgrade) return false;
+    let { scan = {}, refund = {} } = orderUpgrade;
+
+    if (scan.scanned && scan.scannedAt > 0) return false;
+    if (refund.refunded && refund.refundedAt > 0) return false;
+    return true;
+  }
+};

package/src/utils/WebFlowUtil.ts

@@ -0,0 +1,8 @@
+export default {
+/****************************************************************************************
+  WebFlow Entity
+****************************************************************************************/
+  getSiteEntityId(entity, siteId) {
+    
+  }
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compileOnSave": true,
+  "compilerOptions": {
+    "baseUrl": ".",
+    "moduleResolution": "node",
+    "target": "es6",
+    "module": "commonjs",
+    "outDir": "./.dist/",
+    "declaration": true,
+    "sourceMap": true,
+    "strictNullChecks": true,
+    "noUnusedLocals": true,
+    "paths": {},
+    "types": [
+      "node",
+    ]
+  },
+  "typeRoots": [
+    "node_modules/@types"
+  ],
+  "include": [
+    "./src/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/tslint.json

@@ -0,0 +1,21 @@
+{
+  "extends": "tslint-config-airbnb",
+  "rules": {
+    "max-line-length": {
+      "options": [120]
+    },
+    "no-console": false,
+    "ban": [
+      true,
+      {
+        "name": ["Math", "random"],
+        "message": "Use a better RNG, perhaps UUID?"
+      }
+    ]
+  },
+  "jsRules": {
+    "max-line-length": {
+      "options": [120]
+    }
+  }
+}