turf-common 1.3.1-beta.9 → 1.3.1

package/build/src/models/charge-model.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChargesModel = void 0;
+var app_badrequest_exception_1 = require("../exceptions/app-badrequest.exception");
+var modification_discount_policy_enum_1 = require("../enums/modification-discount-policy.enum");
+var _utils_1 = require("../@utils");
+var ChargesModel = /** @class */ (function () {
+    function ChargesModel(initialGrossAmount, paidAmount, couponCode, totalBookingHours, discountPolicy) {
+        this.initialBookingGrossAmount = initialGrossAmount;
+        this.amountPaid = paidAmount;
+        this.couponCode = couponCode;
+        this.additionalBookingGrossAmount = 0;
+        this.cancelledBookingGrossAmount = 0;
+        this.totalCancellationCharges = 0;
+        this.refundPayable = 0;
+        this.totalRefundedAmount = 0;
+        this.totalBookingHours = totalBookingHours;
+        this.netTotal = this.getNetAmount();
+        this.amountPayable = this.getPayableRefundAmount();
+        this.discountPolicy = discountPolicy;
+    }
+    ChargesModel.prototype.getGrossAmount = function () {
+        return (this.initialBookingGrossAmount +
+            this.additionalBookingGrossAmount -
+            this.cancelledBookingGrossAmount);
+    };
+    ChargesModel.prototype.getNetAmount = function () {
+        return this.getGrossAmount() - this.getDiscountAmount();
+    };
+    ChargesModel.prototype.getDiscountAmount = function () {
+        if ([
+            modification_discount_policy_enum_1.ModificationDiscountPolicy.DISCOUNT_CONDITIONAL,
+            modification_discount_policy_enum_1.ModificationDiscountPolicy.DISCOUNT_RECALL,
+        ].includes(this.discountPolicy) &&
+            this.cancelledBookingGrossAmount > 0) {
+            this.couponCode = "";
+        }
+        return ChargesModel.getDiscountAmount(this.couponCode, this.getGrossAmount(), false, this.totalBookingHours);
+    };
+    ChargesModel.prototype.getPayableRefundAmount = function () {
+        return (this.getNetAmount() +
+            this.totalCancellationCharges -
+            this.amountPaid +
+            this.totalRefundedAmount);
+    };
+    // setRefundedAmount(refundAmount: number) {
+    //   this.paidAmount = this.paidAmount - refundAmount;
+    //   this.totalRefundAmount = this.totalRefundAmount - refundAmount;
+    //   this.refundedAmount += refundAmount;
+    // }
+    ChargesModel.getDiscountAmount = function (couponCode, totalCost, validationApply, totalBookingHours) {
+        if (validationApply === void 0) { validationApply = false; }
+        var discountAmount = 0;
+        if (couponCode) {
+            var code = _utils_1.stringUtil.getCouponDetails(couponCode).code;
+            var value = _utils_1.stringUtil.getCouponDetails(couponCode).value;
+            if (validationApply && !code && !value) {
+                throw new app_badrequest_exception_1.AppBadRequestException({
+                    key: "couponCode",
+                    message: ["Coupon with code ".concat(couponCode, " is wrong ")],
+                });
+            }
+            if (code === "P" || code === "PHP") {
+                var percentDiscount = parseFloat(couponCode);
+                if (validationApply && percentDiscount > 90) {
+                    throw new app_badrequest_exception_1.AppBadRequestException({
+                        key: "couponCode",
+                        message: ["Discount should not be more than 90P"],
+                    });
+                }
+                discountAmount = totalCost * (percentDiscount / 100);
+            }
+            else if (code === "U") {
+                discountAmount = parseFloat(couponCode);
+            }
+            else if (code === "PHU") {
+                if (totalBookingHours === undefined) {
+                    throw new app_badrequest_exception_1.AppBadRequestException({
+                        key: "totalBookingHours",
+                        message: [
+                            "Total Booking Hours is mandatory to calculate per hour unit",
+                        ],
+                    });
+                }
+                discountAmount = parseFloat(couponCode) * totalBookingHours;
+            }
+        }
+        return Math.round(discountAmount);
+    };
+    ChargesModel.prototype.setValues = function (values) {
+        if (values === void 0) { values = {}; }
+        var that = this.clone();
+        if (values.totalRefundedAmount) {
+            that.totalRefundedAmount += values.totalRefundedAmount;
+            that.refundPayable -= values.totalRefundedAmount;
+        }
+        if (values.amountPaid) {
+            that.amountPaid = that.amountPaid + values.amountPaid;
+            that.amountPayable = that.amountPayable - values.amountPaid;
+        }
+        return that;
+    };
+    ChargesModel.prototype.modify = function (bookingModification) {
+        var oldBookingCode = bookingModification.oldBookingCode, newBookingCode = bookingModification.newBookingCode, cancellationUnit = bookingModification.cancellationUnit;
+        // this.totalBookingHours =
+        //   this.totalBookingHours -
+        //   oldBookingCode.getTotalTime("hr") +
+        //   (newBookingCode ? newBookingCode.getTotalTime("hr") : 0);
+        if (!newBookingCode) {
+            return this.modifyDelete(oldBookingCode, cancellationUnit !== null && cancellationUnit !== void 0 ? cancellationUnit : "");
+        }
+        if (!newBookingCode)
+            return null;
+        var oldTimeSlotMinutes = oldBookingCode.getTotalTime();
+        var newTimeSlotMinutes = newBookingCode.getTotalTime();
+        if (oldTimeSlotMinutes === newTimeSlotMinutes) {
+            return this.modifyMove(oldBookingCode, newBookingCode, cancellationUnit !== null && cancellationUnit !== void 0 ? cancellationUnit : "");
+        }
+        if (oldTimeSlotMinutes > newTimeSlotMinutes) {
+            return this.modifyReduce(oldBookingCode, newBookingCode, cancellationUnit !== null && cancellationUnit !== void 0 ? cancellationUnit : "");
+        }
+        if (oldTimeSlotMinutes < newTimeSlotMinutes) {
+            return this.modifyExtend(oldBookingCode, newBookingCode);
+        }
+        return null;
+    };
+    ChargesModel.prototype.modifyExtend = function (oldBookingCode, newBookingCode) {
+        var newTotalBookingHours = this.totalBookingHours -
+            oldBookingCode.getTotalTime("hr") +
+            (newBookingCode ? newBookingCode.getTotalTime("hr") : 0);
+        var newChargeModel = this.clone();
+        newChargeModel.totalBookingHours = newTotalBookingHours;
+        newChargeModel.additionalBookingGrossAmount +=
+            newBookingCode.getCost() - oldBookingCode.getCost();
+        newChargeModel.netTotal = newChargeModel.getNetAmount();
+        newChargeModel.amountPayable = newChargeModel.getPayableRefundAmount();
+        // console.log(newChargeModel.payableAmount);
+        if (newChargeModel.amountPayable > 0) {
+            newChargeModel.refundPayable = 0;
+        }
+        else {
+            newChargeModel.refundPayable = Math.abs(newChargeModel.amountPayable);
+            newChargeModel.amountPayable = 0;
+        }
+        return newChargeModel;
+    };
+    ChargesModel.prototype.modifyReduce = function (oldBookingCode, newBookingCode, cancellationUnit) {
+        var newTotalBookingHours = this.totalBookingHours -
+            oldBookingCode.getTotalTime("hr") +
+            (newBookingCode ? newBookingCode.getTotalTime("hr") : 0);
+        var newChargeModel = this.clone();
+        newChargeModel.totalBookingHours = newTotalBookingHours;
+        newChargeModel.couponCode = "";
+        var costDifference = oldBookingCode.getCost() - newBookingCode.getCost();
+        // console.log(`costDifference ${costDifference}`);
+        newChargeModel.cancelledBookingGrossAmount += costDifference;
+        var cancellationCharges = ChargesModel.getDiscountAmount(cancellationUnit, costDifference);
+        // console.log(`cancellationCharges ${cancellationCharges}`);
+        newChargeModel.totalCancellationCharges += cancellationCharges;
+        newChargeModel.netTotal = newChargeModel.getNetAmount();
+        // console.log(`newChargeModel.netAmount ${newChargeModel.netAmount}`);
+        newChargeModel.amountPayable = newChargeModel.getPayableRefundAmount();
+        // console.log(`newChargeModel.payableAmount ${newChargeModel.payableAmount}`);
+        if (newChargeModel.amountPayable > 0) {
+            newChargeModel.refundPayable = 0;
+        }
+        else {
+            newChargeModel.refundPayable = Math.abs(newChargeModel.amountPayable);
+            newChargeModel.amountPayable = 0;
+        }
+        return newChargeModel;
+    };
+    ChargesModel.prototype.modifyMove = function (oldBookingCode, newBookingCode, cancellationUnit) {
+        var newTotalBookingHours = this.totalBookingHours -
+            oldBookingCode.getTotalTime("hr") +
+            (newBookingCode ? newBookingCode.getTotalTime("hr") : 0);
+        var newChargeModel = this.clone();
+        newChargeModel.totalBookingHours = newTotalBookingHours;
+        var costDifference = newBookingCode.getCost() - oldBookingCode.getCost();
+        if (costDifference === 0) {
+            return newChargeModel;
+        }
+        if (costDifference > 0) {
+            newChargeModel.additionalBookingGrossAmount += costDifference;
+        }
+        else {
+            newChargeModel.cancelledBookingGrossAmount += Math.abs(costDifference);
+            var cancellationCharges = ChargesModel.getDiscountAmount(cancellationUnit, Math.abs(costDifference));
+            newChargeModel.totalCancellationCharges += cancellationCharges;
+        }
+        newChargeModel.netTotal = newChargeModel.getNetAmount();
+        newChargeModel.amountPayable = newChargeModel.getPayableRefundAmount();
+        if (newChargeModel.amountPayable > 0) {
+            newChargeModel.refundPayable = 0;
+        }
+        else {
+            newChargeModel.refundPayable = Math.abs(newChargeModel.amountPayable);
+            newChargeModel.amountPayable = 0;
+        }
+        return newChargeModel;
+    };
+    ChargesModel.prototype.clone = function () {
+        var that = new ChargesModel(this.initialBookingGrossAmount, this.amountPaid, this.couponCode, this.totalBookingHours, this.discountPolicy);
+        Object.assign(that, this);
+        return that;
+    };
+    ChargesModel.prototype.modifyDelete = function (bookingCode, cancellationUnit) {
+        var newTotalBookingHours = this.totalBookingHours - bookingCode.getTotalTime("hr");
+        var newChargeModel = this.clone();
+        newChargeModel.totalBookingHours = newTotalBookingHours;
+        newChargeModel.couponCode = "";
+        var costDifference = bookingCode.getCost();
+        newChargeModel.cancelledBookingGrossAmount += costDifference;
+        var cancellationCharges = ChargesModel.getDiscountAmount(cancellationUnit, costDifference);
+        newChargeModel.totalCancellationCharges += cancellationCharges;
+        newChargeModel.netTotal = newChargeModel.getNetAmount();
+        newChargeModel.amountPayable = newChargeModel.getPayableRefundAmount();
+        if (newChargeModel.amountPayable > 0) {
+            newChargeModel.refundPayable = 0;
+        }
+        else {
+            newChargeModel.refundPayable = Math.abs(newChargeModel.amountPayable);
+            newChargeModel.amountPayable = 0;
+        }
+        return newChargeModel;
+    };
+    ChargesModel.getInstance = function (chargeData, discountPolicy) {
+        if (discountPolicy === void 0) { discountPolicy = modification_discount_policy_enum_1.ModificationDiscountPolicy.DISCOUNT_CONDITIONAL; }
+        var chargesModel = new ChargesModel(chargeData.initialBookingGrossAmount, chargeData.amountPaid, chargeData.couponCode, chargeData.totalBookingHours, discountPolicy);
+        Object.assign(chargesModel, chargeData);
+        return chargesModel;
+    };
+    // static assignByInterface(
+    //   chargeData: IChargeModel,
+    //   discountPolicy: ModificationDiscountPolicy = ModificationDiscountPolicy.DISCOUNT_CONDITIONAL
+    // ): ChargesModel {
+    //   const newChargeModel = new ChargesModel(
+    //     chargeData.initialBookingGrossAmount,
+    //     chargeData.amountPaid,
+    //     chargeData.couponCode,
+    //     discountPolicy
+    //   );
+    //   newChargeModel.additionalBookingGrossAmount =
+    //     chargeData.additionalBookingGrossAmount;
+    //   newChargeModel.initialBookingGrossAmount =
+    //     chargeData.initialBookingGrossAmount;
+    //   newChargeModel.cancelledBookingGrossAmount =
+    //     chargeData.cancelledBookingGrossAmount;
+    //   newChargeModel.refundPayable = chargeData.refundPayable;
+    //   newChargeModel.totalRefundedAmount = chargeData.totalRefundedAmount;
+    //   newChargeModel.amountPaid = chargeData.amountPaid;
+    //   newChargeModel.totalCancellationCharges =
+    //     chargeData.totalCancellationCharges;
+    //   newChargeModel.netTotal = chargeData.netTotal;
+    //   newChargeModel.couponCode = chargeData.couponCode;
+    //   newChargeModel.amountPayable = chargeData.amountPayable;
+    //   return newChargeModel;
+    // }
+    ChargesModel.prototype.getTotalAmount = function () {
+        return this.getNetAmount() + this.totalCancellationCharges;
+    };
+    ChargesModel.prototype.getPaymentStatus = function () {
+        var payableRefundAmount = this.getPayableRefundAmount();
+        return payableRefundAmount < 0
+            ? "Refund"
+            : payableRefundAmount === 0
+                ? "Paid"
+                : "Pending";
+    };
+    ChargesModel.prototype.getTotalNetAmount = function () {
+        return this.getNetAmount() + this.totalCancellationCharges;
+    };
+    return ChargesModel;
+}());
+exports.ChargesModel = ChargesModel;

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

