turf-common 1.0.1 → 1.0.2

package/build/modules/booking-module/booking-code-model.js

@@ -0,0 +1,407 @@
+"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-module/time-slot-model");
+var charge_model_1 = require("../charge-module/charge-model");
+var date_code_model_1 = require("../date-module/date-code-model");
+var app_badrequest_exception_model_1 = require("../app-badrequest-exception-module/app-badrequest-exception-model");
+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_model_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_model_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_model_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_model_1.AppBadRequestException({
+                key: "Date",
+                message: ["Invalid Date"],
+            });
+        }
+        if (selectedWeekday < 0 || selectedWeekday > 7) {
+            throw new app_badrequest_exception_model_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 = date_code_model_1.DateCode.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);
+    };
+    return BookingCode;
+}());
+exports.BookingCode = BookingCode;

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

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

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

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

package/build/modules/charge-module/charge-model.d.ts

@@ -0,0 +1,44 @@
+import { BookingModification } 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: BookingModification): 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";
+}