turf-common 1.0.16 → 1.0.17

package/build/models/entity/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./booking-details-model"), exports);
+__exportStar(require("./booking-entity-model"), exports);
+__exportStar(require("./booking-payment-history-model"), exports);
+__exportStar(require("./cancellation-policy-model"), exports);
+__exportStar(require("./configuration-model"), exports);
+__exportStar(require("./price-model"), exports);
+__exportStar(require("./pricing-plan-entity-model"), exports);
+__exportStar(require("./subscription-model"), exports);
+__exportStar(require("./turf-model"), exports);
+__exportStar(require("./user-model"), exports);

package/build/models/entity/price-model.d.ts

@@ -0,0 +1,11 @@
+import { IPriceModel } from "../../interface/model";
+import { IPriceEntity } from "../../interface/entity/price-entity.interface";
+export declare class PriceModel implements IPriceModel {
+    id: string;
+    price: number;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    static sortByCode(priceEntities: IPriceEntity[]): IPriceEntity[];
+}

package/build/models/entity/price-model.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriceModel = void 0;
+var PriceModel = /** @class */ (function () {
+    function PriceModel() {
+    }
+    PriceModel.sortByCode = function (priceEntities) {
+        priceEntities = priceEntities.sort(function (a, b) {
+            return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+        });
+        return priceEntities;
+    };
+    return PriceModel;
+}());
+exports.PriceModel = PriceModel;

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