@@ -0,0 +1,41 @@
+import { BookingDetailsStatus } from "../../enums/booking-details-status.enum";
+import { IBookingDetailsModel } from "../../interface/model/booking-details-model.interface";
+import { IBookingDetailsWithBooking } from "../../types/bookingdetails-with-booking.type";
+import { IBookingDetailsEntity } from "../../interface/entity/booking-details-entity.interface";
+import { IBookingsEntity } from "../../interface/entity/bookings-entity.interface";
+import { ChargesModel } from "../charge-model";
+export declare class BookingDetailsModel implements IBookingDetailsModel {
+    id: number;
+    turfId: number;
+    pitchId: number;
+    customerName: string;
+    contact: string;
+    paymentMode: string;
+    couponCode: string;
+    totalCost: number;
+    discountedCost: number;
+    amountPaid: number;
+    email: string;
+    status: BookingDetailsStatus;
+    sport: string;
+    remarks: string;
+    initialBookingGrossAmount: number;
+    additionalBookingGrossAmount: number;
+    discountAmount: number;
+    cancelledBookingGrossAmount: number;
+    totalCancellationCharges: number;
+    netTotal: number;
+    amountPayable: number;
+    refundPayable: number;
+    totalRefundedAmount: number;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    totalBookingHours: number;
+    type: string | null;
+    constructor(data: IBookingDetailsEntity);
+    static getIdAndCreatedBy(bookingDetailsEntities: IBookingDetailsEntity[]): number[][];
+    assignCharges(chargeModel: ChargesModel): void;
+    static toMap(bookingDetailsEntities: IBookingDetailsEntity[], bookingsEntities: IBookingsEntity[]): IBookingDetailsWithBooking;
+}

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

