ia-common 1.0.1-beta.98 → 1.0.1

package/build/src/model/pricing-plan-entity-model.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BillingCycleModel = exports.PricingPlanEntityModel = void 0;
+const _model_1 = require("../@model");
+class PricingPlanEntityModel {
+    constructor(data) {
+        Object.assign(this, data);
+    }
+    toObject() {
+        const responseObj = {
+            id: this.id,
+            effectiveFromDate: 0,
+            effectiveToDate: 0,
+            basePrice: 0,
+            billingCycle: {},
+        };
+        const billingCycle = this.billingCycle.split(",");
+        billingCycle.forEach((billing, index) => {
+            const billingArray = billing.split("_");
+            responseObj.billingCycle[index] = {
+                noOfMonths: Number(billingArray[0]),
+                discount: billingArray[1],
+                value: parseFloat(billingArray[2]),
+                name: billingArray.slice(3).join("_"),
+                key: billingArray.slice(3).join("-").toLowerCase().replace(/ /g, "-"),
+            };
+        });
+        responseObj.effectiveFromDate = this.effectiveFrom;
+        responseObj.effectiveToDate = this.effectiveTo;
+        responseObj.basePrice = this.basePrice;
+        return responseObj;
+    }
+    static getBillingCycleString(billingCycle) {
+        const billingCycles = [];
+        Object.values(billingCycle).forEach((billing) => {
+            billingCycles.push(`${billing.noOfMonths}_${billing.discount}_${billing.value}_${billing.name}`);
+        });
+        return billingCycles.join(",");
+    }
+    static validateNoOfMonthsByBillingCycle(billingCycle) {
+        const billingCycleKeys = Object.keys(billingCycle);
+        let previousMonthCount = 0;
+        for (const key of billingCycleKeys) {
+            const billingCycleObj = billingCycle[key];
+            const currentMonthCount = billingCycleObj.noOfMonths;
+            if (previousMonthCount >= currentMonthCount && key != "0") {
+                throw new _model_1.AppBadRequestException({
+                    key: `noOfMonths.${key}`,
+                    message: [
+                        `No of months at index ${key} should be greater than ${previousMonthCount}`,
+                    ],
+                });
+            }
+            previousMonthCount = currentMonthCount;
+        }
+    }
+    static validateBillingCycleIndexByBillingCycle(billingCycle) {
+        const billingCycleKeys = Object.keys(billingCycle);
+        for (let i = 0; i < billingCycleKeys.length; i++) {
+            const billingCycleIndex = Number(billingCycleKeys[i]);
+            if (billingCycleIndex !== 0) {
+                const recentBillingCycleIndex = Number(billingCycleKeys[i - 1]);
+                if (recentBillingCycleIndex !== billingCycleIndex - 1) {
+                    throw new _model_1.AppBadRequestException({
+                        key: `billingCycleIndex.${billingCycleIndex}`,
+                        message: [
+                            `billingCycleIndex should be ${recentBillingCycleIndex + 1} at index ${billingCycleIndex}`,
+                        ],
+                    });
+                }
+            }
+        }
+    }
+}
+exports.PricingPlanEntityModel = PricingPlanEntityModel;
+class BillingCycleModel {
+    constructor(code) {
+        this.code = code;
+        this.parse();
+    }
+    parse() {
+        const billingCycleComponents = this.code.split("_");
+        this.noOfMonths = Number(billingCycleComponents[0]);
+        this.discount = billingCycleComponents[1];
+        this.name = billingCycleComponents[2];
+        this.key = this.getKey();
+        return this;
+    }
+    getDiscount() {
+        if (this.discount.indexOf("P") > -1) {
+            return parseFloat(this.discount.replace("P", ""));
+        }
+        return 0;
+    }
+    getKey() {
+        return this.name.toLowerCase().replace(" ", "-");
+    }
+}
+exports.BillingCycleModel = BillingCycleModel;