@@ -0,0 +1,47 @@
+import { PricingPlanStatus } from "../../enums/pricing-plan-status.enum";
+import { IBillingCycleModel } from "../../interface/billing-cycle.interface";
+import { GetPricingPlanByDateResponse } from "../../interface/get-pricing-plan-by-date-response.interface";
+import { IPitchSlab } from "../../interface/pitch-slab.interface";
+import { IPricingPlanEntityModel } from "../../interface/model/pricing-plan-entity-model.interface";
+import { IPricingPlanEntity } from "../../interface/entity/pricing-plan-entity.interface";
+import { BillingCycleModel } from "../billing-cycle-model";
+import { PricingPlanModel } from "../pricing-plan-model";
+export declare class PricingPlanEntityModel implements IPricingPlanEntityModel {
+    id: number;
+    effectiveFrom: Date;
+    effectiveTo: Date;
+    costCode: string;
+    status: PricingPlanStatus;
+    createdBy: number;
+    createdOn: Date;
+    updatedBy: number;
+    updatedOn: Date;
+    basePrice: number;
+    billingCycle: string;
+    unit: string;
+    constructor(data: IPricingPlanEntity);
+    getBillingCycleKeys(): string[];
+    toModel(): PricingPlanModel;
+    arrayToIndexedObject<T>(arr: T[]): {
+        [key: string]: T;
+    };
+    toObject(): GetPricingPlanByDateResponse;
+    toPitchSlabs(): IPitchSlab[];
+    toBillingCycles(): IBillingCycleModel[];
+}
+export declare class PitchSlabParser {
+    code: string;
+    constructor(code: string);
+    parseToModel(): IPitchSlab;
+}
+export declare class BillingCycleCodeParser {
+    code: string;
+    from: number;
+    to: number;
+    discount: string;
+    name: string;
+    constructor(code: string);
+    parse(): BillingCycleCodeParser;
+    parseToModel(): BillingCycleModel;
+    getKey(): string;
+}

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

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BillingCycleCodeParser = exports.PitchSlabParser = exports.PricingPlanEntityModel = void 0;
+var billing_cycle_model_1 = require("../billing-cycle-model");
+var booking_code_model_1 = require("../booking-code-model");
+var pitch_slab_model_1 = require("../pitch-slab-model");
+var pricing_plan_model_1 = require("../pricing-plan-model");
+var PricingPlanEntityModel = /** @class */ (function () {
+    function PricingPlanEntityModel(data) {
+        Object.assign(this, data);
+    }
+    PricingPlanEntityModel.prototype.getBillingCycleKeys = function () {
+        return this.toBillingCycles().map(function (billingCycle) { return billingCycle.key; });
+    };
+    PricingPlanEntityModel.prototype.toModel = function () {
+        return new pricing_plan_model_1.PricingPlanModel({
+            id: this.id,
+            base_price: this.basePrice,
+            effective_from_date: parseInt(booking_code_model_1.BookingCode.getDateCode(this.effectiveFrom)),
+            effective_to_date: parseInt(booking_code_model_1.BookingCode.getDateCode(this.effectiveTo)),
+            unit: this.unit,
+            billing_cycle: this.arrayToIndexedObject(this.toBillingCycles()),
+            pitch_slab: this.arrayToIndexedObject(this.toPitchSlabs()),
+        });
+    };
+    PricingPlanEntityModel.prototype.arrayToIndexedObject = function (arr) {
+        return arr.reduce(function (result, item, index) {
+            result[index.toString()] = item; //a, b, c
+            return result;
+        }, {});
+    };
+    PricingPlanEntityModel.prototype.toObject = function () {
+        var responseObj = {
+            id: this.id,
+            effective_from_date: 0,
+            effective_to_date: 0,
+            base_price: 0,
+            unit: "per_hour_per_pitch",
+            pitch_slab: {},
+            billing_cycle: {},
+        };
+        var billingCycle = this.billingCycle.split(",");
+        billingCycle.forEach(function (billing, index) {
+            var billingArray = billing.split("_");
+            responseObj.billing_cycle[index] = {
+                from: Number(billingArray[0].slice(0, 3)),
+                to: Number(billingArray[0].slice(3, 6)),
+                discount: billingArray[1],
+                name: billingArray.slice(2).join("_"),
+                key: billingArray.slice(2).join("-").toLowerCase().replace(/ /g, "-"),
+            };
+        });
+        this.costCode.split(",").forEach(function (code, index) {
+            var costCode = code.split("_");
+            responseObj.pitch_slab[index] = {
+                from: Number(costCode[0].slice(0, 3)),
+                to: Number(costCode[0].slice(3, 6)),
+                discount: costCode[1],
+            };
+        });
+        responseObj.effective_from_date = Number(booking_code_model_1.BookingCode.getDateCode(this.effectiveFrom));
+        responseObj.effective_to_date = Number(booking_code_model_1.BookingCode.getDateCode(this.effectiveTo));
+        responseObj.unit = this.unit;
+        responseObj.base_price = this.basePrice;
+        return responseObj;
+    };
+    PricingPlanEntityModel.prototype.toPitchSlabs = function () {
+        return this.costCode
+            .split(",")
+            .map(function (cost_code) { return new PitchSlabParser(cost_code).parseToModel(); });
+    };
+    PricingPlanEntityModel.prototype.toBillingCycles = function () {
+        return this.billingCycle
+            .split(",")
+            .map(function (billingCode) {
+            return new BillingCycleCodeParser(billingCode).parseToModel();
+        });
+    };
+    return PricingPlanEntityModel;
+}());
+exports.PricingPlanEntityModel = PricingPlanEntityModel;
+var PitchSlabParser = /** @class */ (function () {
+    function PitchSlabParser(code) {
+        this.code = code;
+    }
+    PitchSlabParser.prototype.parseToModel = function () {
+        var costCodeComponents = this.code.split("_");
+        return new pitch_slab_model_1.PitchSlabModel({
+            discount: costCodeComponents[1],
+            from: parseInt(costCodeComponents[0].slice(0, 3)),
+            to: parseInt(costCodeComponents[0].slice(3)),
+        });
+    };
+    return PitchSlabParser;
+}());
+exports.PitchSlabParser = PitchSlabParser;
+var BillingCycleCodeParser = /** @class */ (function () {
+    function BillingCycleCodeParser(code) {
+        this.code = code;
+    }
+    BillingCycleCodeParser.prototype.parse = function () {
+        var billingCycleComponents = this.code.split("_");
+        this.from = parseInt(billingCycleComponents[0].slice(0, 3));
+        this.to = parseInt(billingCycleComponents[0].slice(3, 6));
+        this.discount = billingCycleComponents[1];
+        this.name = billingCycleComponents[2];
+        return this;
+    };
+    BillingCycleCodeParser.prototype.parseToModel = function () {
+        var billingCycleComponents = this.code.split("_");
+        this.from = parseInt(billingCycleComponents[0].slice(0, 3));
+        this.to = parseInt(billingCycleComponents[0].slice(3, 6));
+        this.discount = billingCycleComponents[1];
+        this.name = billingCycleComponents[2];
+        return new billing_cycle_model_1.BillingCycleModel({
+            discount: this.discount,
+            from: this.from,
+            to: this.to,
+            name: this.name,
+            key: this.getKey(),
+        });
+    };
+    BillingCycleCodeParser.prototype.getKey = function () {
+        return this.name.toLowerCase().replace(" ", "-");
+    };
+    return BillingCycleCodeParser;
+}());
+exports.BillingCycleCodeParser = BillingCycleCodeParser;

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

