old-psihologija/services/integration/invoiceIntegration.js

'use strict';

const moment = require('moment-timezone');

const { getAllIncidents } = require('./reports');
const { getAllBookingsForMembersInDateRange } = require('./bookings');

const { DEFAULT_DATE_FORMAT, UI_TIMEZONE, incidentTypeExplanations, incidentType, unlockedIncidentLevelsPrices } = require('../../constants/constants');
const { getResourceMappings } = require('../officeRnD/resources');
const { fetchAllMembers } = require('../officeRnD/members');
const { fetchAllMembershipsAsMap } = require('../officeRnD/memberships');
const { discounts, DISCOUNT_PLANS } = require('../../constants/constants');

const createFeeFromIncident = (incident) => {
    const {
        memberId,
        officeId,
        officeName,
        resourceName,
        oldResourceName,
        newResourceName,
        bookingStartRaw,
        bookingEndRaw,
        oldBookingStartRaw,
        oldBookingEndRaw,
        newBookingStartRaw,
        newBookingEndRaw,
        unlockTimestampRaw,
        lockTimestampRaw,
        incidentLevel,
        timeIntervalsToCharge,
        incidentPrice,
        chargePrice,
        totalChargeFee,
        incidentTimestampRaw
    } = incident;
    const incidentTypeNumber = incident.incidentType;

    const incidentExplanation = incidentTypeExplanations[incidentTypeNumber];

    let date = '';
    let price = 0;
    let quantity = 0;
    // let priceExplanation = '';
    let bookingTimeExplanation = '';
    let incidentTimeExplanation = '';
    let incidentTypeExplanation = '';
    let additionalIncidentExplanation = '';

    let roomExplanation = '';
    let dateExplanation = '';

    const bookingStartMoment = moment.tz(bookingStartRaw, UI_TIMEZONE);
    const bookingEndMoment = moment.tz(bookingEndRaw, UI_TIMEZONE);
    const unlockMoment = moment.tz(unlockTimestampRaw, UI_TIMEZONE);
    const lockMoment = moment.tz(lockTimestampRaw, UI_TIMEZONE);

    const oldBookingStartMoment = moment.tz(oldBookingStartRaw, UI_TIMEZONE);
    const oldBookingEndMoment = moment.tz(oldBookingEndRaw, UI_TIMEZONE);
    const newBookingStartMoment = moment.tz(newBookingStartRaw, UI_TIMEZONE);
    const newBookingEndMoment = moment.tz(newBookingEndRaw, UI_TIMEZONE);

    const incidentTimestampMoment = moment.tz(incidentTimestampRaw, UI_TIMEZONE);

    switch (incidentTypeNumber){
        case incidentType.UNLOCKED_INCIDENT_RELATED_WITH_RESERVATION:
            roomExplanation = resourceName;
            dateExplanation = bookingStartMoment.clone().startOf('day').format('MMM DD');
            bookingTimeExplanation = `${bookingStartMoment.clone().format('HH:mm a')} - ${bookingEndMoment.clone().format('HH:mm a')}`;
            incidentTimeExplanation = ''; // `UNLOCK : ${unlockMoment.clone().format('HH:mm a')}`;
            additionalIncidentExplanation = ` ${unlockedIncidentLevelsPrices[incidentLevel].description},`;
            incidentTypeExplanation = '';

            date = bookingStartMoment.clone().startOf('day').format();

            price = +incidentPrice.toFixed(2);
            quantity = 1.00;
            // priceExplanation = `$${price}, 1 x $${price.toFixed(2)}`;
            break;
        case incidentType.UNSCHEDULED_INCIDENT_BEFORE_RESERVATION:
            roomExplanation = resourceName;
            dateExplanation = bookingStartMoment.clone().startOf('day').format('MMM DD');
            bookingTimeExplanation = `${bookingStartMoment.clone().format('HH:mm a')} - ${bookingEndMoment.clone().format('HH:mm a')}`;
            incidentTimeExplanation = ` Unlock : ${unlockMoment.clone().format('HH:mm a')},`;
            incidentTypeExplanation = '';

            date = bookingStartMoment.clone().startOf('day').format();

            price = +chargePrice.toFixed(2);
            quantity = +timeIntervalsToCharge.toFixed(2);
            // priceExplanation = `$${totalChargeFee.toFixed(2)}, ${quantity} x $${price.toFixed(2)}`;
            break;
        case incidentType.UNSCHEDULED_INCIDENT_AFTER_RESERVATION:
            roomExplanation = resourceName;
            dateExplanation = bookingStartMoment.clone().startOf('day').format('MMM DD');
            bookingTimeExplanation = `${bookingStartMoment.clone().format('HH:mm a')} - ${bookingEndMoment.clone().format('HH:mm a')}`;
            incidentTimeExplanation = ` Lock : ${lockMoment.clone().format('HH:mm a')},`;
            incidentTypeExplanation = '';

            date = bookingStartMoment.clone().startOf('day').format();

            price = +chargePrice.toFixed(2);
            quantity = +timeIntervalsToCharge.toFixed(2);
            // priceExplanation = `$${totalChargeFee.toFixed(2)}, ${quantity} x $${price.toFixed(2)}`;
            break;
        case incidentType.UNLOCKED_INCIDENT_STANDALONE:
            roomExplanation = resourceName;
            dateExplanation = unlockMoment.clone().startOf('day').format('MMM DD');
            bookingTimeExplanation = `No reservation`;
            incidentTimeExplanation = ''; // `UNLOCK : ${unlockMoment.clone().format('HH:mm a')}`;
            additionalIncidentExplanation = ` ${unlockedIncidentLevelsPrices[incidentLevel].description},`;
            incidentTypeExplanation = '';

            date = unlockMoment.clone().startOf('day').format();

            price = +incidentPrice.toFixed(2);
            quantity = 1.00;
            // priceExplanation = `$${price.toFixed(2)}, 1 x $${price.toFixed(2)}`;
            break;
        case incidentType.UNSCHEDULED_INCIDENT_STANDALONE:
            roomExplanation = resourceName;
            dateExplanation = unlockMoment.clone().startOf('day').format('MMM DD');
            bookingTimeExplanation = `No reservation`;
            incidentTimeExplanation = ` Unlock : ${unlockMoment.clone().format('HH:mm a')} Lock : ${lockMoment.clone().format('HH:mm a')},`;
            incidentTypeExplanation = '';

            date = unlockMoment.clone().startOf('day').format();

            price = +chargePrice.toFixed(2);
            quantity = +timeIntervalsToCharge.toFixed(2);
            // priceExplanation = `$${totalChargeFee.toFixed(2)}, ${quantity} x $${price.toFixed(2)}`;
            break;
        case incidentType.BOOKING_MOVED_TO_ANOTHER_DAY:
            if (oldResourceName !== newResourceName){
                roomExplanation = `${oldResourceName} -> ${newResourceName}`;
            }else{
                roomExplanation = oldResourceName;
            }

            dateExplanation = `${oldBookingStartMoment.clone().format('MMM DD')} -> ${newBookingStartMoment.clone().format('MMM DD')}`;
            bookingTimeExplanation = `(${oldBookingStartMoment.clone().format('HH:mm a')} - ${oldBookingEndMoment.clone().format('HH:mm a')}) -> (${newBookingStartMoment.clone().format('HH:mm a')} - ${newBookingEndMoment.clone().format('HH:mm a')})`;
            incidentTimeExplanation = ` Moved on : ${incidentTimestampMoment.clone().format('MMM DD, HH:mm a')},`;
            incidentTypeExplanation = '[Cancellation]';

            date = incidentTimestampMoment.clone().startOf('day').format();

            price = +totalChargeFee.toFixed(2);
            quantity = 1.00;
            // priceExplanation = `$${totalChargeFee.toFixed(2)}, 1 x $${price.toFixed(2)}`;
            break;
        case incidentType.BOOKING_SHORTENED:
            if (oldResourceName !== newResourceName){
                roomExplanation = `${oldResourceName} -> ${newResourceName}`;
            }else{
                roomExplanation = oldResourceName;
            }

            dateExplanation = `${oldBookingStartMoment.clone().format('MMM DD')}`;
            bookingTimeExplanation = `(${oldBookingStartMoment.clone().format('HH:mm a')} - ${oldBookingEndMoment.clone().format('HH:mm a')}) -> (${newBookingStartMoment.clone().format('HH:mm a')} - ${newBookingEndMoment.clone().format('HH:mm a')})`;
            incidentTimeExplanation = ` Shortened on : ${incidentTimestampMoment.clone().format('MMM DD, HH:mm a')},`;
            incidentTypeExplanation = '[Cancellation]';

            date = incidentTimestampMoment.clone().startOf('day').format();

            price = +totalChargeFee.toFixed(2);
            quantity = 1.00;
            // priceExplanation = `$${totalChargeFee.toFixed(2)}, 1 x $${price.toFixed(2)}`;
            break;
        case incidentType.BOOKING_CANCELED_LATE:
            roomExplanation = oldResourceName;
            dateExplanation = `${oldBookingStartMoment.clone().format('MMM DD')}`;
            bookingTimeExplanation = `${oldBookingStartMoment.clone().format('HH:mm a')} - ${oldBookingEndMoment.clone().format('HH:mm a')}`;
            incidentTimeExplanation = ` Canceled on : ${incidentTimestampMoment.clone().format('MMM DD, HH:mm a')},`;
            incidentTypeExplanation = '[Cancellation]';

            date = incidentTimestampMoment.clone().startOf('day').format();

            price = +totalChargeFee.toFixed(2);
            quantity = 1.00;
            // priceExplanation = `$${totalChargeFee.toFixed(2)}, 1 x $${price.toFixed(2)}`;
            break;
    }

    const formattedName = `${incidentTypeExplanation} ${incidentExplanation},${additionalIncidentExplanation}${incidentTimeExplanation} ${officeName}, ${roomExplanation}, ${dateExplanation}, ${bookingTimeExplanation}`;

    return {
        name: formattedName,
        price,
        quantity,
        date,
        member: memberId,
        team: null,
        office: officeId,
        isPersonal: false,
    }
};

