turf-common 1.0.16-beta.2 → 1.0.16-beta.21

package/build/models/booking-details-model.js

@@ -0,0 +1,69 @@
+"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.BookingDetailsModel = void 0;
+var booking_entity_model_1 = require("./booking-entity-model");
+var BookingDetailsModel = /** @class */ (function () {
+    function BookingDetailsModel(data) {
+        Object.assign(this, data);
+    }
+    BookingDetailsModel.getIdAndCreatedBy = function (bookingDetailsEntities) {
+        var bookingDetailsIds = [];
+        var userIds = [];
+        bookingDetailsEntities.forEach(function (_a) {
+            var bookingDetailId = _a.id, createdBy = _a.createdBy;
+            bookingDetailsIds.push(bookingDetailId), userIds.push(createdBy);
+        });
+        return [bookingDetailsIds, userIds];
+    };
+    //   static toMap(
+    //     bookingDetailsEntities: IBookingDetailsEntity[],
+    //     bookingsEntities: BookingsEntity[],
+    //   ): IBookingDetailsWithBooking {
+    //     const response: IBookingDetailsWithBooking = {};
+    //     bookingDetailsEntities.forEach((bookingsDetailsEntity) => {
+    //       const bookingDetailsId = bookingsDetailsEntity.id;
+    //       if (!response[bookingDetailsId]) {
+    //         response[bookingDetailsId] = {
+    //           ...bookingsDetailsEntity,
+    //           bookings: {},
+    //         };
+    //       }
+    //       const filterBookingEntities = bookingsEntities.filter(
+    //         (bookingEntity) => bookingEntity.bookingDetailsId === bookingDetailsId,
+    //       );
+    //       response[bookingDetailsId].bookings = BookingsEntity.toMap(
+    //         filterBookingEntities,
+    //       );
+    //     });
+    //     return response;
+    //   }
+    BookingDetailsModel.prototype.assignCharges = function (chargeModel) {
+        this.discountAmount = chargeModel.getDiscountAmount();
+        Object.assign(this, chargeModel);
+    };
+    BookingDetailsModel.toMap = function (bookingDetailsEntities, bookingsEntities) {
+        var response = {};
+        bookingDetailsEntities.forEach(function (bookingsDetailsEntity) {
+            var bookingDetailsId = bookingsDetailsEntity.id;
+            if (!response[bookingDetailsId]) {
+                response[bookingDetailsId] = __assign(__assign({}, bookingsDetailsEntity), { bookings: {} });
+            }
+            var filterBookingEntities = bookingsEntities.filter(function (bookingEntity) { return bookingEntity.bookingDetailsId === bookingDetailsId; });
+            response[bookingDetailsId].bookings = booking_entity_model_1.BookingEntityModel.toMap(filterBookingEntities);
+        });
+        return response;
+    };
+    return BookingDetailsModel;
+}());
+exports.BookingDetailsModel = BookingDetailsModel;

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