@@ -0,0 +1,30 @@
+import { SubscriptionStatus } from "../../enums/subscription-status.enum";
+import { ISubscriptionEntity, ISubscriptionModel } from "../../interface/entity/subscription-entity.interface";
+export declare class SubscriptionModel implements ISubscriptionModel {
+    id: number;
+    organizationId: number;
+    from: Date;
+    to: Date;
+    type: string;
+    grossAmount: number;
+    discount: string;
+    netAmount: number;
+    amountPaid: number;
+    status: SubscriptionStatus;
+    noOfPitches: number;
+    remarks: string;
+    registrationId: number;
+    pricingPlanId: number;
+    previousSubscriptionIds: string;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    constructor(data: ISubscriptionEntity);
+    remainingSubscriptionDays(): number;
+    static updateStatus(subscriptionEntities: ISubscriptionEntity[], status: SubscriptionStatus, userId: number): ISubscriptionEntity[];
+    remainingAmount(): number;
+    isAmountFullyPaid(): boolean;
+    isAmountPaidGreater(): boolean;
+    updateStatusIfPaymentDone(): void;
+}

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionModel = void 0;
+var subscription_status_enum_1 = require("../../enums/subscription-status.enum");
+var SubscriptionModel = /** @class */ (function () {
+    function SubscriptionModel(data) {
+        Object.assign(this, data);
+    }
+    SubscriptionModel.prototype.remainingSubscriptionDays = function () {
+        var oneDay = 24 * 60 * 60 * 1000;
+        var dayDifference = Math.ceil((this.to.getTime() - new Date().getTime()) / oneDay);
+        return dayDifference - 1; //minus 1 day
+    };
+    SubscriptionModel.updateStatus = function (subscriptionEntities, status, userId) {
+        return subscriptionEntities.map(function (subscriptionEntity) {
+            subscriptionEntity.status = status;
+            subscriptionEntity.updatedBy = userId;
+            subscriptionEntity.updatedOn = new Date();
+            return subscriptionEntity;
+        });
+    };
+    SubscriptionModel.prototype.remainingAmount = function () {
+        return this.netAmount - this.amountPaid;
+    };
+    SubscriptionModel.prototype.isAmountFullyPaid = function () {
+        if (this.netAmount === this.amountPaid) {
+            return true;
+        }
+        return false;
+    };
+    SubscriptionModel.prototype.isAmountPaidGreater = function () {
+        if (this.amountPaid > this.netAmount) {
+            return true;
+        }
+        return false;
+    };
+    SubscriptionModel.prototype.updateStatusIfPaymentDone = function () {
+        if (this.isAmountFullyPaid()) {
+            this.status =
+                this.status === subscription_status_enum_1.SubscriptionStatus.UPGRADE_PAYMENT_PENDING
+                    ? subscription_status_enum_1.SubscriptionStatus.UPGRADE_PAYMENT_DONE
+                    : this.status === subscription_status_enum_1.SubscriptionStatus.UPGRADE_RENEW_PAYMENT_PENDING
+                        ? subscription_status_enum_1.SubscriptionStatus.UPGRADE_RENEW_PAYMENT_DONE
+                        : this.status === subscription_status_enum_1.SubscriptionStatus.PAYMENT_PENDING
+                            ? subscription_status_enum_1.SubscriptionStatus.PAYMENT_DONE
+                            : this.status;
+        }
+    };
+    return SubscriptionModel;
+}());
+exports.SubscriptionModel = SubscriptionModel;

package/build/models/entity/turf-model.d.ts