@@ -0,0 +1,21 @@
+import { IBookingsEntityModel } from "../../interface/model/booking-entity-model.interface";
+import { IBookingsEntity } from "../../interface/entity/bookings-entity.interface";
+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/src/models/entity/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/src/models/entity/booking-payment-history-model.d.ts

@@ -0,0 +1,20 @@
+import { PaymentMode } from "../../enums/payment-mode.enum";
+import { BookingPaymentTransactionType } from "../../enums/transaction-type.enum";
+import { IDateWisePaymentHistoryData } from "../../types/date-wise-payment-history-data.types";
+import { IBookingPaymentHistoryEntity } from "../../interface/entity/booking-payment-history-entity.interface";
+export declare class BookingPaymentHistoryModel implements IBookingPaymentHistoryEntity {
+    id: number;
+    bookingDetailsId: number;
+    turfId: number;
+    pitchId: number;
+    type: PaymentMode | null;
+    transactionType: BookingPaymentTransactionType;
+    amount: number;
+    bookingHistoryId: number;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    constructor(data: IBookingPaymentHistoryEntity);
+    static dateCodeAndTurfIdWiseData(bookingPaymentHistoryEntities: IBookingPaymentHistoryEntity[]): IDateWisePaymentHistoryData;
+}

package/build/src/models/entity/booking-payment-history-model.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BookingPaymentHistoryModel = void 0;
+var payment_mode_enum_1 = require("../../enums/payment-mode.enum");
+var booking_code_model_1 = require("../booking-code-model");
+var BookingPaymentHistoryModel = /** @class */ (function () {
+    function BookingPaymentHistoryModel(data) {
+        Object.assign(this, data);
+    }
+    BookingPaymentHistoryModel.dateCodeAndTurfIdWiseData = function (bookingPaymentHistoryEntities) {
+        var dateWisePaymentHistoryData = {};
+        for (var _i = 0, bookingPaymentHistoryEntities_1 = bookingPaymentHistoryEntities; _i < bookingPaymentHistoryEntities_1.length; _i++) {
+            var bookingPaymentHistoryEntity = bookingPaymentHistoryEntities_1[_i];
+            var turfId = bookingPaymentHistoryEntity.turfId, amount = bookingPaymentHistoryEntity.amount, type = bookingPaymentHistoryEntity.type, createdOn = bookingPaymentHistoryEntity.createdOn;
+            var dateCode = booking_code_model_1.BookingCode.getDateCode(createdOn);
+            if (!dateWisePaymentHistoryData[dateCode])
+                dateWisePaymentHistoryData[dateCode] = {};
+            var turfWisePaymentData = dateWisePaymentHistoryData[dateCode][turfId];
+            if (!turfWisePaymentData)
+                turfWisePaymentData = dateWisePaymentHistoryData[dateCode][turfId] = {
+                    cashTotal: 0,
+                    upiTotal: 0,
+                    total: 0,
+                };
+            if (type === payment_mode_enum_1.PaymentMode.CASH)
+                turfWisePaymentData.cashTotal += amount;
+            else if (type === payment_mode_enum_1.PaymentMode.UPI)
+                turfWisePaymentData.upiTotal += amount;
+            turfWisePaymentData.total =
+                turfWisePaymentData.cashTotal + turfWisePaymentData.upiTotal;
+        }
+        return dateWisePaymentHistoryData;
+    };
+    return BookingPaymentHistoryModel;
+}());
+exports.BookingPaymentHistoryModel = BookingPaymentHistoryModel;

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