@@ -0,0 +1,21 @@
+import { IBookingsEntityModel } from "../interface/booking-entity-model.interface";
+import { IBookingsEntity } from "../types/entity/bookings-entity.type";
+import { BookingCode } from "./booking-code-model";
+export declare class BookingEntityModel implements IBookingsEntityModel {
+    bookingDetailsId: number;
+    code: string;
+    cost: string;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    constructor(data: IBookingsEntity);
+    getTotalCost(): number;
+    getBookingTimeInMinutes(): number;
+    isTimeExtended(newBookingEntities: IBookingsEntity[]): boolean;
+    getBookingCode(): BookingCode;
+    static toMap(bookingEntities: IBookingsEntity[]): {
+        [key: string]: string;
+    };
+    static findByCodeAndTurfId(bookingEntities: IBookingsEntity[], turfId: number, bookingCode: string): IBookingsEntity | undefined;
+}

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BookingEntityModel = void 0;
+var booking_code_model_1 = require("./booking-code-model");
+var BookingEntityModel = /** @class */ (function () {
+    function BookingEntityModel(data) {
+        Object.assign(this, data);
+    }
+    BookingEntityModel.prototype.getTotalCost = function () {
+        return this.cost
+            .split(",")
+            .map(Number)
+            .reduce(function (accumulator, currentValue) { return accumulator + currentValue; }, 0);
+    };
+    BookingEntityModel.prototype.getBookingTimeInMinutes = function () {
+        var bookingCode = new booking_code_model_1.BookingCode(this.code);
+        return bookingCode.getBookingTimeInMinutes();
+    };
+    BookingEntityModel.prototype.isTimeExtended = function (newBookingEntities) {
+        var newTimeInMinutes = newBookingEntities
+            .map(function (bookingEntity) {
+            return new BookingEntityModel(bookingEntity).getBookingTimeInMinutes();
+        })
+            .reduce(function (accumulator, currentValue) { return accumulator + currentValue; }, 0);
+        return (newTimeInMinutes > new BookingEntityModel(this).getBookingTimeInMinutes());
+    };
+    BookingEntityModel.prototype.getBookingCode = function () {
+        return new booking_code_model_1.BookingCode(this.code, this.cost);
+    };
+    BookingEntityModel.toMap = function (bookingEntities) {
+        var response = {};
+        bookingEntities.forEach(function (bookingEntity) {
+            response[bookingEntity.code] =
+                response[bookingEntity.code] === undefined
+                    ? bookingEntity.cost
+                    : response[bookingEntity.code];
+        });
+        return response;
+    };
+    BookingEntityModel.findByCodeAndTurfId = function (bookingEntities, turfId, bookingCode) {
+        return bookingEntities.find(function (bookingEntity) {
+            return bookingEntity.code === booking_code_model_1.BookingCode.getInstance(turfId, bookingCode).code;
+        });
+    };
+    return BookingEntityModel;
+}());
+exports.BookingEntityModel = BookingEntityModel;

package/build/models/cancellation-policy-model.d.ts

@@ -0,0 +1,18 @@
+import { ICancellationPolicyModel } from "../interface/cancellation-policy-model.interface";
+import { ICancellationPolicyEntity } from "../types/entity/cancellation-policy-entity.type";
+export declare class CancellationPolicyModel implements ICancellationPolicyModel {
+    id: number;
+    turfId: number;
+    from: number;
+    to: number;
+    charges: string;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    constructor(data: ICancellationPolicyEntity);
+    unitOfCharges(): string;
+    chargesWithoutUnit(): string;
+    isInEffect(hours: number): boolean;
+    getCancellationCharges(cost: number): number;
+}

package/build/models/cancellation-policy-model.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancellationPolicyModel = void 0;
+var CancellationPolicyModel = /** @class */ (function () {
+    function CancellationPolicyModel(data) {
+        Object.assign(this, data);
+    }
+    CancellationPolicyModel.prototype.unitOfCharges = function () {
+        return this.charges.slice(-1);
+    };
+    CancellationPolicyModel.prototype.chargesWithoutUnit = function () {
+        return this.charges.slice(0, -1);
+    };
+    CancellationPolicyModel.prototype.isInEffect = function (hours) {
+        return this.from <= hours && hours <= this.to;
+    };
+    CancellationPolicyModel.prototype.getCancellationCharges = function (cost) {
+        var cancellationCharges = 0;
+        var cancellationChargesModel = new CancellationPolicyModel(this);
+        if (cancellationChargesModel.unitOfCharges() === "P") {
+            var percentageValue = cancellationChargesModel.chargesWithoutUnit();
+            cancellationCharges = (cost * Number(percentageValue)) / 100;
+        }
+        else if (cancellationChargesModel.unitOfCharges() === "U") {
+            var unit = cancellationChargesModel.chargesWithoutUnit();
+            cancellationCharges = Number(unit);
+        }
+        return cancellationCharges;
+    };
+    return CancellationPolicyModel;
+}());
+exports.CancellationPolicyModel = CancellationPolicyModel;

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/price-model.d.ts

@@ -0,0 +1,11 @@
+import { IPriceModel } from "../interface/price-model.interface";
+import { IPriceEntity } from "../types/entity/price-entity.type";
+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/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/pricing-plan-entity-model.d.ts

@@ -0,0 +1,47 @@
+import { PricingPlanStatus } from "../enums/pricing-plan-status.enum copy";
+import { IBillingCycle } 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/pricing-plan-entity-model.interface";
+import { IPricingPlanEntity } from "../types/entity/pricing-plan-entity";
+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(): IBillingCycle[];
+}
+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/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/pricing-plan-model.d.ts

