ia-common 1.0.1-beta.21 → 1.0.1-beta.211

package/build/model/pricing-plan-entity-model.d.ts

@@ -1,6 +1,6 @@
 import { PricingPlanStatus } from "../@enum";
-import { IGetPricingPlanByDateResponse, IPricingPlanEntity } from "../@type";
-export declare class PricingPlanEntityModel {
+import { IBillingCycle, IGetPricingPlanByDateResponse, IPricingPlanEntity } from "../@type";
+export declare class PricingPlanEntityModel implements IPricingPlanEntity {
     id: number;
     effectiveFrom: number;
     effectiveTo: number;
@@ -13,6 +13,9 @@ export declare class PricingPlanEntityModel {
     billingCycle: string;
     constructor(data: IPricingPlanEntity);
     toObject(): IGetPricingPlanByDateResponse;
+    static getBillingCycleString(billingCycle: IBillingCycle): string;
+    static validateNoOfMonthsByBillingCycle(billingCycle: IBillingCycle): void;
+    static validateBillingCycleIndexByBillingCycle(billingCycle: IBillingCycle): void;
 }
 export declare class BillingCycleModel {
     code: string;
@@ -25,41 +28,3 @@ export declare class BillingCycleModel {
     getDiscount(): number;
     getKey(): string;
 }
-export interface IPricingPlanModel {
-    id: number;
-    effectiveFromDate: number;
-    effectiveToDate: number;
-    basePrice: number;
-    billingCycle: {
-        [key: string]: {
-            noOfMonths: number;
-            discount: string;
-            name: string;
-            key: string;
-        };
-    };
-}
-export declare class PricingPlanModel implements IPricingPlanModel {
-    id: number;
-    effectiveFromDate: number;
-    effectiveToDate: number;
-    basePrice: number;
-    billingCycle: {
-        [key: string]: {
-            noOfMonths: number;
-            discount: string;
-            name: string;
-            key: string;
-        };
-    };
-    constructor(data: IGetPricingPlanByDateResponse);
-    getBillingCycleKeys(): string[];
-    getNoOfSubscriptionDays(type: string): number;
-    getBillCycleByKey(type: string): {
-        noOfMonths: number;
-        discount: string;
-        name: string;
-        key: string;
-    };
-    validateBillingCycleKey(key: string): void;
-}

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PricingPlanModel = exports.BillingCycleModel = exports.PricingPlanEntityModel = void 0;
-var app_badrequest_exception_1 = require("../exception/app-badrequest.exception");
+exports.BillingCycleModel = exports.PricingPlanEntityModel = void 0;
+var _model_1 = require("../@model");
 var PricingPlanEntityModel = /** @class */ (function () {
     function PricingPlanEntityModel(data) {
         Object.assign(this, data);
@@ -20,8 +20,9 @@ var PricingPlanEntityModel = /** @class */ (function () {
             responseObj.billingCycle[index] = {
                 noOfMonths: Number(billingArray[0]),
                 discount: billingArray[1],
-                name: billingArray.slice(2).join("_"),
-                key: billingArray.slice(2).join("-").toLowerCase().replace(/ /g, "-"),
+                value: parseFloat(billingArray[2]),
+                name: billingArray.slice(3).join("_"),
+                key: billingArray.slice(3).join("-").toLowerCase().replace(/ /g, "-"),
             };
         });
         responseObj.effectiveFromDate = this.effectiveFrom;
@@ -29,6 +30,48 @@ var PricingPlanEntityModel = /** @class */ (function () {
         responseObj.basePrice = this.basePrice;
         return responseObj;
     };
+    PricingPlanEntityModel.getBillingCycleString = function (billingCycle) {
+        var billingCycles = [];
+        Object.values(billingCycle).forEach(function (billing) {
+            billingCycles.push("".concat(billing.noOfMonths, "_").concat(billing.discount, "_").concat(billing.value, "_").concat(billing.name));
+        });
+        return billingCycles.join(",");
+    };
+    PricingPlanEntityModel.validateNoOfMonthsByBillingCycle = function (billingCycle) {
+        var billingCycleKeys = Object.keys(billingCycle);
+        var previousMonthCount = 0;
+        for (var _i = 0, billingCycleKeys_1 = billingCycleKeys; _i < billingCycleKeys_1.length; _i++) {
+            var key = billingCycleKeys_1[_i];
+            var billingCycleObj = billingCycle[key];
+            var currentMonthCount = billingCycleObj.noOfMonths;
+            if (previousMonthCount >= currentMonthCount && key != "0") {
+                throw new _model_1.AppBadRequestException({
+                    key: "noOfMonths.".concat(key),
+                    message: [
+                        "No of months at index ".concat(key, " should be greater than ").concat(previousMonthCount),
+                    ],
+                });
+            }
+            previousMonthCount = currentMonthCount;
+        }
+    };
+    PricingPlanEntityModel.validateBillingCycleIndexByBillingCycle = function (billingCycle) {
+        var billingCycleKeys = Object.keys(billingCycle);
+        for (var i = 0; i < billingCycleKeys.length; i++) {
+            var billingCycleIndex = Number(billingCycleKeys[i]);
+            if (billingCycleIndex !== 0) {
+                var recentBillingCycleIndex = Number(billingCycleKeys[i - 1]);
+                if (recentBillingCycleIndex !== billingCycleIndex - 1) {
+                    throw new _model_1.AppBadRequestException({
+                        key: "billingCycleIndex.".concat(billingCycleIndex),
+                        message: [
+                            "billingCycleIndex should be ".concat(recentBillingCycleIndex + 1, " at index ").concat(billingCycleIndex),
+                        ],
+                    });
+                }
+            }
+        }
+    };
     return PricingPlanEntityModel;
 }());
 exports.PricingPlanEntityModel = PricingPlanEntityModel;
@@ -57,30 +100,3 @@ var BillingCycleModel = /** @class */ (function () {
     return BillingCycleModel;
 }());
 exports.BillingCycleModel = BillingCycleModel;
-var PricingPlanModel = /** @class */ (function () {
-    function PricingPlanModel(data) {
-        Object.assign(this, data);
-    }
-    PricingPlanModel.prototype.getBillingCycleKeys = function () {
-        return Object.values(this.billingCycle).map(function (billingCycleObj) { return billingCycleObj.key; });
-    };
-    PricingPlanModel.prototype.getNoOfSubscriptionDays = function (type) {
-        var billingCycleModel = this.getBillCycleByKey(type);
-        return billingCycleModel.noOfMonths * 30 - 1;
-    };
-    PricingPlanModel.prototype.getBillCycleByKey = function (type) {
-        return Object.values(this.billingCycle).filter(function (billingCycleObj) { return billingCycleObj.key === type; })[0];
-    };
-    PricingPlanModel.prototype.validateBillingCycleKey = function (key) {
-        if (!this.getBillingCycleKeys().includes(key)) {
-            throw new app_badrequest_exception_1.AppBadRequestException({
-                key: "type",
-                message: [
-                    "subscription with type:'".concat(key, "' is wrong,type should be one of the ").concat(this.getBillingCycleKeys()),
-                ],
-            });
-        }
-    };
-    return PricingPlanModel;
-}());
-exports.PricingPlanModel = PricingPlanModel;

package/build/model/pricing-plan-model.d.ts

@@ -0,0 +1,21 @@
+import { IGetPricingPlanByDateResponse, IPricingPlanModel, IBillingCycleObj } from "../@type";
+export declare class PricingPlanModel implements IPricingPlanModel {
+    id: number;
+    effectiveFromDate: number;
+    effectiveToDate: number;
+    basePrice: number;
+    billingCycle: {
+        [key: string]: IBillingCycleObj;
+    };
+    constructor(data: IGetPricingPlanByDateResponse);
+    getBillingCycleKeys(): string[];
+    validateBillingCycleKey(key: string): void;
+    getNoOfSubscriptionDays(type: string): number;
+    getBillCycleByKey(type: string): IBillingCycleObj;
+    getToDateCode(fromDateCode: number, billingCycleKey: string): number;
+    validateGetToDateCode(fromDateCode: number, toDateCode: number, billingCycleKey: string): number;
+    getFromToDateCode(billingCycleKey: string, offset?: number): {
+        fromDateCode: number;
+        toDateCode: number;
+    };
+}

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

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

package/build/model/right-issue-corporate-action-model.d.ts

@@ -0,0 +1,20 @@
+import { CorporateActionsStatus, CorporateActionsType } from "../@enum";
+import { ICorporateActionsEntity, ICorporateEntityOmitData, IRightIssueCorporateAction } from "../@type";
+export declare class RightIssueCorporateActionModel implements IRightIssueCorporateAction, ICorporateEntityOmitData {
+    price: number;
+    startDate: number;
+    endDate: number;
+    ratio: string;
+    companyName: string;
+    recordDate: number;
+    type: CorporateActionsType;
+    status: CorporateActionsStatus;
+    ratioInWord: string;
+    id: number;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    constructor(entity: ICorporateActionsEntity);
+    getCorporateActionEntity(): ICorporateActionsEntity;
+}

package/build/model/right-issue-corporate-action-model.js

@@ -0,0 +1,34 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RightIssueCorporateActionModel = void 0;
+var _enum_1 = require("../@enum");
+var _utils_1 = require("../@utils");
+var RightIssueCorporateActionModel = /** @class */ (function () {
+    function RightIssueCorporateActionModel(entity) {
+        _utils_1.ValidateUtils.validateCorporateActionType(entity.type, _enum_1.CorporateActionsType.RIGHTS_ISSUE);
+        Object.assign(this, __assign(__assign({}, entity), JSON.parse(entity.data)));
+    }
+    RightIssueCorporateActionModel.prototype.getCorporateActionEntity = function () {
+        var corporateActionEntity = __assign(__assign({}, this), { data: JSON.stringify({
+                ratio: this.ratio,
+                price: this.price,
+                startDate: this.startDate,
+                endDate: this.endDate,
+                ratioInWord: this.ratioInWord,
+            }) });
+        return corporateActionEntity;
+    };
+    return RightIssueCorporateActionModel;
+}());
+exports.RightIssueCorporateActionModel = RightIssueCorporateActionModel;

package/build/model/split-bonus-corporate-action-model.d.ts

@@ -0,0 +1,18 @@
+import { CorporateActionsStatus, CorporateActionsType, OrderOfSplitAndBonusStock } from "../@enum";
+import { IBonusStockData, ICorporateActionsEntity, ICorporateEntityOmitData, ISplitBonusCorporateAction, ISplitStockData } from "../@type";
+export declare class SplitBonusCorporateActionModel implements ISplitBonusCorporateAction, ICorporateEntityOmitData {
+    splitStock: ISplitStockData;
+    bonusStock: IBonusStockData;
+    order: OrderOfSplitAndBonusStock;
+    companyName: string;
+    recordDate: number;
+    type: CorporateActionsType;
+    status: CorporateActionsStatus;
+    id: number;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    constructor(entity: ICorporateActionsEntity);
+    getCorporateActionEntity(): ICorporateActionsEntity;
+}

package/build/model/split-bonus-corporate-action-model.js

@@ -0,0 +1,35 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SplitBonusCorporateActionModel = void 0;
+var SplitBonusCorporateActionModel = /** @class */ (function () {
+    function SplitBonusCorporateActionModel(entity) {
+        Object.assign(this, __assign(__assign({}, entity), JSON.parse(entity.data)));
+    }
+    SplitBonusCorporateActionModel.prototype.getCorporateActionEntity = function () {
+        var corporateActionEntity = __assign(__assign({}, this), { data: JSON.stringify({
+                splitStock: {
+                    currentFV: this.splitStock.currentFV,
+                    newFV: this.splitStock.newFV,
+                },
+                bonusStock: {
+                    ratio: this.bonusStock.ratio,
+                    ratioInWords: this.bonusStock.ratioInWords,
+                },
+                order: this.order,
+            }) });
+        return corporateActionEntity;
+    };
+    return SplitBonusCorporateActionModel;
+}());
+exports.SplitBonusCorporateActionModel = SplitBonusCorporateActionModel;

package/build/model/split-corporate-action-model.d.ts

@@ -0,0 +1,17 @@
+import { CorporateActionsStatus, CorporateActionsType } from "../@enum";
+import { ICorporateActionsEntity, ICorporateEntityOmitData, ISplitCorporateAction } from "../@type";
+export declare class SplitCorporateActionModel implements ISplitCorporateAction, ICorporateEntityOmitData {
+    currentFV: number;
+    newFV: number;
+    companyName: string;
+    recordDate: number;
+    type: CorporateActionsType;
+    status: CorporateActionsStatus;
+    id: number;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    constructor(entity: ICorporateActionsEntity);
+    getCorporateActionEntity(): ICorporateActionsEntity;
+}

package/build/model/split-corporate-action-model.js

@@ -0,0 +1,31 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SplitCorporateActionModel = void 0;
+var _enum_1 = require("../@enum");
+var _utils_1 = require("../@utils");
+var SplitCorporateActionModel = /** @class */ (function () {
+    function SplitCorporateActionModel(entity) {
+        _utils_1.ValidateUtils.validateCorporateActionType(entity.type, _enum_1.CorporateActionsType.SPLIT);
+        Object.assign(this, __assign(__assign({}, entity), JSON.parse(entity.data)));
+    }
+    SplitCorporateActionModel.prototype.getCorporateActionEntity = function () {
+        var corporateActionEntity = __assign(__assign({}, this), { data: JSON.stringify({
+                currentFV: this.currentFV,
+                newFV: this.newFV,
+            }) });
+        return corporateActionEntity;
+    };
+    return SplitCorporateActionModel;
+}());
+exports.SplitCorporateActionModel = SplitCorporateActionModel;

package/build/model/subscribed-pricing-plan-model.d.ts

@@ -1,20 +1,27 @@
-import { PricingPlanModel } from "./pricing-plan-entity-model";
-export declare class SubscribedPricingPlanModel extends PricingPlanModel {
+import { IBillingCycleObj } from "../@type";
+import { PricingPlanModel } from "./pricing-plan-model";
+export declare class SubscribedPricingPlanModel {
     billingCycleKey: string;
-    selectedBillingCycle: {
-        noOfMonths: number;
-        discount: string;
-        name: string;
-        key: string;
-    };
-    selectedPitchSlabBasePrice: number;
+    selectedBillingCycle: IBillingCycleObj;
+    basePrice: number;
+    pricingPlanModel: PricingPlanModel;
     constructor(data: PricingPlanModel, billingCycleKey: string);
-    getBasePrice(): number;
     getGrossAmount(config?: {
         roundDown: boolean;
     }): number;
+    getNextBillingCycleDateRange(): {
+        subscriptionDays: number;
+        date: string;
+    };
     getNetAmount(config?: {
         roundDown: boolean;
     }): number;
     getBillingDiscount(): number;
+    validateGrossAmount(grossAmount: number, config?: {
+        roundDown: boolean;
+    }): number;
+    validateNetAmount(netAmount: number, config?: {
+        roundDown: boolean;
+    }): number;
+    validateGetBillingCycleDiscount(discount: string): number;
 }

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

@@ -1,33 +1,15 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SubscribedPricingPlanModel = void 0;
-var pricing_plan_entity_model_1 = require("./pricing-plan-entity-model");
-var SubscribedPricingPlanModel = /** @class */ (function (_super) {
-    __extends(SubscribedPricingPlanModel, _super);
+var _model_1 = require("../@model");
+var _utils_1 = require("../@utils");
+var SubscribedPricingPlanModel = /** @class */ (function () {
     function SubscribedPricingPlanModel(data, billingCycleKey) {
-        var _this = _super.call(this, data) || this;
-        _this.billingCycleKey = billingCycleKey;
-        _this.selectedBillingCycle = data.getBillCycleByKey(billingCycleKey);
-        return _this;
+        this.basePrice = data.basePrice;
+        this.billingCycleKey = billingCycleKey;
+        this.selectedBillingCycle = data.getBillCycleByKey(billingCycleKey);
+        this.pricingPlanModel = data;
     }
-    SubscribedPricingPlanModel.prototype.getBasePrice = function () {
-        return this.selectedPitchSlabBasePrice;
-    };
     SubscribedPricingPlanModel.prototype.getGrossAmount = function (config) {
         if (config === void 0) { config = { roundDown: false }; }
         var roundDown = config.roundDown;
@@ -38,18 +20,19 @@ var SubscribedPricingPlanModel = /** @class */ (function (_super) {
             return Math.round(this.basePrice * this.selectedBillingCycle.noOfMonths);
         }
     };
+    SubscribedPricingPlanModel.prototype.getNextBillingCycleDateRange = function () {
+        var subscriptionDays = this.pricingPlanModel.getNoOfSubscriptionDays(this.billingCycleKey);
+        var date = _utils_1.dateUtil.addNDaysToDateCode(_utils_1.dateUtil.getDateCode(new Date()), subscriptionDays);
+        return { subscriptionDays: subscriptionDays, date: date };
+    };
     SubscribedPricingPlanModel.prototype.getNetAmount = function (config) {
         if (config === void 0) { config = { roundDown: false }; }
         var roundDown = config.roundDown;
         if (roundDown) {
-            return Math.floor(this.basePrice *
-                (1 - this.getBillingDiscount() / 100) *
-                this.selectedBillingCycle.noOfMonths);
+            return Math.floor(this.selectedBillingCycle.value * this.selectedBillingCycle.noOfMonths);
         }
         else {
-            return Math.round(this.basePrice *
-                (1 - this.getBillingDiscount() / 100) *
-                this.selectedBillingCycle.noOfMonths);
+            return Math.round(this.selectedBillingCycle.value * this.selectedBillingCycle.noOfMonths);
         }
     };
     SubscribedPricingPlanModel.prototype.getBillingDiscount = function () {
@@ -58,6 +41,41 @@ var SubscribedPricingPlanModel = /** @class */ (function (_super) {
         }
         return 0;
     };
+    SubscribedPricingPlanModel.prototype.validateGrossAmount = function (grossAmount, config) {
+        var calculatedGrossAmount = this.getGrossAmount(config);
+        if (Math.abs(calculatedGrossAmount - grossAmount) > 1) {
+            throw new _model_1.AppBadRequestException({
+                key: "grossAmount",
+                message: [
+                    "calculated gross amount:'".concat(calculatedGrossAmount, "' is not matches with grossAmount you entered"),
+                ],
+            });
+        }
+        return calculatedGrossAmount;
+    };
+    SubscribedPricingPlanModel.prototype.validateNetAmount = function (netAmount, config) {
+        var calculatedNetAmount = this.getNetAmount(config);
+        if (calculatedNetAmount !== netAmount) {
+            throw new _model_1.AppBadRequestException({
+                key: "netAmount",
+                message: [
+                    "calculated net amount:'".concat(calculatedNetAmount, "' is not matches with netAmount ").concat(netAmount, " you entered"),
+                ],
+            });
+        }
+        return calculatedNetAmount;
+    };
+    SubscribedPricingPlanModel.prototype.validateGetBillingCycleDiscount = function (discount) {
+        if (Number(discount.replace("P", "")) !== this.getBillingDiscount()) {
+            throw new _model_1.AppBadRequestException({
+                key: "discount",
+                message: [
+                    "calculated discount:'".concat(this.getBillingDiscount(), "' is not matches with discount you entered"),
+                ],
+            });
+        }
+        return this.getBillingDiscount();
+    };
     return SubscribedPricingPlanModel;
-}(pricing_plan_entity_model_1.PricingPlanModel));
+}());
 exports.SubscribedPricingPlanModel = SubscribedPricingPlanModel;

package/build/model/subscription-entity-model.d.ts

@@ -0,0 +1,25 @@
+import { SubscriptionStatus } from "../@enum";
+import { ICreateSubscriptionRequest, ISubscriptionEntity, IUserEntity } from "../@type";
+export declare class SubscriptionEntityModel implements ISubscriptionEntity {
+    id: number;
+    fromDateCode: number;
+    toDateCode: number;
+    organizationId: number;
+    type: string;
+    grossAmount: number;
+    discount: string;
+    netAmount: number;
+    amountPaid: number;
+    status: SubscriptionStatus;
+    remarks: string;
+    registrationId: number;
+    pricingPlanId: number;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    constructor(subscriptionEntity: ISubscriptionEntity);
+    static getEntityInstanceByICreateSubscriptionRequestUserEntity(body: ICreateSubscriptionRequest, userEntity: IUserEntity, status: SubscriptionStatus, pricingPlanId: number): ISubscriptionEntity;
+    validateAdvanceAmount(isAmountPaidValidation?: boolean): void;
+    static filterByOrganizationId(subScriptionEntities: ISubscriptionEntity[], organizationId: number): ISubscriptionEntity[];
+}

package/build/model/subscription-entity-model.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionEntityModel = void 0;
+var _model_1 = require("../@model");
+var SubscriptionEntityModel = /** @class */ (function () {
+    function SubscriptionEntityModel(subscriptionEntity) {
+        Object.assign(this, subscriptionEntity);
+    }
+    SubscriptionEntityModel.getEntityInstanceByICreateSubscriptionRequestUserEntity = function (body, userEntity, status, pricingPlanId) {
+        var _a;
+        var subscriptionEntity = {};
+        subscriptionEntity.organizationId = userEntity.organizationId;
+        subscriptionEntity.fromDateCode = body.from;
+        subscriptionEntity.toDateCode = body.to;
+        subscriptionEntity.type = body.type;
+        subscriptionEntity.grossAmount = body.grossAmount;
+        subscriptionEntity.discount = body.discount;
+        subscriptionEntity.netAmount = body.netAmount;
+        subscriptionEntity.amountPaid = body.amountPaid;
+        subscriptionEntity.status = status;
+        subscriptionEntity.remarks = (_a = body.remarks) !== null && _a !== void 0 ? _a : "";
+        subscriptionEntity.createdBy = userEntity.id;
+        subscriptionEntity.createdOn = new Date();
+        subscriptionEntity.updatedBy = userEntity.id;
+        subscriptionEntity.updatedOn = new Date();
+        subscriptionEntity.pricingPlanId = pricingPlanId;
+        subscriptionEntity.registrationId = userEntity.registrationId;
+        return subscriptionEntity;
+    };
+    SubscriptionEntityModel.prototype.validateAdvanceAmount = function (isAmountPaidValidation) {
+        if (isAmountPaidValidation === void 0) { 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),
+                    ],
+                });
+            }
+            else {
+                throw new _model_1.AppBadRequestException({
+                    key: "advanceAmount",
+                    message: [
+                        "advance should not greater than net amount:'".concat(this.netAmount, "'"),
+                    ],
+                });
+            }
+        }
+    };
+    SubscriptionEntityModel.filterByOrganizationId = function (subScriptionEntities, organizationId) {
+        return subScriptionEntities.filter(function (subScriptionEntity) {
+            return subScriptionEntity.organizationId === organizationId;
+        });
+    };
+    return SubscriptionEntityModel;
+}());
+exports.SubscriptionEntityModel = SubscriptionEntityModel;

package/build/model/user-entity-model.d.ts

@@ -0,0 +1,26 @@
+import { UserStatus, UserType } from "../@enum";
+import { IRegistrationEntity, IUserEntity } from "../@type";
+export declare class UserEntityModel implements IUserEntity {
+    id: number;
+    firstname: string;
+    phone: string;
+    password: string;
+    email: string;
+    status: UserStatus;
+    isEmailVerified: boolean;
+    isMobileVerified: boolean;
+    isAccountVerified: boolean;
+    requireNewPassword: boolean;
+    type: UserType;
+    registrationId: number;
+    organizationId: number;
+    imageUrl: string | null;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    documentUrls: string | null;
+    constructor(userEntity: IUserEntity);
+    static getEntityInstanceByRegistrationEntityOrganizationId(registrationEntity: IRegistrationEntity, hashPassword: string, organizationId: number): IUserEntity;
+    static filterByOrganizationId(userEntities: IUserEntity[], organizationId: number): IUserEntity[];
+}