turf-common 1.3.1-beta.8 → 1.3.1

package/build/src/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/src/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/src/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/src/models/entity/subscription-model.d.ts

@@ -0,0 +1,44 @@
+import { IGetCurrentSubscriptionResponse, ISubscriptionPitchMappingEntity } from "../../@type";
+import { SubscriptionStatus } from "../../enums/subscription-status.enum";
+import { ISubscriptionEntity, ISubscriptionModel } from "../../interface/entity/subscription-entity.interface";
+import { RenewSubscriptionData, UpgradeSubscriptionData } from "../../interface/ui/upgrade-subscription-data.interface";
+import { PricingPlanModel } from "../pricing-plan-model";
+import { SubscribedPricingPlanModel } from "../subscribed-pricing-plan-model";
+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;
+    fromDateCode: string;
+    toDateCode: string;
+    details?: ISubscriptionPitchMappingEntity[];
+    advanceAmount?: number;
+    constructor(data: ISubscriptionEntity);
+    static getInstanceByResponse(data: IGetCurrentSubscriptionResponse): SubscriptionModel;
+    getFromDate(): Date;
+    getToDate(): Date;
+    isRenewalDue(): boolean;
+    remainingSubscriptionDays(): number;
+    upgradeSubscription(totalPitchCount: number, subscribedPricingModel: SubscribedPricingPlanModel): UpgradeSubscriptionData;
+    renewSubscription(totalPitchCount: number, billingCycle: string, currentPricingPlanModel: PricingPlanModel): RenewSubscriptionData;
+    static updateStatus(subscriptionEntities: ISubscriptionEntity[], status: SubscriptionStatus, userId: number): ISubscriptionEntity[];
+    remainingAmount(): number;
+    isAmountFullyPaid(): boolean;
+    isAmountPaidGreater(): boolean;
+    updateStatusIfPaymentDone(): void;
+}

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