@@ -0,0 +1,34 @@
+import { IPitchStatus } from "../../enums/pitch-status.enum";
+import { ITurf } from "../../interface/get-turf-entity.interface";
+import { ITurfModel } from "../../interface/model/turf-model.interface";
+import { IOrganizationEntity } from "../../interface/entity/organization-entity.interface";
+import { IPitchEntity } from "../../interface/entity/pitch-entity.interface";
+import { ISubscriptionPitchMappingEntity } from "../../interface/entity/subscription-pitch-mapping.interface";
+import { ITurfEntity } from "../../interface/entity/turf-entity.interface";
+import { IUserEntity } from "../../interface/entity/user-entity.interface";
+export declare class TurfModel implements ITurfModel {
+    id: number;
+    turfName: string;
+    numberOfPitches: number;
+    address: string;
+    org_id: number;
+    adhocRefund: boolean;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    pitches: IPitchEntity[];
+    organization: IOrganizationEntity;
+    Users: IUserEntity[];
+    constructor(data: ITurfEntity);
+    getPitchStatusCount(): IPitchStatus;
+    getModifiedTurfEntity(): ITurf;
+    static toMap(turfEntities: ITurfModel[]): {
+        [key: number]: ITurf;
+    };
+    static toKeyValue(turfEntities: ITurfEntity[]): {
+        [key: number]: ITurfEntity;
+    };
+    static fromEntity(data: ITurfEntity): ITurfModel;
+    static filterBySubscriptionPitchMapping(turfEntities: ITurfEntity[], subscriptionPitchMappingEntities: ISubscriptionPitchMappingEntity[], pitchStatusSet: Set<string>): ITurfEntity[];
+}

package/build/models/entity/turf-model.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurfModel = void 0;
+var pitch_status_enum_1 = require("../../enums/pitch-status.enum");
+var TurfModel = /** @class */ (function () {
+    function TurfModel(data) {
+        Object.assign(this, data);
+    }
+    TurfModel.prototype.getPitchStatusCount = function () {
+        var statusCount = {};
+        for (var _i = 0, _a = Object.values(pitch_status_enum_1.PitchStatus); _i < _a.length; _i++) {
+            var status_1 = _a[_i];
+            statusCount[status_1] = 0;
+        }
+        for (var _b = 0, _c = this.pitches; _b < _c.length; _b++) {
+            var pitch = _c[_b];
+            statusCount[pitch.status] += 1;
+        }
+        return statusCount;
+    };
+    TurfModel.prototype.getModifiedTurfEntity = function () {
+        return {
+            id: this.id,
+            turfName: this.turfName,
+            numberOfPitches: this.numberOfPitches,
+            address: this.address,
+            org_id: this.org_id,
+            updatedBy: this.updatedBy,
+            updatedOn: this.updatedOn,
+            createdBy: this.createdBy,
+            createdOn: this.createdOn,
+            pitches: this.pitches.map(function (_a) {
+                var turf = _a.turf, number = _a.number, name = _a.name, status = _a.status, sports = _a.sports, createdBy = _a.createdBy, createdOn = _a.createdOn, updatedBy = _a.updatedBy, updatedOn = _a.updatedOn;
+                return ({
+                    turf: turf.id,
+                    number: number,
+                    name: name,
+                    status: status,
+                    sports: sports.split(",").map(function (sport) { return ({ name: sport }); }),
+                    createdBy: createdBy,
+                    createdOn: createdOn,
+                    updatedBy: updatedBy,
+                    updatedOn: updatedOn,
+                });
+            }),
+        };
+    };
+    TurfModel.toMap = function (turfEntities) {
+        var response = {};
+        turfEntities.forEach(function (turfEntity) {
+            if (!response[turfEntity.id]) {
+                response[turfEntity.id] = turfEntity.getModifiedTurfEntity();
+            }
+        });
+        return response;
+    };
+    TurfModel.toKeyValue = function (turfEntities) {
+        var response = {};
+        turfEntities.forEach(function (turfEntity) {
+            if (!response[turfEntity.id]) {
+                response[turfEntity.id] = turfEntity;
+            }
+        });
+        return response;
+    };
+    TurfModel.fromEntity = function (data) {
+        return new TurfModel(data);
+    };
+    TurfModel.filterBySubscriptionPitchMapping = function (turfEntities, subscriptionPitchMappingEntities, pitchStatusSet) {
+        turfEntities.forEach(function (turfEntity) {
+            turfEntity.pitches = turfEntity.pitches.filter(function (pitchEntity) {
+                var subscriptionPitchMappingEntity = subscriptionPitchMappingEntities.find(function (_a) {
+                    var turfId = _a.turfId, pitchId = _a.pitchId, status = _a.status;
+                    return turfId === turfEntity.id &&
+                        pitchId === pitchEntity.number &&
+                        pitchStatusSet.has(status);
+                });
+                if (subscriptionPitchMappingEntity)
+                    return true;
+                else
+                    false;
+            });
+        });
+        return turfEntities;
+    };
+    return TurfModel;
+}());
+exports.TurfModel = TurfModel;

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

