turf-common 1.3.1-beta.8 → 1.3.1

package/build/src/models/booking-code-model.js

@@ -0,0 +1,624 @@
+"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.BookingCode = void 0;
+var time_slot_model_1 = require("./time-slot-model");
+var charge_model_1 = require("./charge-model");
+var app_badrequest_exception_1 = require("../exceptions/app-badrequest.exception");
+var date_util_1 = require("../utils/date-util");
+var date_fns_1 = require("date-fns");
+var _utils_1 = require("../@utils");
+var BookingCode = /** @class */ (function () {
+    function BookingCode(code, cost) {
+        if (cost === void 0) { cost = "-1"; }
+        // this.id = turfid;
+        if (code.length === 18)
+            this.code = code + "00";
+        else
+            this.code = code;
+        this.cost = cost;
+        this.parse();
+    }
+    BookingCode.prototype.parse = function () {
+        var regexp = /(\d{4})(\d{6})(\d{8})(\d{2})/g;
+        var matches = regexp.exec(this.code);
+        if (!matches) {
+            throw new Error("Booking slot ".concat(this.code, " is invalid"));
+        }
+        this.turfId = matches[1];
+        this.dateCode = matches[2];
+        this.slot = matches[3];
+        this.fromTimeCode = matches[3].slice(0, 4);
+        this.toTimeCode = matches[3].slice(4, 8);
+        this.pitchCode = matches[4];
+        this.pitchNumber = Number(matches[4]);
+        return this;
+    };
+    BookingCode.prototype.getBookingTimeInMinutes = function () {
+        //from HHMM to HHMM
+        var fromHours = parseInt(this.fromTimeCode.slice(0, 2));
+        var fromMinutes = parseInt(this.fromTimeCode.slice(2, 4));
+        var toHours = parseInt(this.toTimeCode.slice(0, 2));
+        var toMinutes = parseInt(this.toTimeCode.slice(2, 4));
+        return toHours * 60 + toMinutes - (fromHours * 60 + fromMinutes);
+    };
+    BookingCode.prototype.getPitchNo = function () {
+        return parseInt(this.pitchCode);
+    };
+    BookingCode.prototype.getHalfHourTimeCodes = function () {
+        return new time_slot_model_1.TimeSlot(this.fromTimeCode, this.toTimeCode).getHalfHourTimeCodes();
+    };
+    /**
+     *
+     * @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']
+     */
+    BookingCode.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;
+    };
+    BookingCode.prototype.getValidDate = function () {
+        // Date format: YYMMDD
+        function getDate(dateString) {
+            var separators = ["\\.", "\\-", "\\/"];
+            var stringBits = dateString.split(new RegExp(separators.join("|"), "g"));
+            var intBits = stringBits.map(function (bit) { return parseInt(bit); });
+            return new Date(intBits[0], intBits[1] - 1, intBits[2]);
+        }
+        return getDate("20".concat(this.dateCode.slice(0, 2), ".").concat(this.dateCode.slice(2, 4), ".").concat(this.dateCode.slice(4, 6)));
+    };
+    BookingCode.prototype.getDateCode = function () {
+        var date = this.getValidDate();
+        return "".concat(date.getFullYear() % 2000).concat((date.getMonth() + 1)
+            .toString()
+            .padStart(2, "0")).concat(date.getDate().toString().padStart(2, "0"));
+    };
+    BookingCode.prototype.getWeekday = function () {
+        var dateObj = new Date(2000 + parseInt(this.dateCode.slice(0, 2)), // Year
+        parseInt(this.dateCode.toString().slice(2, 4)) - 1, // Month (0-indexed)
+        parseInt(this.dateCode.toString().slice(4, 6)) // Day
+        );
+        return dateObj.getDay() === 0 ? 7 : dateObj.getDay();
+        // return weekday;
+    };
+    BookingCode.prototype.getMonthCode = function () {
+        return this.dateCode.slice(0, 4);
+    };
+    BookingCode.prototype.getDateWithFromTimeCode = function () {
+        return "".concat(this.dateCode).concat(this.fromTimeCode);
+    };
+    BookingCode.prototype.getCodeWithoutTurfCode = function () {
+        return "".concat(this.dateCode).concat(this.slot).concat(this.pitchCode);
+    };
+    BookingCode.sortByCode = function (bookingCodes) {
+        bookingCodes.sort(function (_a, _b) {
+            var code1 = _a.code;
+            var code2 = _b.code;
+            return code1 < code2 ? -1 : code1 > code2 ? 1 : 0;
+        });
+    };
+    // code: TTTTYYMMDDFHFMTHTMPP;
+    BookingCode.getOneSlotBookingCode = function (turfId, bookingDate, fhfm, thtm, pitchCode) {
+        var code = turfId + bookingDate + fhfm + thtm + pitchCode;
+        return code;
+    };
+    BookingCode.getDiscountedCost = function (couponCode, totalCost, validationApply, totalBookingHours) {
+        if (validationApply === void 0) { validationApply = true; }
+        var discount = 0;
+        var discountedCost = 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) {
+                    if (percentDiscount > 90) {
+                        throw new app_badrequest_exception_1.AppBadRequestException({
+                            key: "couponCode",
+                            message: ["Discount should not be more than 90P"],
+                        });
+                    }
+                }
+                discount = totalCost * (percentDiscount / 100);
+            }
+            else if (code === "U") {
+                discount = 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",
+                        ],
+                    });
+                }
+                discount = parseFloat(couponCode) * totalBookingHours;
+            }
+        }
+        discountedCost = totalCost - discount;
+        return Math.round(discountedCost);
+    };
+    BookingCode.getDiscountAmount = function (couponCode, totalCost) {
+        return charge_model_1.ChargesModel.getDiscountAmount(couponCode, totalCost, true);
+    };
+    //-----------------
+    BookingCode.isValidDate = function (date) {
+        // Date format: YYMMDD
+        function isDate(dateString) {
+            var separators = ["\\.", "\\-", "\\/"];
+            var stringBits = dateString.split(new RegExp(separators.join("|"), "g"));
+            var intBits = stringBits.map(function (bit) { return parseInt(bit); });
+            var parsedDate = new Date(intBits[0], intBits[1] - 1, intBits[2]);
+            return (parsedDate.getFullYear() === intBits[0] &&
+                parsedDate.getMonth() + 1 === intBits[1] &&
+                parsedDate.getDate() === intBits[2]);
+        }
+        return isDate("20".concat(date.slice(0, 2), ".").concat(date.slice(2, 4), ".").concat(date.slice(4, 6)));
+    };
+    BookingCode.parseDateCode = function (dateCode) {
+        // Date format: YYMMDD
+        function getDate(dateString) {
+            var separators = ["\\.", "\\-", "\\/"];
+            var stringBits = dateString.split(new RegExp(separators.join("|"), "g"));
+            var intBits = stringBits.map(function (bit) { return parseInt(bit); });
+            return new Date(intBits[0], intBits[1] - 1, intBits[2]);
+        }
+        return getDate("20".concat(dateCode.slice(0, 2), ".").concat(dateCode.slice(2, 4), ".").concat(dateCode.slice(4, 6)));
+    };
+    //------------------
+    BookingCode.getWeekday = function (dateCode) {
+        var dateObj = new Date(2000 + parseInt(dateCode.toString().slice(0, 2)), // Year
+        parseInt(dateCode.toString().slice(2, 4)) - 1, // Month (0-indexed)
+        parseInt(dateCode.toString().slice(4, 6)) // Day
+        );
+        var weekday = dateObj.getDay();
+        return weekday === 0 ? 7 : weekday;
+    };
+    //---------------------
+    BookingCode.convertToDate = function (str) {
+        var year = parseInt(20 + str.slice(0, 2));
+        var month = parseInt(str.slice(2, 4)) - 1;
+        var day = parseInt(str.slice(4, 6));
+        var date = new Date(Date.UTC(year, month, day, 0, 0, 0));
+        return date;
+    };
+    //---------------------
+    BookingCode.previousDateChecker = function (fromDate, index, errorKey) {
+        var slotDate = this.convertToDate(fromDate.toString());
+        var currentDateObj = new Date();
+        var parsedDate = this.dateFormat([slotDate]);
+        var currentDate = this.dateFormat([currentDateObj]);
+        if (parsedDate < currentDate) {
+            throw new app_badrequest_exception_1.AppBadRequestException({
+                key: errorKey !== null && errorKey !== void 0 ? errorKey : "slot.".concat(index),
+                message: ["date must be present Date or future Date"],
+            });
+        }
+        else if (parsedDate === currentDate) {
+            return;
+        }
+    };
+    //---------------------
+    BookingCode.previousTimeChecker = function (fromTime, fromDate, index) {
+        var now = new Date();
+        this.convertToDate(fromDate.toString());
+        var delayInBooking = 15;
+        if (this.convertToDate(fromDate.toString()) > now) {
+            return; //do nothing if fromDate is in future
+        }
+        else if (this.convertToDate(fromDate.toString()) <= now) {
+            now.setMinutes(now.getMinutes() - delayInBooking); // 15minutes buffer for late bookings
+            var options = {
+                timeZone: "Asia/Kolkata",
+            };
+            var timeFormat = new Intl.DateTimeFormat("en-US", __assign(__assign({}, options), { hour: "2-digit", minute: "2-digit", hour12: false }));
+            var currentTimeObj = timeFormat.format(now).replace(/:/g, "");
+            if (fromTime < currentTimeObj) {
+                throw new app_badrequest_exception_1.AppBadRequestException({
+                    key: "slot.".concat(index),
+                    message: ["Booking time should be in future"],
+                });
+            }
+        }
+    };
+    //---------------------
+    BookingCode.getDateCodesByWeek = function (fromDate, toDate, selectedWeekday) {
+        return BookingCode.dateFormat(BookingCode.getDatesByWeek(fromDate, toDate, selectedWeekday));
+    };
+    BookingCode.getDatesByWeek = function (fromDate, toDate, selectedWeekday) {
+        if (!BookingCode.isValidDate(fromDate.toString()) ||
+            !BookingCode.isValidDate(toDate.toString())) {
+            throw new app_badrequest_exception_1.AppBadRequestException({
+                key: "Date",
+                message: ["Invalid Date"],
+            });
+        }
+        if (selectedWeekday < 0 || selectedWeekday > 7) {
+            throw new app_badrequest_exception_1.AppBadRequestException({
+                key: "weekday",
+                message: ["weekday should be between 1-7"],
+            });
+        }
+        var startDate = BookingCode.convertToDate(fromDate.toString());
+        var endDate = BookingCode.convertToDate(toDate.toString());
+        var currentDate = startDate;
+        var dates = [];
+        while (currentDate <= endDate) {
+            var weekday = currentDate.getDay();
+            if (weekday === selectedWeekday % 7) {
+                dates.push(new Date(currentDate.getTime()));
+                currentDate.setDate(currentDate.getDate() + 7);
+            }
+            else {
+                currentDate.setDate(currentDate.getDate() + 1);
+            }
+        }
+        return dates;
+    };
+    //--------------------
+    BookingCode.isValidTimeRange = function (timeSlot) {
+        var timeformat = /^(([01]\d|2[0-3])([0-5]\d|60)|2400|0000)$/;
+        var isValidTime = timeformat.test(timeSlot) && parseInt(timeSlot, 10) <= 2400;
+        return isValidTime;
+    };
+    //---------------------
+    BookingCode.dateFormat = function (dates) {
+        var codes = [];
+        for (var _i = 0, dates_1 = dates; _i < dates_1.length; _i++) {
+            var date = dates_1[_i];
+            var dateYear = date.getFullYear() % 2000;
+            var dateMonth = date.getMonth() + 1;
+            var dateDay = date.getDate();
+            var dateFormat = dateYear.toString() +
+                dateMonth.toString().padStart(2, "0") +
+                dateDay.toString().padStart(2, "0");
+            codes.push(dateFormat);
+        }
+        return codes;
+    };
+    BookingCode.getDateCode = function (date) {
+        return "".concat(date.getFullYear() % 2000).concat((date.getMonth() + 1)
+            .toString()
+            .padStart(2, "0")).concat(date.getDate().toString().padStart(2, "0"));
+    };
+    /**
+     * 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)
+     */
+    BookingCode.getMonthCodesRange = function (from, to) {
+        from = new Date(from.getTime());
+        to = new Date(to.getTime());
+        var monthCodes = [];
+        while (from < to) {
+            var fromDateCode = BookingCode.getDateCode(from);
+            monthCodes.push(parseInt("".concat(fromDateCode.slice(0, 4))));
+            from.setMonth(from.getMonth() + 1);
+        }
+        var toDateCode = BookingCode.getDateCode(to);
+        if (!monthCodes.includes(parseInt("".concat(toDateCode.slice(0, 4))))) {
+            monthCodes.push(parseInt("".concat(toDateCode.slice(0, 4))));
+        }
+        return monthCodes;
+    };
+    BookingCode.getNMonthCodes = function (n) {
+        var now = new Date();
+        var future = new Date(now.getTime());
+        future.setMonth(now.getMonth() + n);
+        return BookingCode.getMonthCodesRange(now, future);
+    };
+    BookingCode.getCodes = function (fromDate, toDate, weekday, turfId, from, to) {
+        // const {fromDate, toDate, weekday, turfId, from, to} = bookingSlot
+        var dates = this.getDateCodesByWeek(fromDate, toDate, weekday);
+        // TTTTYYMMDDFFFFTTTT
+        var codes = [];
+        for (var _i = 0, dates_2 = dates; _i < dates_2.length; _i++) {
+            var date = dates_2[_i];
+            codes.push("".concat(turfId.toString().padStart(4, "0")).concat(date).concat(from).concat(to));
+        }
+        return codes;
+    };
+    //To check fromDate and toDate present in weekDays and return dateCode
+    BookingCode.getNextDayDateCode = function (dateCode) {
+        var nextDate = BookingCode.parseDateCode(dateCode.toString());
+        nextDate.setDate(nextDate.getDate() + 1);
+        return parseInt(BookingCode.getDateCode(nextDate));
+    };
+    BookingCode.prototype.getUtcDateWithTime = function (dateCodeWithTime) {
+        // const dateCodeWithTime = '2305131200';
+        var year = parseInt(dateCodeWithTime.slice(0, 2)) + 2000;
+        var month = parseInt(dateCodeWithTime.slice(2, 4)) - 1;
+        var day = parseInt(dateCodeWithTime.slice(4, 6));
+        var hours = parseInt(dateCodeWithTime.slice(6, 8));
+        var minutes = parseInt(dateCodeWithTime.slice(8, 10));
+        return new Date(Date.UTC(year, month, day, hours, minutes));
+    };
+    BookingCode.getUtcDateWithTime = function (dateCodeWithTime) {
+        // const dateCodeWithTime = '2305131200';
+        var year = parseInt(dateCodeWithTime.slice(0, 2)) + 2000;
+        var month = parseInt(dateCodeWithTime.slice(2, 4)) - 1;
+        var day = parseInt(dateCodeWithTime.slice(4, 6));
+        var hours = parseInt(dateCodeWithTime.slice(6, 8));
+        var minutes = parseInt(dateCodeWithTime.slice(8, 10));
+        return new Date(Date.UTC(year, month, day, hours, minutes));
+    };
+    BookingCode.prototype.getNoOfHoursDifference = function () {
+        var bookingDate = BookingCode.getUtcDateWithTime(this.getDateWithFromTimeCode());
+        var date = BookingCode.getIndianTimeZoneDate();
+        var timeDifferenceMs = bookingDate.getTime() - date.getTime();
+        return timeDifferenceMs / (1000 * 60 * 60);
+    };
+    BookingCode.getBookingCodesPerThirtyMinutes = function (from, to, bookingDate) {
+        var bookingCodePerThirtyMinutes = [];
+        while (from < to) {
+            var lastDigit = from.slice(2, 4);
+            if (lastDigit == "00") {
+                var code = "".concat(from).concat((Number(from) + 30)
+                    .toString()
+                    .padStart(4, "0"));
+                bookingCodePerThirtyMinutes.push({
+                    slotCodePerThirtyMinute: code,
+                    bookingDate: bookingDate,
+                });
+                from = (Number(from) + 30).toString().padStart(4, "0");
+            }
+            else {
+                var code = "".concat(from).concat((Number(from) + 70)
+                    .toString()
+                    .padStart(4, "0"));
+                bookingCodePerThirtyMinutes.push({
+                    slotCodePerThirtyMinute: code,
+                    bookingDate: bookingDate,
+                });
+                from = (Number(from) + 70).toString().padStart(4, "0");
+            }
+        }
+        return bookingCodePerThirtyMinutes;
+    };
+    BookingCode.getCostPerThirtyMinutes = function (bookingCodePerThirtyMinutesPerSlot, pricePerThirtyMinutesData) {
+        var cost = [];
+        bookingCodePerThirtyMinutesPerSlot.forEach(function (slot) {
+            var weekDay = BookingCode.getWeekday(Number(slot.bookingDate));
+            var month = slot.bookingDate.slice(0, 4);
+            var monthWeekday = "".concat(month).concat(weekDay);
+            var price = pricePerThirtyMinutesData[monthWeekday][slot.slotCodePerThirtyMinute];
+            cost.push(price.toString());
+        });
+        return cost.join(",");
+    };
+    BookingCode.padBookingCode = function (bookingCodeWithoutTurfCode) {
+        return bookingCodeWithoutTurfCode.padStart(20, "0");
+    };
+    BookingCode.getInstance = function (turfId, bookingCodeWithoutTurfCode) {
+        return new BookingCode("".concat(turfId.toString().padStart(4, "0")).concat(bookingCodeWithoutTurfCode));
+    };
+    BookingCode.prototype.getCost = function () {
+        return this.cost
+            .split(",")
+            .map(function (a) { return parseInt(a); })
+            .reduce(function (a, b) { return a + b; }, 0);
+    };
+    BookingCode.prototype.getTimeslot = function () {
+        return new time_slot_model_1.TimeSlot(this.fromTimeCode, this.toTimeCode);
+    };
+    BookingCode.getIndianTimeZoneDate = function (bookingBufferOffsetHour) {
+        var now = new Date();
+        var utcOffsetMinutes = 330; // Indian Standard Time (IST) offset is UTC+05:30
+        var indianTimeMillis = now.getTime() +
+            utcOffsetMinutes * 60 * 1000 +
+            (bookingBufferOffsetHour || 0) * 60 * 60 * 1000;
+        return new Date(indianTimeMillis);
+    };
+    //--------------------------------------------------------------
+    BookingCode.prototype.getInstanceByPitchNo = function (newPitchNo) {
+        return new BookingCode("".concat(this.code.slice(0, -2)).concat(newPitchNo.toString().padStart(2, "0")), this.cost);
+    };
+    BookingCode.prototype.getDateFromTimeCode = function () {
+        return parseInt("".concat(this.dateCode).concat(this.fromTimeCode));
+    };
+    BookingCode.prototype.getPreviousBookingSlotCode = function () {
+        var prevousBookingCode = this.getPreviousBookingCode();
+        return "".concat(prevousBookingCode.dateCode).concat(prevousBookingCode
+            .getTimeslot()
+            .getCode());
+    };
+    BookingCode.prototype.getPreviousBookingCode = function () {
+        if (this.fromTimeCode === "0000") {
+            // Add previous day
+            var previousDateCode = date_util_1.dateUtilService.addNDaysToDateCode(this.dateCode, -1);
+            // return `${previousDateCode}23302400`;
+            return new BookingCode("".concat(this.code.slice(0, 4)).concat(previousDateCode, "23302400").concat(this.code.slice(-2)));
+        }
+        else {
+            var previousTimeSlotCode = this.getPreviousTimeSlotCode();
+            return new BookingCode("".concat(this.code.slice(0, 4)).concat(this.dateCode).concat(previousTimeSlotCode).concat(this.fromTimeCode).concat(this.code.slice(-2)));
+        }
+    };
+    BookingCode.prototype.getPreviousTimeSlotCode = function (isHour) {
+        if (isHour === void 0) { isHour = false; }
+        return this.getOffsetTimeSlotCode(this.fromTimeCode, isHour, false);
+    };
+    BookingCode.prototype.getNextBookingSlotCode = function () {
+        var nextBookingCode = this.getNextBookingCode();
+        return "".concat(nextBookingCode.dateCode).concat(nextBookingCode
+            .getTimeslot()
+            .getCode());
+    };
+    BookingCode.prototype.getNextTimeSlotCode = function (isHour) {
+        if (isHour === void 0) { isHour = false; }
+        return this.getOffsetTimeSlotCode(this.toTimeCode, isHour, true);
+    };
+    BookingCode.prototype.getNextBookingCode = function () {
+        var toTimeSlotCode = this.toTimeCode;
+        if (this.toTimeCode === "2400") {
+            // Add next day
+            var nextDateCode = date_util_1.dateUtilService.addNDaysToDateCode(this.dateCode, 1);
+            // return `${nextDateCode}00000030`;
+            return new BookingCode("".concat(this.code.slice(0, 4)).concat(nextDateCode, "00000030").concat(this.code.slice(-2)));
+        }
+        else {
+            var nextTimeSlotCode = this.getNextTimeSlotCode();
+            return new BookingCode("".concat(this.code.slice(0, 4)).concat(this.dateCode).concat(toTimeSlotCode).concat(nextTimeSlotCode).concat(this.code.slice(-2)));
+        }
+    };
+    BookingCode.prototype.getOffsetTimeSlotCode = function (timeCode, isHour, isNext) {
+        if (isHour === void 0) { isHour = false; }
+        if (isNext === void 0) { isNext = true; }
+        var minutes = parseInt(timeCode.slice(0, 2)) * 60 +
+            parseInt(timeCode.slice(2, 4)) +
+            (isNext ? 1 : -1) * (isHour ? 60 : 30);
+        return "".concat(Math.floor(minutes / 60)
+            .toString()
+            .padStart(2, "0")).concat((minutes % 60).toString().padStart(2, "0"));
+    };
+    BookingCode.prototype.isInPast = function () {
+        var pastBookingCode = "".concat(this.dateCode).concat(this.getTimeslot().getCode());
+        var currentTime = new Date().getTime();
+        return (new Date(parseInt("20".concat(pastBookingCode.slice(0, 2))), parseInt(pastBookingCode.slice(2, 4)) - 1, parseInt(pastBookingCode.slice(4, 6)), parseInt(pastBookingCode.slice(6, 8)), parseInt(pastBookingCode.slice(8, 10))).getTime() < currentTime);
+    };
+    BookingCode.prototype.formatDateAndTime = function (formateDateAndTime) {
+        var dateFormat = formateDateAndTime.dateFormat, timeFormat = formateDateAndTime.timeFormat, separator = formateDateAndTime.separator, timeSeparator = formateDateAndTime.timeSeparator;
+        this.toTimeCode = date_util_1.dateUtilService
+            .handle2400HourInDateCode("".concat(this.dateCode).concat(this.toTimeCode))
+            .slice(-4);
+        var formattedDate = BookingCode.dateFormatter({
+            dateFormat: dateFormat,
+            dateCode: this.dateCode,
+        });
+        var formattedFromTime = BookingCode.timeFormatter({
+            timeFormat: timeFormat,
+            timeCode: this.fromTimeCode,
+        });
+        var formattedToTime = BookingCode.timeFormatter({
+            timeFormat: timeFormat,
+            timeCode: this.toTimeCode,
+        });
+        return "".concat(formattedDate).concat(separator).concat(formattedFromTime).concat(timeSeparator).concat(formattedToTime);
+    };
+    BookingCode.timeFormatter = function (timeFormatter) {
+        var parsedFromTime = (0, date_fns_1.parse)(timeFormatter.timeCode, "HHmm", new Date());
+        return (0, date_fns_1.format)(parsedFromTime, timeFormatter.timeFormat);
+    };
+    BookingCode.dateFormatter = function (dateFormatter) {
+        var dateFormat = dateFormatter.dateFormat, dateCode = dateFormatter.dateCode;
+        return (0, date_fns_1.format)(BookingCode.convertToDate(dateCode), dateFormat);
+    };
+    /**
+     * Calculates the total time difference between two date codes.
+     * @param unit - Optional. Specifies the unit of time for the result. Valid values are "minute" or "hr". Defaults to "minute" if not provided.
+     * @returns The total time difference in the specified unit (minutes or hours) between the "from" and "to" date codes.
+     */
+    BookingCode.prototype.getTotalTime = function (unit) {
+        if (unit === void 0) { unit = "minute"; }
+        return date_util_1.dateUtilService.calculateDateDifference(this.getAcrossDateCodes().fromDateCode, this.getAcrossDateCodes().toDateCode, unit);
+    };
+    /**
+     * Gets the date codes across a time range.
+     *
+     * @returns An object containing the date codes for the from and to time.
+     * @description
+     * The `fromDateCode` is generated by combining the current instance's `dateCode` and `fromTimeCode`.
+     * The `toDateCode` is generated based on the `fromTimeCode` and `toTimeCode`. If `fromTimeCode` is greater
+     * than `toTimeCode`, it adds one day to the current instance's `dateCode`.
+     */
+    BookingCode.prototype.getAcrossDateCodes = function () {
+        var fromDateCode = "".concat(this.dateCode).concat(this.fromTimeCode);
+        var toDateCode = "".concat(this.fromTimeCode > this.toTimeCode
+            ? date_util_1.dateUtilService.addNDaysToDateCode(this.dateCode, 1)
+            : this.dateCode).concat(this.toTimeCode);
+        return { fromDateCode: fromDateCode, toDateCode: toDateCode };
+    };
+    BookingCode.getTotalTimeByBookingCodes = function (bookingCodes) {
+        var totalBookingHours = 0;
+        bookingCodes.forEach(function (bookingCode) {
+            totalBookingHours += new BookingCode(bookingCode.code).getTotalTime("hr");
+        });
+        return totalBookingHours;
+    };
+    /**
+     * Retrieves booking codes for a booking scenario that may span across different days.
+     * If the booking spans multiple days, two codes are generated for each day; otherwise, a single code is used.
+     *
+     * @returns {string[]} An array containing the booking codes.
+     */
+    BookingCode.prototype.getBookingCodesByAcrossDateBookingCode = function () {
+        var bookingCodes = [];
+        // Check if the booking spans across different days
+        if (this.fromTimeCode > this.toTimeCode) {
+            var firstDayCode = "".concat(this.turfId).concat(this.dateCode).concat(this.fromTimeCode, "2400").concat(this.pitchCode);
+            var secondDayCode = "".concat(this.turfId).concat(date_util_1.dateUtilService.addNDaysToDateCode(this.dateCode, 1), "0000").concat(this.toTimeCode).concat(this.pitchCode);
+            bookingCodes.push(firstDayCode);
+            bookingCodes.push(secondDayCode);
+        }
+        else {
+            bookingCodes.push(this.code);
+        }
+        return bookingCodes;
+    };
+    /**
+     * Converts booking codes obtained using `getBookingCodesByAcrossDateBookingCode` into an array of BookingCode models.
+     *
+     * @returns {BookingCode[]} An array containing BookingCode models.
+     */
+    BookingCode.prototype.getBookingCodeModelsByAcrossDateBookingCode = function () {
+        var bookingCodes = this.getBookingCodesByAcrossDateBookingCode();
+        var bookingCodeModels = [];
+        bookingCodes.forEach(function (code) {
+            bookingCodeModels.push(new BookingCode(code));
+        });
+        return bookingCodeModels;
+    };
+    /**
+     * @param {BookingCode} nextBookingCode - The booking code to check for adjacency.
+     * @returns {boolean} True if the codes are adjacent, false otherwise.
+     *
+     * @description
+     * Two booking codes are considered adjacent if the current booking code ends at the end of the day (`2400`)
+     * and the next booking code starts at the beginning of the day (`0000`) on the following day.
+     * Additionally, the pitch number and turf ID must match between the two codes.
+     */
+    BookingCode.prototype.isAdjacentBookingCode = function (nextBookingCode) {
+        return (this.toTimeCode === _utils_1.END_OF_DAY_TIME_CODE &&
+            nextBookingCode.fromTimeCode === _utils_1.START_OF_DAY_TIME_CODE &&
+            date_util_1.dateUtilService.addNDaysToDateCode(this.dateCode, 1) ===
+                nextBookingCode.dateCode &&
+            this.pitchNumber === nextBookingCode.pitchNumber &&
+            this.turfId === nextBookingCode.turfId);
+    };
+    /**
+     * Extracts the numeric part of a bookingCode, excluding a predefined deleted slot separator.
+     *
+     * @param {string} bookingCode - The input bookingCode to extract from.
+     * @returns {string} The numeric part of the bookingCode.
+     */
+    BookingCode.extractBookingCodeByDeletedSlotSeparator = function (bookingCode) {
+        return bookingCode.startsWith(_utils_1.DELETED_SLOT_SEPARATOR)
+            ? bookingCode.slice(_utils_1.DELETED_SLOT_SEPARATOR.length)
+            : bookingCode;
+    };
+    return BookingCode;
+}());
+exports.BookingCode = BookingCode;

