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

package/dist/models/payment.js

@@ -0,0 +1,859 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const is_subset_1 = __importDefault(require("is-subset"));
+const mongoose_lean_virtuals_1 = __importDefault(require("mongoose-lean-virtuals"));
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)("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 = OEM_FOCUSRITE_SUPPORT_LICENSE.find((o) => (0, is_subset_1.default)(redeemMeta, o.support_type));
+            break;
+        case "Apogee":
+            ret = OEM_APOGEE_SUPPORT_LICENSE.find((o) => (0, is_subset_1.default)(redeemMeta, o.support_type));
+            break;
+        case "ProSonus":
+            ret = OEM_PROSONUS_SUPPORT_LICENSE.find((o) => (0, is_subset_1.default)(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 };
+};
+function default_1(mongoose) {
+    const { Schema } = mongoose;
+    const { ObjectId } = Schema.Types;
+    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: () => 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: () => 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 {
+                return await this.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 {
+                return await this.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 ret = await this.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 this.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 ret = await this.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 this.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;
+            }
+        },
+    });
+    const 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 } });
+    const 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 (!Array.isArray(ownedSku) || !Array.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;
+            additionalPurchaseData.forEach((addition) => {
+                if (addition.rule === "has") {
+                    const compare = ownedSku.filter((x) => !addition.main_product_sku.includes(x));
+                    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;
+            hasAdditionalPurchase.forEach((addition) => {
+                if (addition.rule === "has") {
+                    const mainSkus = addition.main_product_sku;
+                    const compare = mainSkus.filter((x) => !skus.includes(x));
+                    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: () => null },
+        date: { type: Date, default: Date.now },
+    }, { collection: "cn_sales_meta" });
+    CnSalesMetaSchema.static({
+        getAllSaleItems: async function (query = {}) {
+            try {
+                const queryCondition = typeof query === "object" && Object.keys(query).length === 0 ? { 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] }, // eslint-disable-line unicorn/no-thenable
+                            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 () => {
+                const code = "PGCN" + Math.random().toString(36).substring(2, 12).toUpperCase();
+                if (await this.findOne({ code }).exec()) {
+                    return generateCnCouponCode();
+                }
+                return code;
+            };
+            try {
+                if (!value) {
+                    throw new Error("No value provided");
+                }
+                const result = await this.create({
+                    code: await 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 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: async function (condition) {
+            const query = condition || {};
+            return this.find(query).sort({ created_on: -1 }).exec();
+        },
+        createProduct: async function (data) {
+            return this.create(data);
+        },
+    });
+    LicenseSchema.static({
+        hasLicenseOrNot: async function (userId, productId) {
+            const license = await this.findOne({
+                user_id: userId,
+                product_id: productId,
+                status: 1,
+            }).exec();
+            if (license) {
+                throw new Error("User already owned this license");
+            }
+        },
+        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: async function (redeem) {
+            return this.find({ from_redeem: redeem }).sort({ created_on: -1 }).exec();
+        },
+        getLicenseByRedeemPromise: async function (redeem, userID) {
+            const output = await this.find({
+                from_redeem: redeem,
+                user_id: new mongoose.Types.ObjectId(userID),
+            })
+                .sort({ created_on: -1 })
+                .populate("product_id")
+                .exec();
+            return output;
+        },
+        // Include normal & trial licenses
+        getUserLicense: async function (query) {
+            if (typeof query !== "object") {
+                throw new Error("Given query params should be a object");
+            }
+            const queryObj = {
+                ...query,
+                status: { $in: [1, 4] },
+                $or: [{ due_date: null }, { due_date: { $gt: new Date() } }],
+            };
+            const licenses = await this.find(queryObj)
+                .sort({ created_on: -1 })
+                .populate("product_id", "id name price product_type status version addition extra_payment_fields")
+                .exec();
+            if (!Array.isArray(licenses)) {
+                throw new Error("Invalid data format");
+            }
+            const result = [];
+            licenses.forEach((item) => {
+                if (item.product_id) {
+                    result.push(item);
+                }
+                else {
+                    debug("getUserLicense:Invalid", item);
+                }
+            });
+            debug("getUserLicense:Return", result);
+            return result;
+        },
+        // Include normal & trial licenses
+        getUserLicensePromise: async function (query) {
+            if (typeof query !== "object") {
+                throw new Error("Given query params should be a object");
+            }
+            const queryObj = {
+                ...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 (!Array.isArray(licenseData)) {
+                throw new Error("Invalid license data");
+            }
+            const result = [];
+            licenseData.forEach((item) => {
+                if (item.product_id) {
+                    result.push(item);
+                }
+                else {
+                    debug("getUserLicense:Invalid", item);
+                }
+            });
+            debug("getUserLicense:Return", result);
+            return result;
+        },
+        // Include normal & trial licenses
+        getUserPurchase: async function (query, productType) {
+            if (typeof query !== "object") {
+                throw new Error("Given query params should be a object");
+            }
+            const 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 = {
+                ...query,
+                status: { $in: [1, 4] },
+                $or: [{ due_date: null }, { due_date: { $gt: new Date() } }],
+            };
+            return this.find(queryObj)
+                .sort({ created_on: -1 })
+                .populate("product_id", populateProductList)
+                .exec();
+        },
+        // Include normal & trial licenses
+        getUserPurchasePromise: async function (query, productType, opts) {
+            if (typeof query !== "object") {
+                throw new Error("Given query params should be a object");
+            }
+            const 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 = {
+                status: { $in: [1, 4] },
+                $or: [{ due_date: null }, { due_date: { $gt: new Date() } }],
+                ...freeTrialQuery,
+                ...query,
+            };
+            debug("getUserPurchasePromise %o", queryObj);
+            const result = opts && "isLean" in opts && 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;
+        },
+        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 (!("due_date" in data) || isNaN(new Date(data.due_date).getTime())) {
+                    throw new Error("Invalid trail license format!");
+                }
+                const ret = await this.create({
+                    ...data,
+                    status: 4,
+                    due_date: new Date(data.due_date),
+                });
+                return ret;
+            }
+            catch (err) {
+                debug("ERR:createTrialLicense:%o", err);
+                throw err;
+            }
+        },
+        createLicense: async function (data) {
+            const newLicense = await this.create(data);
+            return this.findById(newLicense.id).populate("product_id").exec();
+        },
+        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();
+        },
+    });
+    // Keep product and oem virtuals on LicenseSchema
+    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;
+    });
+    LicenseSchema.plugin(mongoose_lean_virtuals_1.default);
+    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);
+}
+//# sourceMappingURL=payment.js.map