package/build/src/model/pricing-plan-model.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PricingPlanModel = void 0;
+const _utils_1 = require("../@utils");
+const app_badrequest_exception_1 = require("../exception/app-badrequest.exception");
+class PricingPlanModel {
+    constructor(data) {
+        Object.assign(this, data);
+    }
+    getBillingCycleKeys() {
+        return Object.values(this.billingCycle).map((billingCycleObj) => billingCycleObj.key);
+    }
+    validateBillingCycleKey(key) {
+        if (!this.getBillingCycleKeys().includes(key)) {
+            throw new app_badrequest_exception_1.AppBadRequestException({
+                key: "type",
+                message: [
+                    `subscription with type:'${key}' is wrong,type should be one of the ${this.getBillingCycleKeys()}`,
+                ],
+            });
+        }
+    }
+    getNoOfSubscriptionDays(type) {
+        this.validateBillingCycleKey(type);
+        const billingCycleModel = this.getBillCycleByKey(type);
+        return billingCycleModel.noOfMonths * 30 - 1;
+    }
+    getBillCycleByKey(type) {
+        this.validateBillingCycleKey(type);
+        return Object.values(this.billingCycle).filter((billingCycleObj) => billingCycleObj.key === type)[0];
+    }
+    getToDateCode(fromDateCode, billingCycleKey) {
+        this.validateBillingCycleKey(billingCycleKey);
+        const copyFromDateCode = fromDateCode;
+        const newSubscriptionToDate = new Date(_utils_1.dateUtil.convertStringToDate(String(copyFromDateCode)));
+        newSubscriptionToDate.setDate(newSubscriptionToDate.getDate() +
+            this.getNoOfSubscriptionDays(billingCycleKey));
+        return Number(_utils_1.dateUtil.getDateCode(newSubscriptionToDate));
+    }
+    validateGetToDateCode(fromDateCode, toDateCode, billingCycleKey) {
+        const calculatedToDateCode = this.getToDateCode(fromDateCode, billingCycleKey);
+        if (calculatedToDateCode != Number(toDateCode)) {
+            throw new app_badrequest_exception_1.AppBadRequestException({
+                key: "to",
+                message: [
+                    `calculated to Date:'${calculatedToDateCode}' is not matches with to date you entered`,
+                ],
+            });
+        }
+        return calculatedToDateCode;
+    }
+    getFromToDateCode(billingCycleKey, offset = 0) {
+        const fromDateCode = Number(_utils_1.dateUtil.addNDaysToDateCode(_utils_1.dateUtil.getTodayCode(), offset));
+        const toDateCode = this.getToDateCode(fromDateCode, billingCycleKey);
+        return {
+            fromDateCode,
+            toDateCode,
+        };
+    }
+}
+exports.PricingPlanModel = PricingPlanModel;

package/build/src/model/subscribed-pricing-plan-model.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscribedPricingPlanModel = void 0;
+const _model_1 = require("../@model");
+const _utils_1 = require("../@utils");
+class SubscribedPricingPlanModel {
+    constructor(data, billingCycleKey) {
+        this.basePrice = data.basePrice;
+        this.billingCycleKey = billingCycleKey;
+        this.selectedBillingCycle = data.getBillCycleByKey(billingCycleKey);
+        this.pricingPlanModel = data;
+    }
+    getGrossAmount(config = { roundDown: false }) {
+        const { roundDown } = config;
+        if (roundDown) {
+            return Math.floor(this.basePrice * this.selectedBillingCycle.noOfMonths);
+        }
+        else {
+            return Math.round(this.basePrice * this.selectedBillingCycle.noOfMonths);
+        }
+    }
+    getNextBillingCycleDateRange() {
+        const subscriptionDays = this.pricingPlanModel.getNoOfSubscriptionDays(this.billingCycleKey);
+        const date = _utils_1.dateUtil.addNDaysToDateCode(_utils_1.dateUtil.getDateCode(new Date()), subscriptionDays);
+        return { subscriptionDays, date };
+    }
+    getNetAmount(config = { roundDown: false }) {
+        const { roundDown } = config;
+        if (roundDown) {
+            return Math.floor(this.selectedBillingCycle.value * this.selectedBillingCycle.noOfMonths);
+        }
+        else {
+            return Math.round(this.selectedBillingCycle.value * this.selectedBillingCycle.noOfMonths);
+        }
+    }
+    getBillingDiscount() {
+        if (this.selectedBillingCycle.discount.indexOf("P") > -1) {
+            return parseFloat(this.selectedBillingCycle.discount.replace("P", ""));
+        }
+        return 0;
+    }
+    validateGrossAmount(grossAmount, config) {
+        const calculatedGrossAmount = this.getGrossAmount(config);
+        if (Math.abs(calculatedGrossAmount - grossAmount) > 1) {
+            throw new _model_1.AppBadRequestException({
+                key: `grossAmount`,
+                message: [
+                    `calculated gross amount:'${calculatedGrossAmount}' is not matches with grossAmount you entered`,
+                ],
+            });
+        }
+        return calculatedGrossAmount;
+    }
+    validateNetAmount(netAmount, config) {
+        const calculatedNetAmount = this.getNetAmount(config);
+        if (calculatedNetAmount !== netAmount) {
+            throw new _model_1.AppBadRequestException({
+                key: `netAmount`,
+                message: [
+                    `calculated net amount:'${calculatedNetAmount}' is not matches with netAmount ${netAmount} you entered`,
+                ],
+            });
+        }
+        return calculatedNetAmount;
+    }
+    validateGetBillingCycleDiscount(discount) {
+        if (Number(discount.replace("P", "")) !== this.getBillingDiscount()) {
+            throw new _model_1.AppBadRequestException({
+                key: "discount",
+                message: [
+                    `calculated discount:'${this.getBillingDiscount()}' is not matches with discount you entered`,
+                ],
+            });
+        }
+        return this.getBillingDiscount();
+    }
+}
+exports.SubscribedPricingPlanModel = SubscribedPricingPlanModel;