package/build/src/models/charge-model.d.ts

@@ -0,0 +1,34 @@
+import { IBookingModification } from "../types/booking-modification.type";
+import { ModificationDiscountPolicy } from "../enums/modification-discount-policy.enum";
+import { IChargeModel } from "../interface/model/charge-model.interface";
+export declare class ChargesModel implements IChargeModel {
+    initialBookingGrossAmount: number;
+    additionalBookingGrossAmount: number;
+    cancelledBookingGrossAmount: number;
+    totalCancellationCharges: number;
+    refundPayable: number;
+    netTotal: number;
+    amountPaid: number;
+    amountPayable: number;
+    totalRefundedAmount: number;
+    totalBookingHours: number;
+    couponCode: string;
+    discountPolicy: ModificationDiscountPolicy;
+    constructor(initialGrossAmount: number, paidAmount: number, couponCode: string, totalBookingHours: number, discountPolicy: ModificationDiscountPolicy);
+    getGrossAmount(): number;
+    getNetAmount(): number;
+    getDiscountAmount(): number;
+    getPayableRefundAmount(): number;
+    static getDiscountAmount(couponCode: string, totalCost: number, validationApply?: boolean, totalBookingHours?: number): number;
+    setValues(values?: Partial<ChargesModel>): ChargesModel;
+    modify(bookingModification: IBookingModification): ChargesModel | null;
+    private modifyExtend;
+    private modifyReduce;
+    private modifyMove;
+    clone(): ChargesModel;
+    private modifyDelete;
+    static getInstance(chargeData: IChargeModel, discountPolicy?: ModificationDiscountPolicy): ChargesModel;
+    getTotalAmount(): number;
+    getPaymentStatus(): "Refund" | "Paid" | "Pending";
+    getTotalNetAmount(): number;
+}