turf-common 1.0.1 → 1.0.2

package/build/models/charge-model.js

@@ -0,0 +1,227 @@
+"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 ChargesModel = /** @class */ (function () {
+    function ChargesModel(initialGrossAmount, paidAmount, couponCode, 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.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());
+    };
+    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) {
+        if (validationApply === void 0) { validationApply = false; }
+        var discountAmount = 0;
+        if (couponCode) {
+            if (couponCode.slice(-1) === "P") {
+                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 (couponCode.slice(-1) === "U") {
+                discountAmount = parseFloat(couponCode);
+            }
+        }
+        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;
+        if (!newBookingCode) {
+            return this.modifyDelete(oldBookingCode, cancellationUnit !== null && cancellationUnit !== void 0 ? cancellationUnit : "");
+        }
+        if (!newBookingCode)
+            return null;
+        var oldTimeSlotMinutes = oldBookingCode.getTimeslot().getTotalMinutes();
+        var newTimeSlotMinutes = newBookingCode.getTimeslot().getTotalMinutes();
+        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 newChargeModel = this.clone();
+        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 newChargeModel = this.clone();
+        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 newChargeModel = this.clone();
+        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.discountPolicy);
+        Object.assign(that, this);
+        return that;
+    };
+    ChargesModel.prototype.modifyDelete = function (bookingCode, cancellationUnit) {
+        var newChargeModel = this.clone();
+        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.getInstanceByInterface = function (bookingDetailsEntity, discountPolicy) {
+        if (discountPolicy === void 0) { discountPolicy = modification_discount_policy_enum_1.ModificationDiscountPolicy.DISCOUNT_CONDITIONAL; }
+        var chargesModel = new ChargesModel(bookingDetailsEntity.initialBookingGrossAmount, bookingDetailsEntity.amountPaid, bookingDetailsEntity.couponCode, discountPolicy);
+        Object.assign(chargesModel, bookingDetailsEntity);
+        return chargesModel;
+    };
+    ChargesModel.assignByInterface = function (bookingDetailsEntity, discountPolicy) {
+        if (discountPolicy === void 0) { discountPolicy = modification_discount_policy_enum_1.ModificationDiscountPolicy.DISCOUNT_CONDITIONAL; }
+        var newChargeModel = new ChargesModel(bookingDetailsEntity.initialBookingGrossAmount, bookingDetailsEntity.amountPaid, bookingDetailsEntity.couponCode, discountPolicy);
+        newChargeModel.additionalBookingGrossAmount =
+            bookingDetailsEntity.additionalBookingGrossAmount;
+        newChargeModel.initialBookingGrossAmount =
+            bookingDetailsEntity.initialBookingGrossAmount;
+        newChargeModel.cancelledBookingGrossAmount =
+            bookingDetailsEntity.cancelledBookingGrossAmount;
+        newChargeModel.refundPayable = bookingDetailsEntity.refundPayable;
+        newChargeModel.totalRefundedAmount =
+            bookingDetailsEntity.totalRefundedAmount;
+        newChargeModel.amountPaid = bookingDetailsEntity.amountPaid;
+        newChargeModel.totalCancellationCharges =
+            bookingDetailsEntity.totalCancellationCharges;
+        newChargeModel.netTotal = bookingDetailsEntity.netTotal;
+        newChargeModel.couponCode = bookingDetailsEntity.couponCode;
+        newChargeModel.amountPayable = bookingDetailsEntity.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";
+    };
+    return ChargesModel;
+}());
+exports.ChargesModel = ChargesModel;

package/build/models/time-slot-model.d.ts

@@ -0,0 +1,18 @@
+export declare class TimeSlot {
+    fromTime: string;
+    toTime: string;
+    constructor(fromTime: string, toTime: string);
+    isOverLap(timeSlot: TimeSlot): boolean;
+    getOverlapTime(timeSlot: TimeSlot): TimeSlot | null;
+    getNonOverlapTimeSlots(existingPriceSlot: TimeSlot): string[];
+    getStartMinutes(): number;
+    getEndMinutes(): number;
+    getHalfHourMinutes(): number[];
+    getHalfHourTimeCodes(): string[];
+    getHalfHourTimeRangeCodes(): string[];
+    getTotalMinutes(): number;
+    static convertToCode(minute: number): string;
+    static _getMinutes(timeCode: string): number;
+    static getHalfHourTimeCodes(): string[];
+    static getHalfHourTimeRangeCodes(): string[];
+}

