turf-common 1.0.0 → 1.0.2

package/README.md

@@ -0,0 +1,11 @@
+## 1 npm init -y
+
+## 2 npm login
+
+## 3 npm version patch
+
+# //it increase version
+
+## 3 npm publish --access public
+
+# //npm publish by default --access public

package/build/enums/modification-discount-policy.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum ModificationDiscountPolicy {
+    DISCOUNT_RECALL = "discount_recall",
+    DISCOUNT_RELATIVE = "discount_relative",
+    DISCOUNT_CONDITIONAL = "discount_conditional"
+}

package/build/enums/modification-discount-policy.enum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModificationDiscountPolicy = void 0;
+var ModificationDiscountPolicy;
+(function (ModificationDiscountPolicy) {
+    ModificationDiscountPolicy["DISCOUNT_RECALL"] = "discount_recall";
+    ModificationDiscountPolicy["DISCOUNT_RELATIVE"] = "discount_relative";
+    ModificationDiscountPolicy["DISCOUNT_CONDITIONAL"] = "discount_conditional";
+})(ModificationDiscountPolicy || (exports.ModificationDiscountPolicy = ModificationDiscountPolicy = {}));

package/build/exceptions/app-badrequest.exception.d.ts

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

package/build/exceptions/app-badrequest.exception.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/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./models/booking-code-model";
+export * from "./models/charge-model";
+export * from "./models/time-slot-model";
+export * from "./exceptions/app-badrequest.exception";
+export * from "./types/app-badrequest-exception.type";
+export * from "./types/booking-modification.type";
+export * from "./interface/get-booking-codes-per-thirty-min.interface";
+export * from "./enums/modification-discount-policy.enum";

package/build/index.js

@@ -0,0 +1,24 @@
+"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("./models/booking-code-model"), exports);
+__exportStar(require("./models/charge-model"), exports);
+__exportStar(require("./models/time-slot-model"), exports);
+__exportStar(require("./exceptions/app-badrequest.exception"), exports);
+__exportStar(require("./types/app-badrequest-exception.type"), exports);
+__exportStar(require("./types/booking-modification.type"), exports);
+__exportStar(require("./interface/get-booking-codes-per-thirty-min.interface"), exports);
+__exportStar(require("./enums/modification-discount-policy.enum"), exports);

package/build/interface/get-booking-codes-per-thirty-min.interface.d.ts

@@ -0,0 +1,4 @@
+export interface IGetBookingCodesPerThirtyMinutes {
+    slotCodePerThirtyMinute: string;
+    bookingDate: string;
+}

package/build/interface/get-booking-codes-per-thirty-min.interface.js

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

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

@@ -0,0 +1,72 @@
+import { TimeSlot } from "./time-slot-model";
+import { IGetBookingCodesPerThirtyMinutes } from "../interface/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;
+    static getIndianTimeZoneDate(bookingBufferOffsetHour?: number): Date;
+}

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

@@ -0,0 +1,414 @@
+"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 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.date = matches[2];
+        this.slot = matches[3];
+        this.fromTime = matches[3].slice(0, 4);
+        this.toTime = matches[3].slice(4, 8);
+        this.pitchCode = matches[4];
+        return this;
+    };
+    BookingCode.prototype.getBookingTimeInMinutes = function () {
+        //from HHMM to HHMM
+        var fromHours = parseInt(this.fromTime.slice(0, 2));
+        var fromMinutes = parseInt(this.fromTime.slice(2, 4));
+        var toHours = parseInt(this.toTime.slice(0, 2));
+        var toMinutes = parseInt(this.toTime.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.fromTime, this.toTime).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.date.slice(0, 2), ".").concat(this.date.slice(2, 4), ".").concat(this.date.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.date.slice(0, 2)), // Year
+        parseInt(this.date.toString().slice(2, 4)) - 1, // Month (0-indexed)
+        parseInt(this.date.toString().slice(4, 6)) // Day
+        );
+        return dateObj.getDay() === 0 ? 7 : dateObj.getDay();
+        // return weekday;
+    };
+    BookingCode.prototype.getMonthCode = function () {
+        return this.date.slice(0, 4);
+    };
+    BookingCode.prototype.getDateWithFromTimeCode = function () {
+        return "".concat(this.date).concat(this.fromTime);
+    };
+    BookingCode.prototype.getCodeWithoutTurfCode = function () {
+        return "".concat(this.date).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) {
+        if (validationApply === void 0) { validationApply = true; }
+        var discount = 0;
+        var discountedCost = 0;
+        if (couponCode) {
+            if (couponCode.endsWith("P")) {
+                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 (couponCode.endsWith("U")) {
+                discount = parseFloat(couponCode);
+            }
+        }
+        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.fromTime, this.toTime);
+    };
+    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);
+    };
+    return BookingCode;
+}());
+exports.BookingCode = BookingCode;

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

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