@@ -0,0 +1,18 @@
+import { ICancellationPolicyModel } from "../../interface/model/cancellation-policy-model.interface";
+import { ICancellationPolicyEntity } from "../../interface/entity/cancellation-policy-entity.interface";
+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/src/models/entity/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/src/models/entity/configuration-model.d.ts

@@ -0,0 +1,17 @@
+import { ConfigurationKey } from "../../enums/configuration-key.enum";
+import { IConfigurationsModel } from "../../interface/model/configuration-model.interface";
+import { IConfigurationsEntity } from "../../interface/entity/configurations-entity.interface";
+export declare class ConfigurationsModel implements IConfigurationsModel {
+    id: number;
+    key: ConfigurationKey;
+    value: string;
+    description: string;
+    createdOn: Date;
+    updatedOn: Date;
+    createdBy: number;
+    updatedBy: number;
+    text: string;
+    constructor(data: IConfigurationsEntity);
+    isCronJobKey(): boolean;
+    static findByKey(configurationEntities: IConfigurationsEntity[], key: ConfigurationKey): IConfigurationsEntity | undefined;
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurationsModel = void 0;
+var configuration_key_enum_1 = require("../../enums/configuration-key.enum");
+var ConfigurationsModel = /** @class */ (function () {
+    function ConfigurationsModel(data) {
+        Object.assign(this, data);
+    }
+    ConfigurationsModel.prototype.isCronJobKey = function () {
+        return configuration_key_enum_1.ConfigurationKey.CronJobsConfigurationsKeys(this.key);
+    };
+    ConfigurationsModel.findByKey = function (configurationEntities, key) {
+        return configurationEntities.find(function (configurationEntity) { return configurationEntity.key === key; });
+    };
+    return ConfigurationsModel;
+}());
+exports.ConfigurationsModel = ConfigurationsModel;

package/build/src/models/entity/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./booking-details-model";
+export * from "./booking-entity-model";
+export * from "./booking-payment-history-model";
+export * from "./cancellation-policy-model";
+export * from "./configuration-model";
+export * from "./price-model";
+export * from "./pricing-plan-entity-model";
+export * from "./subscription-model";
+export * from "./turf-model";
+export * from "./user-model";

package/build/src/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/src/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[];
+}