package/build/{model/subscription-model.js → src/model/subscription-entity-model.js}

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SubscriptionEntityModel = void 0;
-var _model_1 = require("../@model");
-var SubscriptionEntityModel = /** @class */ (function () {
-    function SubscriptionEntityModel(subscriptionEntity) {
+const _model_1 = require("../@model");
+class SubscriptionEntityModel {
+    constructor(subscriptionEntity) {
         Object.assign(this, subscriptionEntity);
     }
-    SubscriptionEntityModel.getEntityInstanceByICreateSubscriptionRequestUserEntity = function (body, userEntity, status, pricingPlanId) {
+    static getEntityInstanceByICreateSubscriptionRequestUserEntity(body, userEntity, status, pricingPlanId) {
         var _a;
-        var subscriptionEntity = {};
+        const subscriptionEntity = {};
         subscriptionEntity.organizationId = userEntity.organizationId;
         subscriptionEntity.fromDateCode = body.from;
         subscriptionEntity.toDateCode = body.to;
@@ -26,15 +26,14 @@ var SubscriptionEntityModel = /** @class */ (function () {
         subscriptionEntity.pricingPlanId = pricingPlanId;
         subscriptionEntity.registrationId = userEntity.registrationId;
         return subscriptionEntity;
-    };
-    SubscriptionEntityModel.prototype.validateAdvanceAmount = function (isAmountPaidValidation) {
-        if (isAmountPaidValidation === void 0) { isAmountPaidValidation = false; }
+    }
+    validateAdvanceAmount(isAmountPaidValidation = false) {
         if (this.amountPaid > this.netAmount) {
             if (isAmountPaidValidation) {
                 throw new _model_1.AppBadRequestException({
                     key: "amountPaid",
                     message: [
-                        "amount paid ".concat(this.amountPaid, " is not equal to net amount ").concat(this.netAmount),
+                        `amount paid ${this.amountPaid} is not equal to net amount ${this.netAmount}`,
                     ],
                 });
             }
@@ -42,12 +41,14 @@ var SubscriptionEntityModel = /** @class */ (function () {
                 throw new _model_1.AppBadRequestException({
                     key: "advanceAmount",
                     message: [
-                        "advance should not greater than net amount:'".concat(this.netAmount, "'"),
+                        `advance should not greater than net amount:'${this.netAmount}'`,
                     ],
                 });
             }
         }
-    };
-    return SubscriptionEntityModel;
-}());
+    }
+    static filterByOrganizationId(subScriptionEntities, organizationId) {
+        return subScriptionEntities.filter((subScriptionEntity) => subScriptionEntity.organizationId === organizationId);
+    }
+}
 exports.SubscriptionEntityModel = SubscriptionEntityModel;

package/build/{model → src/model}/user-entity-model.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserEntityModel = void 0;
-var _enum_1 = require("../@enum");
-var UserEntityModel = /** @class */ (function () {
-    function UserEntityModel(userEntity) {
+const _enum_1 = require("../@enum");
+class UserEntityModel {
+    constructor(userEntity) {
         Object.assign(this, userEntity);
     }
-    UserEntityModel.getEntityInstanceByRegistrationEntityOrganizationId = function (registrationEntity, hashPassword, organizationId) {
-        var userEntity = {};
+    static getEntityInstanceByRegistrationEntityOrganizationId(registrationEntity, hashPassword, organizationId) {
+        const userEntity = {};
         userEntity.firstname = registrationEntity.name;
         userEntity.email = registrationEntity.email;
         userEntity.phone = registrationEntity.contact;
@@ -25,12 +25,11 @@ var UserEntityModel = /** @class */ (function () {
         userEntity.registrationId = registrationEntity.id;
         userEntity.organizationId = organizationId;
         return userEntity;
-    };
-    UserEntityModel.filterByOrganizationId = function (userEntities, organizationId) {
-        return userEntities.filter(function (userEntity) {
+    }
+    static filterByOrganizationId(userEntities, organizationId) {
+        return userEntities.filter((userEntity) => {
             return userEntity.organizationId === organizationId;
         });
-    };
-    return UserEntityModel;
-}());
+    }
+}
 exports.UserEntityModel = UserEntityModel;