const createFeeFromBooking = (booking, resourceMappings) => {
    const { officeId, resourceId, memberId, start, end, timezone, hourlyRate } = booking;
    const { officesMap, resourcesMap } = resourceMappings;

    const startMoment = moment.tz(start, DEFAULT_DATE_FORMAT, timezone);
    const endMoment = moment.tz(end, DEFAULT_DATE_FORMAT, timezone);
    const reservationLength = endMoment.diff(startMoment, 'hours', true);

    const officeName = officesMap[officeId].officeName || 'Unknown';
    const resourceName = resourcesMap[resourceId].resourceName || 'Unknown';

    const formattedDate = startMoment.clone().startOf('day').format('MMM DD');
    const formattedStartTime = startMoment.format('HH:mm a');
    const formattedEndTime = endMoment.format('HH:mm a');

    const formattedName = `${officeName}, ${resourceName}, ${formattedDate} [${formattedStartTime} - ${formattedEndTime}]`;

    return {
        name: formattedName,
        price: +hourlyRate.toFixed(2),
        quantity: +reservationLength.toFixed(2),
        date: startMoment.startOf('day').toISOString(),
        member: memberId,
        team: null,
        office: officeId,
        isPersonal: false,
    }
};

const createNegativeFeeForDiscount = (memberData, dateRange) => {
    const { bookingData, member, membershipFees } = memberData;
    const { totalBookedHours, totalChargedHours, totalBookingChargedFee } = bookingData;
    const { memberId, officeId } = member;

    let endDate = moment.utc().endOf('day').toISOString();
    if (dateRange.endDate){
        endDate = moment.utc(dateRange.endDate, DEFAULT_DATE_FORMAT).endOf('day').toISOString();
    }

    let membershipFeeForDiscount = 0;
    membershipFees.forEach((membershipFee) => {
        const {name, price} = membershipFee;
        if (DISCOUNT_PLANS.indexOf(name) !== -1){
            membershipFeeForDiscount = price;
        }
    });

    const totalChargeFee = membershipFeeForDiscount + totalBookingChargedFee;

    let discount = 0;
    let discountPercentage = 0;

    if (totalChargedHours >= discounts.LEVEL_2.hoursRequired){
        discountPercentage = discounts.LEVEL_2.percentage;
        const discountRate = discountPercentage / 100;
        discount = totalChargeFee * discountRate;
    }else if (totalChargedHours >= discounts.LEVEL_1.hoursRequired){
        discountPercentage = discounts.LEVEL_1.percentage;
        const discountRate = discountPercentage / 100;
        discount = totalChargeFee * discountRate;
    }else{
        return null;
    }

    const formattedName = `[Discount] Total booked : ${totalBookedHours.toFixed(2)} hrs, Total charged : ${totalChargedHours.toFixed(2)} hrs, Discount : ${discountPercentage} %`;

    return {
        name: formattedName,
        price: -discount.toFixed(2),
        quantity: 1,
        date: endDate,
        member: memberId,
        team: null,
        office: officeId,
        isPersonal: false,
    }
};