@@ -0,0 +1,32 @@
+import { UserStatus } from "../../enums/user-status.enum";
+import { UserType } from "../../enums/valid-type.enum";
+import { IUserModel } from "../../interface/model/user-model.interface";
+import { ITurfEntity } from "../../interface/entity/turf-entity.interface";
+import { IUserEntity } from "../../interface/entity/user-entity.interface";
+export declare class UserModel implements IUserModel {
+    id: number;
+    firstname: string;
+    lastname: string;
+    phone: string;
+    password: string;
+    email: string;
+    status: UserStatus;
+    is_email_verified: boolean;
+    is_mobile_verified: boolean;
+    is_account_verified: boolean;
+    require_new_password: boolean;
+    organization_id: number;
+    type: UserType;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    registrationId: number;
+    comments: string;
+    turf: ITurfEntity[];
+    imageUrl: string;
+    constructor(data: IUserModel);
+    static toMap(userEntities: IUserEntity[]): {
+        [key: number]: IUserEntity;
+    };
+}

package/build/models/entity/user-model.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserModel = void 0;
+var UserModel = /** @class */ (function () {
+    function UserModel(data) {
+        Object.assign(this, data);
+    }
+    UserModel.toMap = function (userEntities) {
+        var response = {};
+        userEntities.forEach(function (userEntity) {
+            if (!response[userEntity.id]) {
+                response[userEntity.id] = userEntity;
+            }
+        });
+        return response;
+    };
+    return UserModel;
+}());
+exports.UserModel = UserModel;

package/build/models/pitch-slab-model.d.ts

@@ -0,0 +1,9 @@
+import { IPitchSlab } from "../interface/pitch-slab.interface";
+export declare class PitchSlabModel implements IPitchSlab {
+    from: number;
+    to: number;
+    discount: string;
+    constructor(data: IPitchSlab);
+    getDiscount(): number;
+    getBasePrice(basePrice: number): number;
+}

package/build/models/pitch-slab-model.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PitchSlabModel = void 0;
+var PitchSlabModel = /** @class */ (function () {
+    function PitchSlabModel(data) {
+        this.from = data.from;
+        this.to = data.to;
+        this.discount = data.discount;
+    }
+    PitchSlabModel.prototype.getDiscount = function () {
+        if (this.discount.indexOf("P") > -1) {
+            return parseFloat(this.discount.replace("P", ""));
+        }
+        return 0;
+    };
+    PitchSlabModel.prototype.getBasePrice = function (basePrice) {
+        return basePrice * (1 - this.getDiscount() / 100);
+    };
+    return PitchSlabModel;
+}());
+exports.PitchSlabModel = PitchSlabModel;

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