@@ -0,0 +1,154 @@
+"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.SubscriptionModel = void 0;
+var subscription_status_enum_1 = require("../../enums/subscription-status.enum");
+var constant_1 = require("../../utils/constant");
+var date_util_1 = require("../../utils/date-util");
+var subscribed_pricing_plan_model_1 = require("../subscribed-pricing-plan-model");
+var SubscriptionModel = /** @class */ (function () {
+    function SubscriptionModel(data) {
+        Object.assign(this, data);
+    }
+    SubscriptionModel.getInstanceByResponse = function (data) {
+        // this.id = data.id;
+        // this.organizationId = data.organizationId;
+        // this.from = data.from;
+        // this.to = data.to;
+        // this.type = data.type;
+        // this.grossAmount = data.grossAmount;
+        // this.discount = data.discount;
+        // this.netAmount = data.netAmount;
+        // this.amountPaid = data.amountPaid;
+        // this.status = data.status;
+        // this.noOfPitches = data.noOfPitches;
+        // this.createdBy = data.createdBy;
+        // this.createdOn = data.createdOn;
+        // this.updatedBy = data.updatedBy;
+        // this.updatedOn = data.updatedOn;
+        // this.remarks = data.remarks;
+        // this.registrationId = data.registrationId;
+        // this.pricingPlanId = data.pricingPlanId;
+        // this.upgradeSubscriptionId = Number(data.previousSubscriptionIds);
+        // this.details = data.details;
+        var demo = __assign(__assign({}, data), { from: date_util_1.dateUtilService.getDateFromDatabaseDate(data.from), to: date_util_1.dateUtilService.getDateFromDatabaseDate(data.to), createdOn: date_util_1.dateUtilService.getDateFromDatabaseDate(data.createdOn), updatedOn: date_util_1.dateUtilService.getDateFromDatabaseDate(data.updatedOn) });
+        return new SubscriptionModel(demo);
+    };
+    SubscriptionModel.prototype.getFromDate = function () {
+        return date_util_1.dateUtilService.convertStringToDate(this.fromDateCode, "yyMMdd");
+    };
+    SubscriptionModel.prototype.getToDate = function () {
+        return date_util_1.dateUtilService.convertStringToDate(this.toDateCode, "yyMMdd");
+    };
+    SubscriptionModel.prototype.isRenewalDue = function () {
+        // Check if difference 'to' date and today's date is less than 7 days
+        return (this.getToDate().getTime() - new Date().getTime() <
+            constant_1.SUBSCRIPTION_RENEWAL_THRESHOLD_DAYS * 24 * 60 * 60 * 1000);
+    };
+    SubscriptionModel.prototype.remainingSubscriptionDays = function () {
+        // const oneDay = 24 * 60 * 60 * 1000;
+        // const dayDifference = Math.ceil(
+        //   (this.to.getTime() - new Date().getTime()) / oneDay
+        // );
+        // return dayDifference - 1; //minus 1 day
+        return date_util_1.dateUtilService.noOfDaysBetweenDates(new Date(), this.getToDate());
+    };
+    SubscriptionModel.prototype.upgradeSubscription = function (totalPitchCount, subscribedPricingModel) {
+        var newlyAddedPitchCount = totalPitchCount - this.noOfPitches;
+        var basePrice = subscribedPricingModel.getSelectedPitchSlabBasePrice();
+        var remainingSubscriptionDays = this.remainingSubscriptionDays();
+        var additionalGrossAmount = basePrice * remainingSubscriptionDays * 24 * newlyAddedPitchCount;
+        return {
+            amountPaid: this.amountPaid,
+            discount: this.discount,
+            from: this.from,
+            to: this.to,
+            noOfPitches: totalPitchCount,
+            netAmount: Math.round(this.netAmount + additionalGrossAmount),
+            grossAmount: Math.round(this.grossAmount + additionalGrossAmount),
+            organizationId: this.organizationId,
+            pricingPlanId: this.pricingPlanId,
+            registrationId: this.registrationId,
+            type: this.type,
+            previousSubscriptionIds: this.id.toString(),
+            newlyAddedPitchCount: newlyAddedPitchCount,
+            basePrice: basePrice,
+            remainingSubscriptionDays: remainingSubscriptionDays,
+            additionalGrossAmount: Math.round(additionalGrossAmount),
+        };
+    };
+    SubscriptionModel.prototype.renewSubscription = function (totalPitchCount, billingCycle, currentPricingPlanModel) {
+        // const dateUtilService = new DateUtilService();
+        // dateService.convertStringToDate(this.from, "yyyy-MM-dd");
+        // const subscribedPitchCount: number = this.noOfPitches;
+        var renewalSubscriptionModel = new subscribed_pricing_plan_model_1.SubscribedPricingPlanModel(currentPricingPlanModel, totalPitchCount, billingCycle);
+        var toDate = this.getToDate();
+        var _a = renewalSubscriptionModel.getNextBillingCycleDateRange(toDate), startDate = _a[0], endDate = _a[1];
+        // const [startDateCode, endDateCode]: [string, string] = [
+        //   dateService.getDateCode(startDate),
+        //   dateService.getDateCode(endDate),
+        // ];
+        return {
+            amountPaid: 0,
+            discount: renewalSubscriptionModel.selectedBillingCycle.discount,
+            fromDate: startDate,
+            grossAmount: Math.round(renewalSubscriptionModel.getGrossAmount()),
+            netAmount: Math.round(renewalSubscriptionModel.getNetAmount()),
+            noOfPitches: totalPitchCount,
+            pricingPlanId: currentPricingPlanModel.id,
+            toDate: endDate,
+            type: billingCycle,
+            organizationId: this.organizationId,
+            registrationId: this.registrationId,
+            previousSubscriptionIds: null,
+            basePrice: renewalSubscriptionModel.getSelectedPitchSlabBasePrice(),
+        };
+    };
+    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/src/models/entity/turf-model.d.ts

@@ -0,0 +1,36 @@
+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";
+import { IModifyTurf } from "../../interface/modify-turf.interface";
+import { IModifyEntity } from "../../@type";
+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]: IModifyTurf;
+    };
+    static toKeyValue(turfEntities: ITurfEntity[]): {
+        [key: number]: ITurfEntity;
+    };
+    static fromEntity(data: ITurfEntity): ITurfModel;
+    static filterBySubscriptionPitchMapping(turfEntities: ITurfEntity[], subscriptionPitchMappingEntities: IModifyEntity<ISubscriptionPitchMappingEntity>[], pitchStatusSet: Set<string>): ITurfEntity[];
+}

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

@@ -0,0 +1,116 @@
+"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);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurfModel = void 0;
+var pitch_status_enum_1 = require("../../enums/pitch-status.enum");
+var _utils_1 = require("../../@utils");
+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] = (0, _utils_1.ConvertToCommonEntities)([
+                    turfEntity.getModifiedTurfEntity(),
+                ]).map(function (_a) {
+                    var pitches = _a.pitches, assignToTurf = __rest(_a, ["pitches"]);
+                    return (__assign(__assign({}, assignToTurf), { pitches: (0, _utils_1.ConvertToCommonEntities)(pitches) }));
+                })[0];
+            }
+        });
+        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/src/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";
+export declare class UserModel implements IUserModel {
+    id: number;
+    firstname: 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<T extends {
+        id: number;
+    }>(userEntities: T[]): {
+        [key: number]: T;
+    };
+}

package/build/src/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/src/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/src/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/src/models/pricing-plan-model.d.ts

@@ -0,0 +1,27 @@
+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;
+    getPitchSlabIndex(pitchCount: number): number;
+    formatPitchSlab(index: number): string;
+    getBillingCycleIndexByMonths(noOfMonths: number): number;
+}