const getMembersFeesForDateRange = (dateRange, memberIds) => {
    return new Promise((resolve, reject) => {
        const collectData = [getAllIncidents(dateRange, memberIds), getAllBookingsForMembersInDateRange(dateRange, memberIds), getResourceMappings(), fetchAllMembers(), fetchAllMembershipsAsMap()];

        Promise.all(collectData)
            .then((result) => {
                const allIncidents = result[0];
                const allBookings = result[1];
                const resourceMappings = result[2];
                const membersList = result[3];
                const membershipsMap = result[4];

                const membersMap = {};
                const oneMemberObject = {
                    totalBookedHours: 0,
                    totalChargedHours: 0,
                    totalBookingChargedFee: 0,
                };

                membersList.forEach((member) => {
                    membersMap[member.memberId] = {
                        member,
                        bookingData: Object.assign({}, oneMemberObject),
                        membershipFees: membershipsMap[member.memberId],
                    };
                });

                const memberIdTeamMappings = {};
                membersList.forEach((member) => {
                    memberIdTeamMappings[member.memberId] = member.teamId;
                });

                const allFees = [];

                allIncidents.forEach((incident) => {
                    allFees.push(createFeeFromIncident(incident));

                    const incidentsValuableForDiscountCalculation = [
                        incidentType.UNSCHEDULED_INCIDENT_BEFORE_RESERVATION,
                        incidentType.UNSCHEDULED_INCIDENT_AFTER_RESERVATION,
                        incidentType.UNSCHEDULED_INCIDENT_STANDALONE,
                        incidentType.BOOKING_SHORTENED,
                        incidentType.BOOKING_CANCELED_LATE
                    ];

                    const incidentTypeNumber = incident.incidentType;
                    if (incidentsValuableForDiscountCalculation.indexOf(incidentTypeNumber) === -1){
                        return;
                    }

                    const {
                        memberId,
                        oldBookingStartRaw,
                        oldBookingEndRaw,
                        newBookingStartRaw,
                        newBookingEndRaw,
                        unlockTimestampRaw,
                        lockTimestampRaw,
                        bookingStartRaw,
                        bookingEndRaw,
                        totalChargeFee
                    } = incident;

                    let chargedBookingLength = 0;

                    switch (incidentTypeNumber){
                        case incidentType.UNSCHEDULED_INCIDENT_BEFORE_RESERVATION:
                            const unlockMoment = moment.utc(unlockTimestampRaw);
                            const bookingStartMoment =moment.utc(bookingStartRaw);
                            if (unlockMoment.isValid() && bookingStartMoment.isValid()){
                                chargedBookingLength = bookingStartMoment.diff(unlockMoment, 'hours', true);
                            }
                            break;
                        case incidentType.UNSCHEDULED_INCIDENT_AFTER_RESERVATION:
                            const lockMoment = moment.utc(lockTimestampRaw);
                            const bookingEndMoment =moment.utc(bookingEndRaw);
                            if (lockMoment.isValid() && bookingEndMoment.isValid()){
                                chargedBookingLength = lockMoment.diff(bookingEndMoment, 'hours', true);
                            }
                            break;
                        case incidentType.UNSCHEDULED_INCIDENT_STANDALONE:
                            const unlockMomentStandalone = moment.utc(unlockTimestampRaw);
                            const lockMomentStandalone = moment.utc(lockTimestampRaw);
                            if (unlockMomentStandalone.isValid() && lockMomentStandalone.isValid()){
                                chargedBookingLength = lockMomentStandalone.diff(unlockMomentStandalone, 'hours', true);
                            }
                            break;
                        case incidentType.BOOKING_SHORTENED:
                            const oldBookingStartMoment = moment.utc(oldBookingStartRaw);
                            const oldBookingEndMoment = moment.utc(oldBookingEndRaw);
                            const newBookingStartMoment = moment.utc(newBookingStartRaw);
                            const newBookingEndMoment = moment.utc(newBookingEndRaw);

                            if (oldBookingStartMoment.isValid() && oldBookingEndMoment.isValid() && newBookingStartMoment.isValid() && newBookingEndMoment.isValid()){
                                const oldBookingLength = oldBookingEndMoment.diff(oldBookingStartMoment, 'hours', true);
                                const newBookingLength = newBookingEndMoment.diff(newBookingStartMoment, 'hours', true);

                                chargedBookingLength = Math.abs(oldBookingLength - newBookingLength);
                            }
                            break;
                        case incidentType.BOOKING_CANCELED_LATE:
                            const startMoment = moment.utc(oldBookingStartRaw);
                            const endMoment = moment.utc(oldBookingEndRaw);

                            if (startMoment.isValid() && endMoment.isValid()) {
                                chargedBookingLength = endMoment.diff(startMoment, 'hours', true);

                                // membersMap[memberId].bookingData.totalBookedHours += bookingLength;
                                // "booked hours" is counted in canceled booking section
                            }

                            break;
                    }

                    membersMap[memberId].bookingData.totalChargedHours += chargedBookingLength;
                    membersMap[memberId].bookingData.totalBookingChargedFee += totalChargeFee;
                });
                allBookings.forEach((booking) => {
                    const {memberId, start, end, timezone, hourlyRate, canceled } = booking.get();
                    const startMoment = moment.tz(start, timezone);
                    const endMoment = moment.tz(end, timezone);

                    if (startMoment.isValid() && endMoment.isValid()) {
                        const bookingLength = endMoment.diff(startMoment, 'hours', true);

                        if (!membersMap[memberId] || !membersMap[memberId].bookingData) {
                            membersMap[memberId].bookingData = Object.assign({}, oneMemberObject);
                        }

                        membersMap[memberId].bookingData.totalBookedHours += bookingLength;

                        if (!canceled){
                            membersMap[memberId].bookingData.totalChargedHours += bookingLength;
                            const bookingFee = bookingLength * hourlyRate;
                            membersMap[memberId].bookingData.totalBookingChargedFee += bookingFee;

                            allFees.push(createFeeFromBooking(booking, resourceMappings));
                        }
                    }
                });

                //add discount
                memberIds.forEach((memberId) => {
                    const discountFee = createNegativeFeeForDiscount(membersMap[memberId], dateRange);
                    if (discountFee){
                        allFees.push(discountFee);
                    }
                });

                allFees.forEach((fee) => {
                    fee.team = memberIdTeamMappings[fee.member] || null;
                });

                resolve(allFees);

            })
            .catch((error) => {
                console.log(error);
                reject(error);
            });
    });
};

module.exports = {
    getMembersFeesForDateRange,
};