@positivegrid/pg-mongoose-schema 27.8.4 → 28.0.0-beta.1

package/models/payment.js

@@ -1,899 +0,0 @@
-'use strict'
-
-const _ = require('lodash')
-const isSubset = require('is-subset')
-const moment = require('moment')
-const mongooseLeanVirtuals = require('mongoose-lean-virtuals')
-const debug = require('debug')('model:payment')
-
-// Support OEM redeem to license type
-const OEM_FOCUSRITE_SUPPORT_LICENSE = [
-  { support_type: { product_name: 'live', type: 'lite' }, display_name: 'LE' },
-  { support_type: { product_name: 'bias', type: 'lite' }, display_name: 'LE' },
-  { support_type: { product_name: 'amp2', type: 'lite' }, display_name: 'LE' }
-]
-const OEM_APOGEE_SUPPORT_LICENSE = [
-  { support_type: { product_name: 'live', type: 'lite' }, display_name: 'BIAS FX JAM' }
-]
-const OEM_PROSONUS_SUPPORT_LICENSE = [
-  { support_type: { product_name: 'fx2', type: 'lite' }, display_name: 'BIAS FX 2 LE' }
-]
-
-const _oemMetaToLicenseName = function (redeemMeta) {
-  let ret
-  switch (redeemMeta['OEM_Name']) {
-    case 'focusrite':
-      ret = _.find(OEM_FOCUSRITE_SUPPORT_LICENSE, (o) => { return isSubset(redeemMeta, o.support_type) })
-      break
-    case 'Apogee':
-      ret = _.find(OEM_APOGEE_SUPPORT_LICENSE, (o) => { return isSubset(redeemMeta, o.support_type) })
-      break
-    case 'ProSonus':
-      ret = _.find(OEM_PROSONUS_SUPPORT_LICENSE, (o) => { return isSubset(redeemMeta, o.support_type) })
-      break
-    default:
-      debug('ERROR:_oemMetaToLicenseName %o', redeemMeta)
-      return null
-  }
-  return (!ret) ? null : { 'oem_name': redeemMeta['OEM_Name'], 'license_name': ret.display_name }
-}
-
-module.exports = (mongoose) => {
-  const Schema = mongoose.Schema
-  const ObjectId = Schema.Types.ObjectId
-
-  const ProductSchema = new Schema({
-    sku: { type: String, required: true, unique: true },
-    name: { type: String, required: true }, // jamup/bias(AMP1)/live(FX1)/amp2/fx2/pedal/proseries
-    display_name: { type: String, required: true },
-    description: { type: String, required: true },
-    price: { type: Number, default: 0, required: true },
-    product_type: { type: Number, default: 0, required: true }, // 0:license, 1:pack, 2: dummy, 3: Partner, 4: IAP, 5: redeem(upgrade), 6: hardware
-    status: { type: Number, default: 1, required: true }, // 0:offline, 1:online, 2:delete
-    quota: { type: Number, default: 1, required: true },
-    addition: { type: Number, required: true }, // 0:professional, 1:demo, 2: standard, 3: lite, 4: elite, 5: test
-    version: { type: String, required: true },
-    max_purchase: { type: Number },
-    can_upgrade_addition: { type: Boolean },
-    can_free_trial: { type: Boolean, default: false },
-    upgrade: {
-      to: { type: ObjectId },
-      price: { type: Number },
-      description: { type: String }
-    },  // Remove in the future
-    upgrade_metadata: [{
-      to: { type: ObjectId },
-      price: { type: Number },
-      description: { type: String }
-    }],
-    discount: { type: Schema.Types.Mixed },  // Remove in the future
-    gift_list: { type: [ObjectId], default: () => { return null } },
-    require_list: { type: Schema.Types.Mixed, default: null },
-    require_one_list: [{ type: ObjectId, ref: 'Product' }],
-    require_one_bundles: [{ type: ObjectId, ref: 'Bundle' }],
-    free_upgrade_list: [{
-      has: { type: ObjectId },
-      to: { type: ObjectId }
-    }],
-    remap_product_sku: { type: String },
-    extra_payment_fields: { type: Schema.Types.Mixed },
-    created_on: { type: Date, default: Date.now },
-    updated_on: { type: Date, default: Date.now }
-  }, { collection: 'jamup_product', toJSON: { virtuals: true }, toObject: { virtuals: true } })
-  ProductSchema.index({ sku: 1 }, { unique: true })
-
-  const LicenseSchema = new Schema({
-    user_id: { type: ObjectId, ref: 'User', required: true },
-    product_id: { type: ObjectId, ref: 'Product', required: true },
-    bc_order_id: { type: Number, default: null },
-    bc_coupon: { type: [String], default: () => { return null } },
-    quota: { type: Number, default: 0 },
-    from_redeem: { type: String, default: null },
-    redeem_id: { type: ObjectId, ref: 'RedeemCode' },
-    from_bundle: { type: ObjectId, ref: 'Bundle', default: null },
-    from_hardware: { type: ObjectId, ref: 'hardware_activation_record', default: null },
-    from_gift: { type: ObjectId, ref: 'License', default: null },
-    from_guest: { type: ObjectId, ref: 'GuestCheckout', default: null },
-    from_remap: { type: ObjectId, ref: 'Product' },
-    from_free_trial: { type: ObjectId, ref: 'FreeTrial', default: null },
-    upgrade_to: { type: ObjectId, ref: 'License', default: null },  // Upgrade from which license
-    price_amount: { type: Number, default: null },
-    due_date: { type: Date, default: null },
-    iap_device_id: { type: String, default: null }, // confirm before remove
-    iap_source: { type: String, default: null },
-    metadata: { type: String, default: null }, // Remove in the future
-    custom_metadata: { type: Schema.Types.Mixed, default: null },
-    status: { type: Number, default: 1 }, // 1:normal/2:delete/3:refund/4:trial
-    created_on: { type: Date, default: Date.now },
-    updated_on: { type: Date, default: Date.now }
-  }, { collection: 'jamup_license' })
-  LicenseSchema.index({ iap_device_id: 1, user_id: 1, product_id: 1, status: 1 })
-  LicenseSchema.index({ user_id: 1, product_id: 1, status: 1, iap_source: 1 })
-  LicenseSchema.index({ from_redeem: 1, user_id: 1 })
-  LicenseSchema.index({ user_id: 1, status: 1, due_date: 1, from_free_trial: 1 })
-  LicenseSchema.set('toJSON', {
-    virtuals: true,
-    transform(_doc, ret) {
-      if (ret.from_free_trial && ret.from_free_trial !== null) {
-        ret.free_trial_meta = {
-          is_free_trial: true,
-          start_date: ret.created_on,
-          end_date: ret.due_date,
-        }
-      } else {
-        ret.free_trial_meta = null;
-      }
-      return ret
-    }
-  })
-  LicenseSchema.set('toObject', {
-    virtuals: true,
-    transform(_doc, ret) {
-      if (ret.from_free_trial && ret.from_free_trial !== null) {
-        ret.free_trial_meta = {
-          is_free_trial: true,
-          start_date: ret.created_on,
-          end_date: ret.due_date,
-        }
-      } else {
-        ret.free_trial_meta = null;
-      }
-      return ret;
-    }
-  })
-
-  const LicenseUpgradeMetaSchema = new Schema({
-    bc_cart_id: { type: String, required: true },
-    user_id: { type: ObjectId, ref: 'auth_user', required: true },
-    upgrade_from: { type: ObjectId, ref: 'jamup_product', default: null, required: true },
-    upgrade_to: { type: ObjectId, ref: 'jamup_product', default: null, required: true },
-    upgrade_bundle_from: [{ type: ObjectId, ref: 'jamup_product' }],
-    upgrade_bundle_to: { type: ObjectId, ref: 'jamup_bundle', default: null },
-    status: { type: Number, default: 0 }, // 0:ReceiveOrder/1:OrderCompleted
-    created_on: { type: Date, default: Date.now }
-  }, { collection: 'license_upgrade_meta' })
-  LicenseUpgradeMetaSchema.index({ bc_cart_id: 1, user_id: 1, upgrade_to: 1, upgrade_from: 1 })
-  LicenseUpgradeMetaSchema.index({ bc_cart_id: 1, user_id: 1, upgrade_bundle_to: 1 })
-  LicenseUpgradeMetaSchema.static({
-    saveUpgradeOrder: async function (bcCartId, userId, upgradeFromProductId, upgradeToProductId) {
-      try {
-        const self = this
-        return await self.findOneAndUpdate({
-          bc_cart_id: bcCartId,
-          user_id: userId,
-          upgrade_from: upgradeFromProductId,
-          upgrade_to: upgradeToProductId
-        }, {
-          '$set': {
-            bc_cart_id: bcCartId,
-            user_id: userId,
-            upgrade_from: upgradeFromProductId,
-            upgrade_to: upgradeToProductId,
-            status: 0,
-            created_on: new Date()
-          }
-        }, { upsert: true }).exec()
-      } catch (err) {
-        debug('ERR:saveUpgradeOrder:%o', err)
-        throw err
-      }
-    },
-    saveBundleUpgradeOrder: async function (bcCartId, userId, userOwnedProductIds, upgradeToBundleId) {
-      try {
-        const self = this
-        return await self.findOneAndUpdate({
-          bc_cart_id: bcCartId,
-          user_id: userId,
-          upgrade_bundle_to: upgradeToBundleId
-        }, {
-          '$set': {
-            bc_cart_id: bcCartId,
-            user_id: userId,
-            upgrade_bundle_to: upgradeToBundleId,
-            upgrade_bundle_from: userOwnedProductIds,
-            status: 0,
-            created_on: new Date()
-          }
-        }, { upsert: true }).exec()
-      } catch (err) {
-        debug('ERR:saveBundleUpgradeOrder:%o', err)
-        throw err
-      }
-    },
-    updateLicenseUpgradeStatusIfExist: async function (bcCartId, userId, targetProductId) {
-      try {
-        const self = this
-        const ret = await self
-          .aggregate()
-          .match({
-            bc_cart_id: bcCartId,
-            user_id: userId,
-            upgrade_to: targetProductId
-          })
-          .lookup({
-            from: 'auth_user',
-            localField: 'user_id',
-            foreignField: '_id',
-            as: 'user'
-          })
-          .unwind('user')
-          .lookup({
-            from: 'jamup_product',
-            localField: 'upgrade_from',
-            foreignField: '_id',
-            as: 'from'
-          })
-          .unwind('from')
-          .lookup({
-            from: 'jamup_product',
-            localField: 'upgrade_to',
-            foreignField: '_id',
-            as: 'to'
-          })
-          .unwind('to')
-          .exec()
-
-        debug('INFO:updateLicenseUpgradeStatusIfExist:%o:%o:%o:%o', ret, bcCartId, userId, targetProductId)
-        if (ret.length === 1) {
-          await self.findOneAndUpdate({
-            bc_cart_id: bcCartId,
-            user_id: userId,
-            upgrade_to: targetProductId
-          }, {
-            '$set': {
-              status: 1
-            }
-          }).exec()
-          return ret[0]
-        } else {
-          return true
-        }
-      } catch (err) {
-        debug('ERR:updateLicenseUpgradeStatusIfExist:%o', err)
-        throw err
-      }
-    },
-    updateBundleUpgradeStatusIfExist: async function (bcCartId, userId, targetBundleId) {
-      try {
-        const self = this
-        const ret = await self.findOne({
-          bc_cart_id: bcCartId,
-          user_id: userId,
-          upgrade_bundle_to: targetBundleId
-        }).exec()
-
-        debug('INFO:updateLicenseUpgradeStatusIfExist:%o:%o:%o:%o', ret, bcCartId, userId, targetBundleId)
-        if (ret) {
-          await self.findOneAndUpdate({
-            bc_cart_id: bcCartId,
-            user_id: userId,
-            upgrade_bundle_to: targetBundleId
-          }, {
-            '$set': {
-              status: 1
-            }
-          }).exec()
-        }
-
-        return true
-      } catch (err) {
-        debug('ERR:updateBundleUpgradeStatusIfExist:%o', err)
-        throw err
-      }
-    }
-  })
-
-
-  let BundleSchema = new Schema({
-    name: { type: String, required: true },
-    display_name: { type: String, required: true },
-    display_detail: { type: String, default: null },
-    description: { type: Array, required: true },
-    price: { type: Number, default: 0, required: true },
-    sku: { type: String, default: null },
-    products: [{ type: ObjectId, ref: 'Product' }], // Array of product Id
-    validate_list: [{ type: ObjectId, ref: 'Product' }], // Verify does user can purchase bundle or not
-    discount: { type: Schema.Types.Mixed },
-    partial_purchase: [{
-      product_id: { type: Schema.Types.Mixed },
-      exclude_product_ids: [{ type: ObjectId, ref: 'Product' }], // only works when discount_type == 'exclude'
-      discount_price: { type: Number },
-      discount_type: { type: String } // amount, max, exclude
-    }],
-    require_list: { type: Schema.Types.Mixed, default: null },
-    require_one_list: { type: Schema.Types.Mixed, default: null },
-    extra_payment_fields: { type: Schema.Types.Mixed, default: null },
-    status: { type: Number, default: 1, required: true }, // 0:offline, 1:online, 2:delete
-    created_on: { type: Date, default: Date.now },
-    updated_on: { type: Date, default: Date.now }
-  }, { collection: 'jamup_bundle', toJSON: { virtuals: true }, toObject: { virtuals: true } })
-
-  let DiscountSchema = new Schema({
-    own_product: { type: ObjectId, ref: 'Product', required: true },
-    discount_product: { type: ObjectId, ref: 'Product' },
-    discount_bundle: { type: ObjectId, ref: 'Bundle' },
-    discount_type: { type: String, required: true }, // amount, percent, overwrite
-    discount_amount: { type: Number, required: true },
-    start_date: { type: Date, default: null },
-    end_date: { type: Date, default: null },
-    status: { type: Boolean, default: true },
-    created_on: { type: Date, default: Date.now }
-  }, { collection: 'jamup_discount', toJSON: { virtuals: true }, toObject: { virtuals: true } })
-
-  const EduDomainSchema = new Schema({
-    domain: { type: String, required: true },
-    name: { type: String, required: true },
-    status: { type: Number, default: 1 }
-  }, { collection: 'edu_domain' })
-  EduDomainSchema.index({ domain: 1 }, { unique: true })
-
-  const EduUserSchema = new Schema({
-    edu_domain_id: { type: ObjectId, ref: 'edu_domain', required: false },
-    user_id: { type: ObjectId, ref: 'auth_user', required: true },
-    edu_email: { type: String, required: true },
-    verify_token: { type: String, default: null },
-    university_field: { type: String, default: null },
-    coupon: { type: String, default: null },
-    status: { type: Number, default: 0, required: true }, // 0:pending/1:verified-and-delivery
-    created_on: { type: Date, default: Date.now, required: true }
-  }, { collection: 'edu_user' })
-
-  const GuestCheckoutSchema = new Schema({
-    email: { type: String, required: true },
-    status: { type: Number, default: 1, required: true }, // 1:Wait for Binding/2: Bind to target account/3: Error/4: Refund
-    bc_order_id: { type: Number, default: null },
-    user_id: { type: ObjectId, ref: 'User', default: null },
-    purchased_items: [{
-      sku: { type: String, required: true },
-      number: { type: Number, default: 1, required: true }
-    }],
-    store_code: { type: String },
-    created_on: { type: Date, default: Date.now, required: true },
-    updated_on: { type: Date, default: Date.now, required: true }
-  }, { collection: 'pg_guest_checkout' })
-  GuestCheckoutSchema.index({ email: 1, bc_order_id: 1 }, { unique: true })
-
-  // additional_purchase.rule:
-  // "has": Buyer need to own the main product
-  // "1to1": Additional purchase and main product should be 1:1
-  // -----
-  // additional_purchase.discount_type:
-  // "amount"/"percent"
-  const AdditionalPurchaseSchema = new Schema({
-    main_product_sku: [{ type: String, required: true }],
-    rule: { type: String, default: 'has' }, //1by1/purchasable/licensePurchasable
-    category: { type: String, default: null },
-    multiplier: { type: Number, default: 1 },
-    additional_purchase: {
-      sku: { type: String, required: true },
-      disount_type: { type: String, default: 'amount' },
-      disount_price: { type: Number, required: true }
-    },
-    include_country: [{type: String}],
-    exclude_country: [{type: String}],
-    status: { type: Number, default: 1 },
-    created_on: { type: Date, default: Date.now }
-  }, { collection: 'additional_purchase_meta' })
-  AdditionalPurchaseSchema.index({ main_product_sku: 1 })
-  AdditionalPurchaseSchema.index({ 'additional_purchase.sku': 1 })
-  AdditionalPurchaseSchema.index({ 'include_country': 1 })
-  AdditionalPurchaseSchema.index({ 'exclude_country': 1 })
-  AdditionalPurchaseSchema.static({
-    canPurchaseAdditional: async function (ownedSku, additionalSku) {
-      if (!_.isArray(ownedSku) || !_.isArray(additionalSku)) {
-        throw new Error('Invalid parameter format!')
-      }
-
-      const additionalPurchaseData = await this.find({
-        'additional_purchase.sku': { $in: additionalSku },
-        status: 1
-      }).exec()
-      if (additionalPurchaseData.length <= 0) {
-        return true
-      }
-
-      let canPurchase = false
-      _.forEach(additionalPurchaseData, addition => {
-        if (addition.rule === 'has') {
-          const compare = _.difference(ownedSku, addition.main_product_sku)
-          if (compare.length < ownedSku.length) {
-            canPurchase = true
-          }
-        }
-      })
-
-      return canPurchase
-    },
-    verifyAdditionalPurchase: async function (skus) {
-      const hasAdditionalPurchase = await this.find({
-        'additional_purchase.sku': { $in: skus },
-        status: 1
-      }).lean().exec()
-      if (hasAdditionalPurchase.length <= 0) {
-        return true
-      }
-
-      // All matching additional purchase should fit the rule
-      let hasFulfill = true
-      _.forEach(hasAdditionalPurchase, addition => {
-        if (addition.rule === 'has') {
-          const mainSkus = addition.main_product_sku
-          const compare = _.difference(mainSkus, skus)
-          if (compare.length >= mainSkus.length) {
-            hasFulfill = false
-          }
-        }
-      })
-
-      return hasFulfill
-    }
-  })
-
-  const CnSalesMetaSchema = new Schema({
-    product_id: { type: ObjectId, ref: 'Product', required: true },
-    status: { type: Number, default: 1, required: true }, // 1: active/2: inactive
-    price: { type: Number, required: true },
-    discount: { type: Number, default: null },
-    gift: { type: [ObjectId], default: () => { return null } },
-    date: { type: Date, default: Date.now }
-  }, { collection: 'cn_sales_meta' })
-  CnSalesMetaSchema.static({
-    getAllSaleItems: async function (query = {}) {
-      try {
-        const queryCondition = (_.isObject(query) && _.isEmpty(query)) ? { status: 1 } : query
-        const result = await this.aggregate()
-          .match(queryCondition)
-          .lookup({
-            'from': 'jamup_product',
-            'localField': 'product_id',
-            'foreignField': '_id',
-            'as': 'product'
-          })
-          .unwind('$product')
-          .project({
-            project_id: 1,
-            price: 1,
-            discount: 1,
-            cn_price: {
-              '$cond': {
-                if: { '$ne': ['$discount', null] },
-                then: { '$multiply': ['$discount', 7] },
-                else: { '$multiply': ['$price', 7] }
-              }
-            },
-            date: 1,
-            product: {
-              _id: 1,
-              name: 1,
-              display_name: 1,
-              sku: 1
-            }
-          })
-          .exec()
-        return result
-      } catch (err) {
-        debug('ERR:getAllSaleItems:%o', err)
-        throw err
-      }
-    }
-  })
-
-  const CnCouponSchema = new Schema({
-    code: { type: String, unique: true, required: true },
-    user_id: { type: ObjectId, ref: 'auth_user', required: false },
-    stripe_order_id: { type: String, required: false }, // This is for CN only; Stripe is used; Only written when multiple_use = False
-    multiple_use: { type: Boolean, required: false },
-    value: {
-      type: Number,
-      required: function () { return !this.ratio }
-    },
-    ratio: {
-      type: Number,
-      required: function () { return !this.value }
-    },
-    type: { type: Number, default: 1, required: true }, // 1:normal/2:allowPromotion
-    status: { type: Number, default: 1, required: true }, // 1:valid/2:used
-    created_on: { type: Date, default: Date.now },
-    expired_on: { type: Date, required: false }
-  }, { collection: 'cn_coupon' })
-  CnCouponSchema.static({
-    createCoupon: async function ({ value, user }) {
-      const generateCnCouponCode = async function () {
-        const code = 'PGCN' + Math.random().toString(36).substr(2, 10).toUpperCase()
-        if (await this.findOne({ code }).exec()) {
-          return generateCnCouponCode()
-        }
-        return code
-      }.bind(this)
-      try {
-        if (!value) {
-          throw new Error('No value provided')
-        }
-        const result = await this.create({
-          code: generateCnCouponCode(),
-          user_id: user ? user._id : null,
-          value
-        })
-        return result
-      } catch (err) {
-        debug('ERR:CnCoupon:createCoupon:%o', err)
-        throw err
-      }
-    },
-    findCoupon: async function (code) {
-      const result = await this.findOne({
-        code,
-        stripe_order_id: { '$exists': false },
-        '$or': [
-          { expired_on: { '$gte': new Date() } },
-          { expired_on: null },
-          { expired_on: { '$exists': false } }
-        ]
-      }).exec()
-      return result
-    }
-  })
-  CnCouponSchema.methods.calculateFinalPrice = function (price) {
-    return this.value ? price - this.value : parseFloat(price * this.ratio).toPrecision(4)
-  }
-  CnCouponSchema.methods.calculateDeducted = function (price) {
-    return this.value ? this.value : price - parseFloat(price * this.ratio).toPrecision(4)
-  }
-  CnCouponSchema.methods.consumeCoupon = async function ({ orderId }) {
-    if (!this.multiple_use) {
-      this.stripe_order_id = orderId
-      return this.save()
-    }
-  }
-
-
-  const BcCartUpdateStatusSchema = new Schema({
-    bc_cart_id: { type: String, required: true },
-    cart_item_id: { type: String, required: true },
-    status: { type: Number, default: 1 }, //1:process/2:finish/3:error
-    created_on: { type: Date, default: Date.now }
-  }, { collection: 'bc_cart_update_status' })
-  BcCartUpdateStatusSchema.static({
-    initCartUpdate: async function (cartId, itemId) {
-      return this.findOneAndUpdate({
-        bc_cart_id: cartId,
-        cart_item_id: itemId
-      }, {
-        $set: {
-          bc_cart_id: cartId,
-          cart_item_id: itemId,
-          status: 1,
-          created_on: new Date()
-        }
-      }, { upsert: true }).exec()
-    },
-    finishCartUpdate: async function (cartId, itemId) {
-      return this.findOneAndUpdate({
-        bc_cart_id: cartId,
-        cart_item_id: itemId
-      }, {
-        $set: {
-          status: 2
-        }
-      }).exec()
-    },
-    handleCartUpdateError: async function (cartId, itemId) {
-      return this.findOneAndUpdate({
-        bc_cart_id: cartId,
-        cart_item_id: itemId
-      }, {
-        $set: {
-          status: 3
-        }
-      }).exec()
-    }
-  })
-
-  const PgUserOrderSchema = new mongoose.Schema({
-    orderId: { type: Number, required: true },
-    customerId: { type: Number },
-    statusId: { type: Number },
-    country: { type: String },
-    totalPrice: { type: Number },
-    purchaseItems: [{
-      sku: { type: String },
-      name: { type: String },
-      quantity: { type: Number },
-      price: { type: Number }
-    }],
-    orderData: { type: Schema.Types.Mixed },
-    createdAt: { type: Date, default: Date.now },
-    updatedAt: { type: Date, default: Date.now }
-  }, { collection: 'pg_user_orders' })
-  PgUserOrderSchema.index({ orderId: 1 })
-  PgUserOrderSchema.index({
-    statusId: 1,
-    'purchaseItems.sku': 1
-  })
-
-  ProductSchema.static({
-    getProductsByCondition: function (condition, cb) {
-      var query = condition || {}
-      this.find(query).sort({ created_on: -1 }).exec(cb)
-    },
-    createProduct: function (data, cb) {
-      this.create(data, function (err, product) {
-        cb(err, product)
-      })
-    }
-  })
-
-  LicenseSchema.static({
-    hasLicenseOrNot: function (userId, productId, cb) {
-      this.findOne({
-        user_id: userId,
-        product_id: productId,
-        status: 1
-      }, function (err, license) {
-        if (err) {
-          return cb(err)
-        } else if (license) {
-          return cb(new Error('User already owned this license'))
-        } else {
-          return cb(null)
-        }
-      })
-    },
-    hasLicensePromise: async function (userID, productID) {
-      const hasProduct = await this.findOne({
-        user_id: userID,
-        product_id: productID,
-        status: 1,
-        '$or': [{ 'due_date': null }, { 'due_date': { $gt: new Date() } }]
-      }).exec()
-      return (hasProduct)
-    },
-    getLicenseByRedeem: function (redeem, cb) {
-      this.find({ from_redeem: redeem }).sort({ created_on: -1 }).exec(cb)
-    },
-    getLicenseByRedeemPromise: async function (redeem, userID) {
-      const output = await this.find({ from_redeem: redeem, user_id: mongoose.Types.ObjectId(userID) })
-        .sort({ created_on: -1 })
-        .populate('product_id')
-        .exec()
-      return output
-    },
-    // Include normal & trial licenses
-    getUserLicense: function (query, cb) {
-      if (!_.isObject(query)) {
-        return cb(Error('Given query params should be a object'))
-      }
-
-      const queryObj = _.assign({}, query, {
-        status: { '$in': [1, 4] },
-        '$or': [{ 'due_date': null }, { 'due_date': { $gt: new Date() } }]
-      })
-
-      this.find(queryObj)
-        .sort({ created_on: -1 })
-        .populate('product_id', 'id name price product_type status version addition extra_payment_fields')
-        .exec(function (err, licenses) {
-          if (err) return cb(err)
-          if (Array.isArray(licenses) === false) return cb(new Error('Invalid data format'))
-
-          let result = []
-          licenses.forEach((item) => {
-            if (item.product_id) {
-              result.push(item)
-            } else {
-              debug('getUserLicense:Invalid', item)
-            }
-          })
-
-          debug('getUserLicense:Return', result)
-          return cb(null, result)
-        })
-    },
-    // Include normal & trial licenses
-    getUserLicensePromise: async function (query) {
-      try {
-        if (!_.isObject(query)) {
-          throw new Error('Given query params should be a object')
-        }
-
-        const queryObj = _.assign({}, query, {
-          status: { '$in': [1, 4] },
-          '$or': [{ 'due_date': null }, { 'due_date': { $gt: new Date() } }]
-        })
-
-        const licenseData = await this.find(queryObj)
-          .sort({ created_on: -1 })
-          .populate('product_id', 'id name price product_type status version addition extra_payment_fields')
-          .exec()
-
-        if (!_.isArray(licenseData)) {
-          throw new Error('Invalid license data')
-        }
-
-        let result = []
-        licenseData.forEach(item => {
-          if (item.product_id) {
-            result.push(item)
-          } else {
-            debug('getUserLicense:Invalid', item)
-          }
-        })
-
-        debug('getUserLicense:Return', result)
-        return result
-      } catch (err) {
-        throw err
-      }
-    },
-    // Include normal & trial licenses
-    getUserPurchase: function (query, productType, cb) {
-      if (!_.isObject(query)) {
-        return cb(Error('Given query params should be a object'))
-      }
-
-      let populateProductList = (productType === 'pack')
-        ? 'id name product_type display_name extra_payment_fields created_on'
-        : 'id name price product_type display_name status version addition'
-
-      const queryObj = _.assign({}, query, {
-        status: { '$in': [1, 4] },
-        '$or': [{ 'due_date': null }, { 'due_date': { $gt: new Date() } }]
-      })
-
-      this.find(queryObj)
-        .sort({ created_on: -1 })
-        .populate('product_id', populateProductList)
-        .exec(cb)
-    },
-    // Include normal & trial licenses
-    getUserPurchasePromise: async function (query, productType, opts) {
-      try {
-        if (!_.isObject(query)) {
-          throw new Error('Given query params should be a object')
-        }
-
-        let populateProductList = (productType === 'pack')
-          ? 'id name sku product_type display_name extra_payment_fields created_on'
-          : 'id name sku product_type display_name addition created_on'
-
-        const freeTrialQuery = (productType === 'free_trial')
-          ? { $and: [{ from_free_trial: { $ne: null } }, { from_free_trial: { $exists: true } }] }
-          : { $or: [{ from_free_trial: null }, { from_free_trial: { $exists: false } }] }
-
-        // Always check license status & due_date
-        const queryObj = _.assign({}, {
-          status: { '$in': [1, 4] },
-          '$or': [{ 'due_date': null }, { 'due_date': { $gt: new Date() } }]
-        }, freeTrialQuery, query)
-        debug('getUserPurchasePromise %o', queryObj)
-
-        const result = (_.has(opts, 'isLean') && opts.isLean === true)
-          ? await this.find(queryObj)
-            .sort({ created_on: -1 })
-            .populate('product_id', populateProductList)
-            .lean({ virtuals: true })
-            .exec()
-          : await this.find(queryObj)
-            .sort({ created_on: -1 })
-            .populate('product_id', populateProductList)
-            .exec()
-
-        debug('getUserPurchasePromise %o', result)
-        return result
-      } catch (err) {
-        throw err
-      }
-    },
-    getUserIapLicenses: async function (userId, iapIds) {
-      try {
-        return this.aggregate([
-          {
-            '$match': {
-              'user_id': userId,
-              'product_id': { '$in': iapIds },
-              'status': 1,
-              '$or': [{ 'due_date': null }, { 'due_date': { $gt: new Date() } }]
-            }
-          },
-          {
-            '$lookup': {
-              'from': 'jamup_product',
-              'localField': 'product_id',
-              'foreignField': '_id',
-              'as': 'product'
-            }
-          },
-          { '$unwind': '$product' },
-          {
-            '$project': {
-              'main_product': '$product.extra_payment_fields.main_product',
-              'iap_id': '$product.extra_payment_fields.iap_id',
-              'category': '$product.extra_payment_fields.category',
-              'display_name': '$product.display_name',
-              'user_id': '$user_id',
-              'source': '$iap_source',
-              'created_on': '$created_on'
-            }
-          }
-        ]).exec()
-      } catch (err) {
-        debug('ERR:getUserIapLicenses %o', err)
-        throw err
-      }
-    },
-    createTrialLicense: async function (data) {
-      try {
-        if (!_.has(data, 'due_date') || !moment(data.due_date).isValid()) {
-          throw new Error('Invalid trail license format!')
-        }
-
-        const ret = await this.create(_.assign({}, data, {
-          'status': 4,
-          'due_date': moment(data.due_date).toDate()
-        }))
-        return ret
-      } catch (err) {
-        debug('ERR:createTrialLicense:%o', err)
-        throw err
-      }
-    },
-    createLicense: function (data, cb) {
-      var that = this
-      that.create(data, function (err, license) {
-        if (err) return cb(err)
-
-        that.findById(license.id).populate('product_id').exec(cb)
-      })
-    },
-    createLicensePromise: async function (data) {
-      try {
-        const newLicense = await this.create(data)
-        return await this.findById(newLicense.id).populate('product_id').exec()
-      } catch (err) {
-        debug('ERR:createLicensePromise:%o', err)
-        throw err
-      }
-    },
-    removeLicense: function (licenseID) {
-      return this
-        .findOneAndUpdate({ _id: licenseID }, { $set: { status: 2 } })
-        .exec()
-    }
-  })
-  ProductSchema.virtual('id').get(function () {
-    return this._id.toHexString()
-  })
-
-  LicenseSchema.virtual('id').get(function () {
-    return this._id.toHexString()
-  })
-  LicenseSchema.virtual('product').get(function () {
-    return this.product_id
-  })
-  LicenseSchema.virtual('oem').get(function () {
-    return (this.custom_metadata && this.custom_metadata['OEM_Name'])
-      ? _oemMetaToLicenseName(this.custom_metadata)
-      : null
-  })
-  BundleSchema.virtual('id').get(function () {
-    return this._id.toHexString()
-  })
-  DiscountSchema.virtual('id').get(function () {
-    return this._id.toHexString()
-  })
-  LicenseSchema.plugin(mongooseLeanVirtuals)
-
-  mongoose.model('Product', ProductSchema)
-  mongoose.model('License', LicenseSchema)
-  mongoose.model('LicenseUpgradeMeta', LicenseUpgradeMetaSchema)
-  mongoose.model('Bundle', BundleSchema)
-  mongoose.model('Discount', DiscountSchema)
-  mongoose.model('EduDomain', EduDomainSchema)
-  mongoose.model('EduUser', EduUserSchema)
-  mongoose.model('GuestCheckout', GuestCheckoutSchema)
-  mongoose.model('CnCoupon', CnCouponSchema)
-  mongoose.model('CnSalesMeta', CnSalesMetaSchema)
-  mongoose.model('AdditionalPurchase', AdditionalPurchaseSchema)
-  mongoose.model('BcCartUpdateStatus', BcCartUpdateStatusSchema)
-  mongoose.model('UserOrder', PgUserOrderSchema)
-}