package/build/models/time-slot-model.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeSlot = void 0;
+var TimeSlot = /** @class */ (function () {
+    function TimeSlot(fromTime, toTime) {
+        this.fromTime = fromTime;
+        this.toTime = toTime;
+    }
+    TimeSlot.prototype.isOverLap = function (timeSlot) {
+        return this.fromTime < timeSlot.toTime && this.toTime > timeSlot.fromTime;
+    };
+    TimeSlot.prototype.getOverlapTime = function (timeSlot) {
+        if (!this.isOverLap(timeSlot)) {
+            return null;
+        }
+        return new TimeSlot(this.fromTime > timeSlot.fromTime ? this.fromTime : timeSlot.fromTime, this.toTime < timeSlot.toTime ? this.toTime : timeSlot.toTime);
+    };
+    TimeSlot.prototype.getNonOverlapTimeSlots = function (existingPriceSlot) {
+        var overLapFromTime = this.fromTime > existingPriceSlot.fromTime
+            ? this.fromTime
+            : existingPriceSlot.fromTime;
+        var overLapToTime = this.toTime < existingPriceSlot.toTime
+            ? this.toTime
+            : existingPriceSlot.toTime;
+        var nonOverlapTimeSlots = [];
+        if (existingPriceSlot.fromTime < overLapFromTime) {
+            nonOverlapTimeSlots.push("".concat(existingPriceSlot.fromTime).concat(overLapFromTime));
+        }
+        if (existingPriceSlot.toTime > overLapToTime) {
+            nonOverlapTimeSlots.push("".concat(overLapToTime).concat(existingPriceSlot.toTime));
+        }
+        return nonOverlapTimeSlots;
+    };
+    TimeSlot.prototype.getStartMinutes = function () {
+        return TimeSlot._getMinutes(this.fromTime);
+    };
+    TimeSlot.prototype.getEndMinutes = function () {
+        return TimeSlot._getMinutes(this.toTime);
+    };
+    TimeSlot.prototype.getHalfHourMinutes = function () {
+        var minutes = [this.getStartMinutes()];
+        var endMinutes = this.getEndMinutes();
+        while (minutes[minutes.length - 1] < endMinutes) {
+            minutes.push(minutes[minutes.length - 1] + 30);
+        }
+        return minutes;
+    };
+    TimeSlot.prototype.getHalfHourTimeCodes = function () {
+        return this.getHalfHourMinutes().map(function (minute) {
+            return TimeSlot.convertToCode(minute);
+        });
+    };
+    TimeSlot.prototype.getHalfHourTimeRangeCodes = function () {
+        var halfHourCodes = this.getHalfHourTimeCodes();
+        var halfHourRangeCodes = [];
+        for (var index = 0; index < halfHourCodes.length - 1; index++) {
+            halfHourRangeCodes.push(halfHourCodes[index] + halfHourCodes[index + 1]);
+        }
+        return halfHourRangeCodes;
+    };
+    TimeSlot.prototype.getTotalMinutes = function () {
+        return this.getEndMinutes() - this.getStartMinutes();
+    };
+    // static padStart(timeCode: string, length: number, padString: string): string {
+    //   return timeCode.padStart(length, padString);
+    // }
+    TimeSlot.convertToCode = function (minute) {
+        return "".concat(Math.floor(minute / 60)
+            .toString()
+            .padStart(2, "0")).concat(Math.floor(minute % 60)
+            .toString()
+            .padStart(2, "0"));
+    };
+    TimeSlot._getMinutes = function (timeCode) {
+        return parseInt(timeCode.slice(0, 2)) * 60 + parseInt(timeCode.slice(2, 4));
+    };
+    TimeSlot.getHalfHourTimeCodes = function () {
+        var minutes = [0];
+        var endMinutes = 24 * 60;
+        while (minutes[minutes.length - 1] < endMinutes) {
+            minutes.push(minutes[minutes.length - 1] + 30);
+        }
+        return minutes.map(function (minute) { return TimeSlot.convertToCode(minute); });
+    };
+    TimeSlot.getHalfHourTimeRangeCodes = function () {
+        var halfHourCodes = TimeSlot.getHalfHourTimeCodes();
+        var halfHourRangeCodes = [];
+        for (var index = 0; index < halfHourCodes.length - 1; index++) {
+            halfHourRangeCodes.push(halfHourCodes[index] + halfHourCodes[index + 1]);
+        }
+        return halfHourRangeCodes;
+    };
+    return TimeSlot;
+}());
+exports.TimeSlot = TimeSlot;

package/build/modules/app-badrequest-exception-module/app-badrequest-exception-model.d.ts

@@ -0,0 +1,5 @@
+import { TAppBadRequestException } from "./types/app-badrequest-exception.type";
+export declare class AppBadRequestException extends Error {
+    appBadRequestException: TAppBadRequestException;
+    constructor(appBadRequestException: TAppBadRequestException);
+}

