@sellout/models 0.0.105 → 0.0.108

package/src/utils/EventUtil.ts

@@ -1,14 +1,19 @@
-import Joi from '@hapi/joi';
+import Joi from "@hapi/joi";
 import * as Time from "@sellout/utils/.dist/time";
 import IEventCustomField from "../interfaces/IEventCustomField";
-import IEvent, { EventProcessAsEnum, EventTypeEnum } from "../interfaces/IEvent";
-import { CustomFieldTypeEnum } from '../enums/CustomFieldTypeEnum';
+import IRefundModal from "../interfaces/IRefundModal";
+import IEvent, {
+  EventProcessAsEnum,
+  EventTypeEnum,
+} from "../interfaces/IEvent";
+import { CustomFieldTypeEnum } from "../enums/CustomFieldTypeEnum";
 import IOrderCustomField from "../interfaces/IOrderCustomField";
 import IEventUpgrade from "../interfaces/IEventUpgrade";
 import ITicketType from "../interfaces/ITicketType";
 import IEventPromotion from "../interfaces/IEventPromotion";
-import { EventPromotionTypeEnum } from '../interfaces/IEventPromotion';
-
+import { EventPromotionTypeEnum } from "../interfaces/IEventPromotion";
+import { DropDownEnum } from "../enums/DropDownEnum";
+import { SendQRCodeEnum} from "../interfaces/IEvent";
 export default {
   /****************************************************************************************
    * Schedule
@@ -53,26 +58,28 @@ export default {
   },
   hasEnded(event): boolean {
     const {
-      schedule: { endsAt },
+      schedule: { endsAt }
     } = event;
     const now = Time.now();
-    return endsAt < now;
+    return endsAt < now ;
   },
   isUnavailable(event: IEvent): boolean {
-    if(!event.published) return true;
-    if(!this.hasBeenAnnounced(event)) return true;
-    if(!this.isOnSale(event)) return true;
-    if(this.allTicketsAreLocked(event)) return true;
-    if(this.saleHasEnded(event)) return true;
+    if (!event.published) return true;
+    if (!this.hasBeenAnnounced(event)) return true;
+    if (!this.isOnSale(event)) return true;
+    if (this.allTicketsAreLocked(event)) return true;
+    if (this.saleHasEnded(event)) return true;
     return false;
   },
   allTicketsAreLocked(event: IEvent): boolean {
     const ticketTypeCount = event.ticketTypes?.length;
-    const promotionCodeTicketCount = [...new Set(event.promotions?.reduce((cur: string[], promotion) => {
-      return [...cur, ...promotion.ticketTypeIds];
-    }, []))].length;
-    console.log(ticketTypeCount);
-    console.log(promotionCodeTicketCount);
+    const promotionCodeTicketCount = [
+      ...new Set(
+        event.promotions?.reduce((cur: string[], promotion) => {
+          return [...cur, ...promotion.ticketTypeIds];
+        }, [])
+      ),
+    ].length;
     return ticketTypeCount === promotionCodeTicketCount;
   },
   /****************************************************************************************
@@ -82,18 +89,30 @@ export default {
     const {
       performances: [performance],
     } = event;
-    const {
-      schedule: { doorsAt, startsAt },
+    const { schedule: { doorsAt, startsAt },
     } = performance;
+    /*
+        changing to lower case 
+        becuse previosly it is stored with different values
+        like Upon Order, Upon order
+    */ 
+    if(event.sendQRCode.toLowerCase() === SendQRCodeEnum.UponOrder.toLowerCase()){
+        return Time.now();
+    }
+
+    if (event.sendQRCode.toLowerCase() === SendQRCodeEnum.TwoWeeksBefore.toLowerCase()) {
+      const TWO_WEEKS = 14 * 24 * 60 * 60;
+      return startsAt - TWO_WEEKS;
+    }
 
-    if (event.sendQRCode === "Upon Order") {
-      return Time.now();
+    /* 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;
   },
@@ -103,9 +122,12 @@ export default {
 
     // Never send a receipt if we are
     // send a qr code upon order
-    if (event.sendQRCode === "Upon Order") {
-      return false;
+    if(event.sendQRCode.toLowerCase() === SendQRCodeEnum.UponOrder.toLowerCase()){
+        return false;
     }
+    // if (event.sendQRCode === "Upon Order") {
+    //   return false;
+    // }
 
     // Only send a receipt if QR codes for
     // the event haven't already gone out
@@ -131,7 +153,7 @@ export default {
    * Seating
    ****************************************************************************************/
   isSeated(event?: IEvent): boolean {
-    if(!event) return false;
+    if (!event) return false;
     return Boolean(event.seatingChartKey);
   },
   /****************************************************************************************
@@ -190,7 +212,7 @@ export default {
     );
   },
   activeTicketTypes(event: IEvent): ITicketType[] {
-    return event.ticketTypes?.filter(ticketType => ticketType.visible) ?? [];
+    return event.ticketTypes?.filter((ticketType) => ticketType.visible) ?? [];
   },
   remainingTicketQty(event, ticketTypeId: string | null = null): number {
     if (ticketTypeId) {
@@ -234,16 +256,20 @@ export default {
     return event.upgrades.find((upgrades) => upgrades._id === upgradeId);
   },
   activeUpgrades(event: IEvent): IEventUpgrade[] {
-    return (event?.upgrades ?? [])
-      // must be active
-      .filter(upgrade => upgrade.visible)
-      // must have remaining qty
-      .filter(upgrade => upgrade.remainingQty > 0);
+    return (
+      (event?.upgrades ?? [])
+        // must be active
+        .filter((upgrade) => upgrade.visible)
+        // must have remaining qty
+        .filter((upgrade) => upgrade.remainingQty > 0)
+    );
   },
   activeNonComplimentaryUpgrades(event: IEvent): IEventUpgrade[] {
-    return this.activeUpgrades(event)
-      // must not be complimentary
-      .filter(upgrade => !upgrade.complimentary);
+    return (
+      this.activeUpgrades(event)
+        // must not be complimentary
+        .filter((upgrade) => !upgrade.complimentary)
+    );
   },
   remainingUpgradeQty(event, upgradeId: string | null = null): number {
     if (upgradeId) {
@@ -269,7 +295,10 @@ export default {
     }, {});
   },
   isUpgradeForSpecificTickets(event: IEvent, upgrade: IEventUpgrade): boolean {
-    return Boolean(event?.ticketTypes?.map((t) => t._id).sort() === upgrade?.ticketTypeIds?.sort());
+    return Boolean(
+      event?.ticketTypes?.map((t) => t._id).sort() ===
+        upgrade?.ticketTypeIds?.sort()
+    );
   },
   /****************************************************************************************
    * Promotions
@@ -279,135 +308,401 @@ export default {
       (promotions) => promotions._id === promotionId
     );
   },
-  activePromotions(event: IEvent, type: EventPromotionTypeEnum | null = null): IEventPromotion[] {
+  activePromotions(
+    event: IEvent,
+    type: EventPromotionTypeEnum | null = null
+  ): IEventPromotion[] {
     const now = Time.now();
 
     let promotions = (event?.promotions ?? [])
       // must be active
-      .filter(promotion => promotion.active)
+      .filter((promotion) => promotion.active)
       // must have remaining qty
-      .filter(promotion => promotion.remainingQty > 0)
+      .filter((promotion) => promotion.remainingQty > 0)
       // must be in the correct time
-      .filter(promotion => promotion.startsAt < now && now < promotion.endsAt);
+      .filter(
+        (promotion) => promotion.startsAt < now && now < promotion.endsAt
+      );
 
     // Optional type
-    if(type !== null) {
-      promotions = promotions.filter(
-        promotion => promotion.type === type
-      );
+    if (type !== null) {
+      promotions = promotions.filter((promotion) => promotion.type === type);
     }
 
-    return promotions
+    return promotions;
   },
   /****************************************************************************************
    * Custom Fields
    ****************************************************************************************/
   customField(event: IEvent, customFieldId: string): IEventCustomField | null {
-    return event?.customFields?.find(
-      (customField) => customField._id === customFieldId
-    ) ?? null;
+    return (
+      event?.customFields?.find(
+        (customField) => customField._id === customFieldId
+      ) ?? null
+    );
   },
   activeCustomFields(event: IEvent): IEventCustomField[] {
-    return event.customFields?.filter(customField => customField.active) ?? [];
+    return (
+      event.customFields?.filter((customField) => customField.active) ?? []
+    );
   },
   hasCustomFields(event) {
     return (
       event.customFields.filter((customField) => customField.active).length > 0
     );
   },
-  customFieldsAreValid(eventCustomFields: IEventCustomField[], orderCustomFields: IOrderCustomField[] ): boolean {
-    const activeFields = eventCustomFields?.filter(
-      (eventCustomField) => eventCustomField.active
-    ) ?? [];
+  // Fixed issue SELLOUT-49
+  customFieldsAreValid(
+    eventCustomFields: IEventCustomField[],
+    orderCustomFields: IOrderCustomField[]
+  ): boolean {
+    const activeFields =
+      eventCustomFields?.filter(
+        (eventCustomField) => eventCustomField.active
+      ) ?? [];
 
-    const validFields = activeFields?.filter((eventCustomField) => {
-      const {
-        _id,
-        minLength,
-        maxLength,
-        minValue,
-        maxValue,
-        required,
-      } = eventCustomField;
+    const validFields =
+      activeFields?.filter((eventCustomField) => {
+        const { _id, minLength, maxLength, minValue, maxValue, required } =
+          eventCustomField;
 
-      const orderCustomField = orderCustomFields.find(
-        (orderCustomField) => orderCustomField.customFieldId === _id
-      );
+        const orderCustomField = orderCustomFields.find(
+          (orderCustomField) => orderCustomField.customFieldId === _id
+        );
 
-      // Field has not been filled out
-      if (!orderCustomField) return false;
+        // Field is not required and orderCustomField not empty
+        if (!required && !orderCustomField) return true;
 
-      let { value } = orderCustomField;
+        // Field has not been filled out
+        if (!orderCustomField) return false;
 
-      if (eventCustomField.type === CustomFieldTypeEnum.Text) {
-        value = <string>value;
-        if (minLength === 0 && maxLength === 0) {
-          return !(required && value.length === 0);
-        }
+        let { value } = orderCustomField;
 
-        if (minLength <= value.length && value.length <= maxLength) {
+        if (
+          !required &&
+          (value === undefined || value === "NaN" || value === "" || value === DropDownEnum.Select)
+        ) {
           return true;
         }
 
-        return false;
-      } else  {
-        value = <number>value;
-        if (minValue === 0 && maxValue === 0) {
-          return !(required && value === 0);
-        }
-
-        if (minValue <= value && value <= maxValue) {
-          return true;
+        if (eventCustomField.type === CustomFieldTypeEnum.Text) {
+          value = <string>value;
+          if (value) {
+            if (minLength === 0 && maxLength === 0 && value.length > 0) {
+              return true;
+            } else if (minLength === 0 && value.length <= maxLength) {
+              return true;
+            } else if (maxLength === 0 && minLength <= value.length) {
+              return true;
+            } else if (minLength <= value.length && value.length <= maxLength) {
+              return true;
+            }
+          }
+          return false;
+        } else if (eventCustomField.type === CustomFieldTypeEnum.Dropdown) {
+          value = <string>value;
+          if (value !== "" && value !== DropDownEnum.Select) {
+            return true;
+          }
+          return false;
+        } else if (eventCustomField.type === CustomFieldTypeEnum.Address) {
+          value = <string>value;
+          if (value !== "") {
+            return true;
+          }
+          return false;
+        } else {
+          value = <number>value;
+          if (value) {
+            if (minValue === 0 && maxValue === 0 && value > 0) {
+              return true;
+            } else if (minValue === 0 && value <= maxValue) {
+              return true;
+            } else if (maxValue === 0 && minValue <= value) {
+              return true;
+            } else if (minValue <= value && value <= maxValue) {
+              return true;
+            }
+          }
+          return false;
         }
-
-        return false;
-      }
-      
-    }) ?? [];
+      }) ?? [];
 
     return validFields.length === activeFields.length;
   },
   /****************************************************************************************
-   * Publish
+   * Publish validate
    ****************************************************************************************/
   validatePublish(event: IEvent): any {
     let eventSchema;
 
-    switch(event.type) {
+    switch (event.type) {
       case EventTypeEnum.GeneralEvent:
-        eventSchema = Joi.object().options({ abortEarly: false }).keys({
-          name: Joi.string().required().messages({ 'any.required': 'Event title is a required field' }),
-          description: Joi.string().required().messages({ 'any.required': 'Event description is a required field' }),
-          posterImageUrl: Joi.string().required().messages({ 'any.required': 'Event image is a required field' }),
-          venueId: Joi.string().required().messages({ 'any.required': 'An event venue is required' }),
-          ticketTypes: Joi.array().min(1).items(Joi.object().options({ allowUnknown: true }).keys({
-            name: Joi.string().required(),
-            remainingQty: Joi.number().required(),
-            totalQty: Joi.number().required(),
-            purchaseLimit: Joi.number().required(),
-            tiers: Joi.array().items(Joi.object().keys({
-              name: Joi.string().required(),
-              price: Joi.number().required(),
-              remainingQty: Joi.number().required(),
-              totalQty: Joi.number().required(),
-            }).unknown(true)),
-          })).messages({ 'any.required': 'Event image is a required field' }),
-        }).unknown(true);
-      break;
-    case EventTypeEnum.Concert:
-        eventSchema = Joi.object().options({ abortEarly: false }).keys({
-          name: Joi.string().required().messages({ 'any.required': 'Event title is a required field' }),
-          description: Joi.string().required().messages({ 'any.required': 'Event description is a required field' }),
-          posterImageUrl: Joi.string().required().messages({ 'any.required': 'Event image is a required field' }),
-          venueId: Joi.string().required().messages({ 'any.required': 'An event venue is required' }),
-          performances: Joi.array().items(Joi.object().keys({
-            headliningArtistIds: Joi.array().items(Joi.string().required()).messages({ 'array.includesRequiredUnknowns': 'An event performer is required for a concert' }),
-          }).unknown(true)).default([]),
-        }).unknown(true);
-      break;
+        eventSchema = Joi.object()
+          .options({ abortEarly: false })
+          .keys({
+            name: Joi.string()
+              .required()
+              .messages({ "string.empty": '"Event name" is a required field' }),
+            description: Joi.string().required().messages({
+              "string.empty": '"Event description" is a required field',
+            }),
+            posterImageUrl: Joi.string().required().messages({
+              "string.empty": '"Event image" is a required field',
+            }),
+            venueId: Joi.string()
+              .required()
+              .messages({ "string.empty": '"Venue" is required' }),
+            ticketTypes: Joi.array()
+              .min(1)
+              .items(
+                Joi.object()
+                  .options({ allowUnknown: true })
+                  .keys({
+                    name: Joi.string().required(),
+                    remainingQty: Joi.number().required(),
+                    totalQty: Joi.number().required(),
+                    purchaseLimit: Joi.number().required(),
+                    tiers: Joi.array().items(
+                      Joi.object()
+                        .keys({
+                          name: Joi.string().required(),
+                          price: Joi.number().required(),
+                          remainingQty: Joi.number().required(),
+                          totalQty: Joi.number().required(),
+                        })
+                        .unknown(true)
+                    ),
+                  })
+              )
+              .messages({ "array.min": "Event must have atleast 1 ticket" }),
+          })
+          .unknown(true);
+        break;
+      case EventTypeEnum.Concert:
+        eventSchema = Joi.object()
+          .options({ abortEarly: false })
+          .keys({
+            name: Joi.string()
+              .required()
+              .messages({ "string.empty": '"Event name" is a required field' }),
+            description: Joi.string().required().messages({
+              "string.empty": '"Event description" is a required field',
+            }),
+            posterImageUrl: Joi.string().required().messages({
+              "string.empty": '"Event image" is a required field',
+            }),
+            venueId: Joi.string()
+              .required()
+              .messages({ "string.empty": '"Venue" is required' }),
+            performances: Joi.array()
+              .items(
+                Joi.object()
+                  .keys({
+                    headliningArtistIds: Joi.array()
+                      .items(Joi.string().required())
+                      .messages({
+                        "array.includesRequiredUnknowns":
+                          "An event performer is required for a concert",
+                      }),
+                  })
+                  .unknown(true)
+              )
+              .default([]),
+          })
+          .unknown(true);
+        break;
     }
 
     return eventSchema.validate(event);
-  }
-
+  },
+  /****************************************************************************************
+   * Ticket validate
+   ****************************************************************************************/
+  validateTicket(ticket: ITicketType, isPaid: Boolean): any {
+    let ticketSchema;
+    let limit = isPaid ? "Purchase limit" : "RSVP limit";
+    let used = ticket.totalQty - ticket.remainingQty;
+    ticketSchema = Joi.object()
+      .options({ abortEarly: false })
+      .keys({
+        name: Joi.string()
+          .required()
+          .messages({ "string.empty": '"Ticket name" is a required field' }),
+        remainingQty: Joi.number().required(),
+        totalQty: Joi.number().required().min(1).messages({
+          "number.required": '"Total qty." is a required field',
+          "number.min": '"Total qty." must be greater than 0',
+        }),
+        purchaseLimit: Joi.number()
+          .required()
+          .min(1)
+          .messages({
+            "number.required": `"${limit}" is a required field`,
+            "number.min": `"${limit}" must be greater than 0`,
+            "number.base": `"${limit}" must be a number`,
+          }),
+        tiers: Joi.array().items(
+          Joi.object()
+            .keys({
+              name: Joi.string().required(),
+              price: Joi.number().required(),
+              remainingQty: Joi.number().required(),
+              totalQty: Joi.number()
+                .custom((value, helpers) => {
+                  if (value > 0 && value < used) {
+                    return helpers.error("totalqty.invalid");
+                  }
+                  return value;
+                })
+                .messages({
+                  "totalqty.invalid":
+                    '"Total qty." must be greater than or equal to number of ticket sold',
+                })
+                .required(),
+            })
+            .unknown(true)
+        ),
+      })
+      .unknown(true);
+    return ticketSchema.validate(ticket);
+  },
+  /****************************************************************************************
+   * Upgrade  validate
+   ****************************************************************************************/
+  validateUpgrade(upgrade: IEventUpgrade, isPaid: Boolean): any {
+    let upgradeSchema;
+    let limit = isPaid ? "Purchase limit" : "RSVP limit";
+    let used = upgrade.totalQty - upgrade.remainingQty;
+    upgradeSchema = Joi.object()
+      .options({ abortEarly: false })
+      .keys({
+        name: Joi.string()
+          .required()
+          .messages({ "string.empty": '"Upgrade name" is a required field' }),
+        price: Joi.number().required(),
+        totalQty: Joi.number()
+          .custom((value, helpers) => {
+            if (value > 0 && value < used) {
+              return helpers.error("totalqty.invalid");
+            }
+            return value;
+          })
+          .messages({
+            "totalqty.invalid":
+              '"Total qty." must be greater than or equal to number of upgrade sold',
+          })
+          .required()
+          .min(1)
+          .messages({
+            "number.required": '"Total qty." is a required field',
+            "number.min": '"Total qty." must be greater than 0',
+          }),
+        remainingQty: Joi.number(),
+        purchaseLimit: Joi.number()
+          .required()
+          .min(1)
+          .messages({
+            "number.required": `"${limit}" is a required field`,
+            "number.min": `"${limit}" must be greater than 0`,
+            "number.base": `"${limit}" must be a number`,
+          }),
+        complimentary: Joi.boolean().required(),
+        complimentaryWith: Joi.string().required(),
+        complimentaryQty: Joi.number().required(),
+        ticketTypeIds: Joi.array().items(Joi.string()).default([]),
+        imageUrl: Joi.string().optional().allow(""),
+        description: Joi.string().optional().allow(""),
+        visible: Joi.boolean().required(),
+        rollFees: Joi.boolean().required(),
+      })
+      .unknown(true);
+    return upgradeSchema.validate(upgrade);
+  },
+  /****************************************************************************************
+   * Promotion  validate
+   ****************************************************************************************/
+  validatePromotion(promotion: IEventPromotion): any {
+    let promotionSchema;
+    let used = promotion.totalQty - promotion.remainingQty;
+    promotionSchema = Joi.object()
+      .options({ abortEarly: false })
+      .keys({
+        code: Joi.string()
+          .required()
+          .messages({ "string.empty": '"Secret code" is a required field' }),
+        type: Joi.string().required(),
+        remainingQty: Joi.number(),
+        totalQty: Joi.number()
+          .custom((value, helpers) => {
+            if (value > 0 && value < used) {
+              return helpers.error("totalqty.invalid");
+            }
+            return value;
+          })
+          .messages({
+            "totalqty.invalid":
+              '"Total qty." must be greater than or equal to number of secret code sold',
+          })
+          .required()
+          .min(1)
+          .messages({
+            "number.required": '"Total qty." is a required field',
+            "number.min": '"Total qty." must be greater than 0',
+          }),
+        ticketTypeIds: Joi.array().items(Joi.string()).default([]),
+        upgradeIds: Joi.array().items(Joi.string()).default([]),
+        active: Joi.boolean().required(),
+        startsAt: Joi.number().required(),
+        endsAt: Joi.number().required(),
+        useLimit: Joi.number().min(1).messages({
+          "number.required": '"Use limit" is a required field',
+          "number.min": 'Use limit" must be greater than 0',
+          "number.base": '"Use limit" must be a number',
+        }),
+        discountType: Joi.string(),
+        discountValue: Joi.number(),
+      })
+      .unknown(true);
+    return promotionSchema.validate(promotion);
+  },
+  /****************************************************************************************
+   * CustomField  validate
+   ****************************************************************************************/
+  validateCustomField(customField: IEventCustomField): any {
+    let customFieldSchema;
+    customFieldSchema = Joi.object()
+      .options({ abortEarly: false })
+      .keys({
+        label: Joi.string()
+          .required()
+          .messages({ "string.empty": '"Question" is a required field' }),
+        type: Joi.string().required(),
+        // minLength: Joi.number(),
+        // maxLength: Joi.number(),
+        // minValue: Joi.number(),
+        // maxValue: Joi.number(),
+        options: Joi.array().items(Joi.string()).default([]),
+        required: Joi.boolean().required(),
+        active: Joi.boolean().required(),
+      })
+      .unknown(true);
+    return customFieldSchema.validate(customField);
+  },
+  validateRefundModal(refundField: IRefundModal): any {
+    let refundFieldSchema;
+    refundFieldSchema = Joi.object()
+      .options({ abortEarly: false })
+      .keys({
+        // ticketIds: Joi.array()
+        //   .min(1)
+        //   .items(Joi.string())
+        //   .messages({ "array.min": "Select any one checkbox for refunding." }),
+        refundReason: Joi.string()
+          .required()
+          .messages({ "string.empty": '"Reason" is a required field' }),
+      })
+      .unknown(true);
+    return refundFieldSchema.validate(refundField);
+  },
 };