@@ -0,0 +1,24 @@
+import { IPricingPlanModel } from "../interface/pricing-plan.interface";
+import { PitchSlabModel } from "./pitch-slab-model";
+import { BillingCycleModel } from "./billing-cycle-model";
+export declare class PricingPlanModel implements IPricingPlanModel {
+    id: number;
+    effective_from_date: number;
+    effective_to_date: number;
+    base_price: number;
+    unit: string;
+    pitch_slab: {
+        [key: string]: PitchSlabModel;
+    };
+    billing_cycle: {
+        [key: string]: BillingCycleModel;
+    };
+    constructor(data: IPricingPlanModel);
+    getPitchSlab(pitchCount: number): PitchSlabModel;
+    getBillingCycle(billingCycleKey: string): BillingCycleModel;
+    getMonth(billingCycleKey: string): number;
+    getNoOfSubscriptionDays(billingCycleKey: string): number;
+    getBillingCycleKeys(): string[];
+    validateBillingCycleKey(billingCycleKey: string): void;
+    getBillingCycleByDay(numberOfDay: number): BillingCycleModel | undefined;
+}

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PricingPlanModel = void 0;
+var pitch_slab_model_1 = require("./pitch-slab-model");
+var billing_cycle_model_1 = require("./billing-cycle-model");
+var app_badrequest_exception_1 = require("../exceptions/app-badrequest.exception");
+var PricingPlanModel = /** @class */ (function () {
+    function PricingPlanModel(data) {
+        var _this = this;
+        this.id = data.id;
+        this.effective_from_date = data.effective_from_date;
+        this.effective_to_date = data.effective_to_date;
+        this.base_price = data.base_price;
+        this.unit = data.unit;
+        this.pitch_slab = {};
+        this.billing_cycle = {};
+        Object.keys(data.pitch_slab).forEach(function (key) {
+            _this.pitch_slab[key] = new pitch_slab_model_1.PitchSlabModel(data.pitch_slab[key]);
+        });
+        Object.keys(data.billing_cycle).forEach(function (key) {
+            _this.billing_cycle[key] = new billing_cycle_model_1.BillingCycleModel(data.billing_cycle[key]);
+        });
+    }
+    PricingPlanModel.prototype.getPitchSlab = function (pitchCount) {
+        var pitchRangesMap = this.pitch_slab;
+        var pitchRanges = Object.values(pitchRangesMap);
+        var selectedPitchSlab = pitchRanges.filter(function (pitchRange) {
+            return pitchRange.from <= pitchCount && pitchCount <= pitchRange.to;
+        })[0];
+        return selectedPitchSlab;
+    };
+    PricingPlanModel.prototype.getBillingCycle = function (billingCycleKey) {
+        var billingCycleMap = this.billing_cycle;
+        var billingCycles = Object.values(billingCycleMap);
+        var selectedBillingCycle = billingCycles.filter(function (_a) {
+            var key = _a.key;
+            return key === billingCycleKey;
+        })[0];
+        return selectedBillingCycle;
+    };
+    PricingPlanModel.prototype.getMonth = function (billingCycleKey) {
+        return this.getBillingCycle(billingCycleKey).to;
+    };
+    PricingPlanModel.prototype.getNoOfSubscriptionDays = function (billingCycleKey) {
+        return this.getBillingCycle(billingCycleKey).to * 30 - 1;
+    };
+    PricingPlanModel.prototype.getBillingCycleKeys = function () {
+        return Object.values(this.billing_cycle).map(function (obj) { return obj.key; });
+    };
+    PricingPlanModel.prototype.validateBillingCycleKey = function (billingCycleKey) {
+        if (!this.getBillingCycleKeys().includes(billingCycleKey)) {
+            throw new app_badrequest_exception_1.AppBadRequestException({
+                key: "type",
+                message: ["pricing plan type:'".concat(billingCycleKey, "' is not found")],
+            });
+        }
+    };
+    PricingPlanModel.prototype.getBillingCycleByDay = function (numberOfDay) {
+        return Object.values(this.billing_cycle).find(function (obj) {
+            if (numberOfDay <= obj.to * 30) {
+                return obj;
+            }
+        });
+    };
+    return PricingPlanModel;
+}());
+exports.PricingPlanModel = PricingPlanModel;

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

@@ -0,0 +1,26 @@
+import { IPricingPlanModel } from "../interface/pricing-plan.interface";
+import { BillingCycleModel } from "./billing-cycle-model";
+import { PitchSlabModel } from "./pitch-slab-model";
+import { PricingPlanModel } from "./pricing-plan-model";
+export declare class SubscribedPricingPlanModel extends PricingPlanModel {
+    pitchCount: number;
+    billingCycle: string;
+    selectedPitchSlab: PitchSlabModel;
+    selectedBillingCycle: BillingCycleModel;
+    selectedPitchSlabBasePrice: number;
+    hourInMonth: number;
+    months: number | undefined;
+    constructor(data: IPricingPlanModel, pitchCount: number, billingCycle: string);
+    getMonths(): number;
+    getBasePrice(): number;
+    getGrossAmount(): number;
+    getNetAmount(): number;
+    getBillingDiscount(): number;
+    getMonthDifference(that: SubscribedPricingPlanModel): number;
+    getGrossAmountByMonth(month: number): number;
+    getNetAmountByMonth(month: number): number;
+    getGrossAmountByPitchDays(pitchCount: number, days: number): number;
+    getNetAmountByPitchDays(pitchCount: number, days: number): number;
+    getGrossAmountByPitchDaysBasePrice(basePrice: number, pitchCount: number, days: number): number;
+    getNetAmountByPitchDaysBasePrice(basePrice: number, pitchCount: number, days: number): number;
+}