package/build/modules/app-badrequest-exception-module/app-badrequest-exception-model.js

@@ -0,0 +1,28 @@
+"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.AppBadRequestException = void 0;
+var AppBadRequestException = /** @class */ (function (_super) {
+    __extends(AppBadRequestException, _super);
+    function AppBadRequestException(appBadRequestException) {
+        var _this = _super.call(this) || this;
+        _this.appBadRequestException = appBadRequestException;
+        return _this;
+    }
+    return AppBadRequestException;
+}(Error));
+exports.AppBadRequestException = AppBadRequestException;

package/build/modules/app-badrequest-exception-module/types/app-badrequest-exception.type.d.ts

@@ -0,0 +1,4 @@
+export type TAppBadRequestException = {
+    key: string;
+    message: string[];
+};

package/build/modules/app-badrequest-exception-module/types/app-badrequest-exception.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/modules/booking-module/booking-code-model.d.ts

@@ -0,0 +1,71 @@
+import { TimeSlot } from "../time-slot-module/time-slot-model";
+import { IGetBookingCodesPerThirtyMinutes } from "./interfaces/get-booking-codes-per-thirty-min.interface";
+export declare class BookingCode {
+    code: string;
+    turfid: string;
+    pitchCode: string;
+    slot: string;
+    fromTime: string;
+    toTime: string;
+    date: string;
+    cost: string;
+    constructor(code: string, cost?: string);
+    parse(): BookingCode;
+    getBookingTimeInMinutes(): number;
+    getPitchNo(): number;
+    getHalfHourTimeCodes(): string[];
+    /**
+     *
+     * @returns {Array<string>} - List of half hour time slot codes between start time & end time inclusive
+     * @example fromTime: 0000; toTime: 0130
+     * // returns ['00000030','00300100','01000130']
+     */
+    getHalfHourTimeRangeCodes(): string[];
+    getValidDate(): Date;
+    getDateCode(): string;
+    getWeekday(): number;
+    getMonthCode(): string;
+    getDateWithFromTimeCode(): string;
+    getCodeWithoutTurfCode(): string;
+    static sortByCode(bookingCodes: BookingCode[]): void;
+    static getOneSlotBookingCode(turfId: string, bookingDate: string, fhfm: string, thtm: string, pitchCode: string): string;
+    static getDiscountedCost(couponCode: string, totalCost: number, validationApply?: boolean): number;
+    static getDiscountAmount(couponCode: string, totalCost: number): number;
+    static isValidDate(date: string): boolean;
+    static parseDateCode(dateCode: string): Date;
+    static getWeekday(dateCode: number): number;
+    static convertToDate(str: string): Date;
+    static previousDateChecker(fromDate: number, index: number, errorKey?: string): void;
+    static previousTimeChecker(fromTime: string, fromDate: number, index: number): void;
+    static getDateCodesByWeek(fromDate: number, toDate: number, selectedWeekday: number): string[];
+    static getDatesByWeek(fromDate: number, toDate: number, selectedWeekday: number): Date[];
+    static isValidTimeRange(timeSlot: string): boolean;
+    static dateFormat(dates: Array<Date>): Array<string>;
+    static getDateCode(date: Date): string;
+    /**
+     * Returns list of month codes (YYMM) in the Date range inclusive
+     * @param {Date} from - Start Date
+     * @param {Date} to - End Date
+     * @return {Array<Number>} - The array of month codes (YYMM)
+     */
+    static getMonthCodesRange(from: Date, to: Date): number[];
+    static getNMonthCodes(n: number): number[];
+    static getCodes(fromDate: number, toDate: number, weekday: number, turfId: number, from: string, to: string): string[];
+    static getNextDayDateCode(dateCode: number): number;
+    getUtcDateWithTime(dateCodeWithTime: string): Date;
+    static getUtcDateWithTime(dateCodeWithTime: string): Date;
+    getNoOfHoursDifference(): number;
+    static getBookingCodesPerThirtyMinutes(from: string, to: string, bookingDate: string): IGetBookingCodesPerThirtyMinutes[];
+    static getCostPerThirtyMinutes(bookingCodePerThirtyMinutesPerSlot: {
+        slotCodePerThirtyMinute: string;
+        bookingDate: string;
+    }[], pricePerThirtyMinutesData: {
+        [date: string]: {
+            [time: string]: number;
+        };
+    }): string;
+    static padBookingCode(bookingCodeWithoutTurfCode: string): string;
+    static getInstance(turfId: number, bookingCodeWithoutTurfCode: string): BookingCode;
+    getCost(): number;
+    getTimeslot(): TimeSlot;
+}