@@ -0,0 +1,24 @@
+import { IPricingPlan } from "../interface/pricing-plan.interface";
+import { PitchSlabModel } from "./pitch-slab-model";
+import { BillingCycleModel } from "./billing-cycle-model";
+export declare class PricingPlanModel implements IPricingPlan {
+    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: IPricingPlan);
+    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 common_1 = require("@nestjs/common");
+var pitch_slab_model_1 = require("./pitch-slab-model");
+var billing_cycle_model_1 = require("./billing-cycle-model");
+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 common_1.BadRequestException({
+                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 { IPricingPlan } 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: IPricingPlan, 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;
+}

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

@@ -0,0 +1,88 @@
+"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_model_1 = require("./pricing-plan-model");
+var SubscribedPricingPlanModel = /** @class */ (function (_super) {
+    __extends(SubscribedPricingPlanModel, _super);
+    function SubscribedPricingPlanModel(data, pitchCount, billingCycle) {
+        var _this = _super.call(this, data) || this;
+        _this.hourInMonth = 24 * 30;
+        _this.pitchCount = pitchCount;
+        _this.billingCycle = billingCycle;
+        _this.selectedPitchSlab = _this.getPitchSlab(_this.pitchCount);
+        _this.selectedBillingCycle = _this.getBillingCycle(_this.billingCycle);
+        _this.selectedPitchSlabBasePrice = _this.selectedPitchSlab.getBasePrice(_this.base_price);
+        return _this;
+    }
+    SubscribedPricingPlanModel.prototype.getMonths = function () {
+        return this.selectedBillingCycle.to;
+    };
+    SubscribedPricingPlanModel.prototype.getBasePrice = function () {
+        return this.selectedPitchSlabBasePrice;
+    };
+    SubscribedPricingPlanModel.prototype.getGrossAmount = function () {
+        return Math.round(this.selectedPitchSlabBasePrice *
+            this.pitchCount *
+            this.hourInMonth *
+            this.selectedBillingCycle.to);
+    };
+    SubscribedPricingPlanModel.prototype.getNetAmount = function () {
+        return Math.round(this.selectedPitchSlabBasePrice *
+            (1 - this.getBillingDiscount() / 100) *
+            this.pitchCount *
+            this.hourInMonth *
+            this.selectedBillingCycle.to);
+    };
+    SubscribedPricingPlanModel.prototype.getBillingDiscount = function () {
+        return this.selectedBillingCycle.getDiscount();
+    };
+    SubscribedPricingPlanModel.prototype.getMonthDifference = function (that) {
+        return that.getMonths() - this.getMonths();
+    };
+    SubscribedPricingPlanModel.prototype.getGrossAmountByMonth = function (month) {
+        return Math.round(this.selectedPitchSlabBasePrice *
+            this.pitchCount *
+            this.hourInMonth *
+            month);
+    };
+    SubscribedPricingPlanModel.prototype.getNetAmountByMonth = function (month) {
+        return Math.round(this.selectedPitchSlabBasePrice *
+            (1 - this.getBillingDiscount() / 100) *
+            this.pitchCount *
+            this.hourInMonth *
+            month);
+    };
+    SubscribedPricingPlanModel.prototype.getGrossAmountByPitchDays = function (pitchCount, days) {
+        return Math.round(this.selectedPitchSlabBasePrice * pitchCount * days * 24);
+    };
+    SubscribedPricingPlanModel.prototype.getNetAmountByPitchDays = function (pitchCount, days) {
+        return Math.round(this.selectedPitchSlabBasePrice *
+            (1 - this.getBillingDiscount() / 100) *
+            pitchCount *
+            days *
+            24);
+    };
+    SubscribedPricingPlanModel.prototype.getGrossAmountByPitchDaysBasePrice = function (basePrice, pitchCount, days) {
+        return Math.round(basePrice * pitchCount * days * 24);
+    };
+    SubscribedPricingPlanModel.prototype.getNetAmountByPitchDaysBasePrice = function (basePrice, pitchCount, days) {
+        return Math.round(basePrice * (1 - this.getBillingDiscount() / 100) * pitchCount * days * 24);
+    };
+    return SubscribedPricingPlanModel;
+}(pricing_plan_model_1.PricingPlanModel));
+exports.SubscribedPricingPlanModel = SubscribedPricingPlanModel;

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

@@ -0,0 +1,30 @@
+import { SubscriptionStatus } from "../interface/subscription-status.interface";
+import { ISubscriptionEntity, ISubscriptionModel } from "../types/entity/subscription-entity.type";
+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;
+}