add negative fee for discount

services/integration/invoiceIntegration.js

@@ -3,11 +3,14 @@
 const moment = require('moment-timezone');
 
 const { getAllIncidents } = require('./reports');
-const { getActiveBookingsForMembersInDateRange } = require('./bookings');
+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 { getChargedCanceledReservations } = require('../integration/bookingChangeCharges');
+const { discounts } = require('../../constants/constants');
 
 const createFeeFromIncident = (incident) => {
     const {
@@ -222,33 +225,138 @@ const createFeeFromBooking = (booking, resourceMappings) => {
     }
 };
 
+const createNegativeFeeForDiscount = (memberData) => {
+    const { bookingData, member, membershipFee } = memberData;
+    const { totalBookedHours, totalChargedHours, totalBookingChargedFee } = bookingData;
+    const { memberId, officeId } = member;
+
+    const totalChargeFee = membershipFee + 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;
+        console.log(discountRate);
+        discount = totalChargeFee * discountRate;
+    }else{
+        discountPercentage = 0;
+        discount = 0;
+    }
+
+    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: moment.tz(UI_TIMEZONE).format(),
+        member: memberId,
+        team: null,
+        office: officeId,
+        isPersonal: false,
+    }
+
+};
+
 const getMembersFeesForDateRange = (dateRange, memberIds) => {
     return new Promise((resolve, reject) => {
-        const collectData = [getAllIncidents(dateRange, memberIds), getActiveBookingsForMembersInDateRange(dateRange, memberIds), getResourceMappings(), fetchAllMembers()];
-
+        const collectData = [getAllIncidents(dateRange, memberIds), getAllBookingsForMembersInDateRange(dateRange, memberIds), getResourceMappings(), fetchAllMembers(), fetchAllMembershipsAsMap()];
 
         Promise.all(collectData)
             .then((result) => {
                 const allIncidents = result[0];
-                const allActiveBookings = result[1];
+                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,
+                };
 
-                const memberIdTeamMappings = {};
                 membersList.forEach((member) => {
-                    memberIdTeamMappings[member.memberId] = member.teamId;
+                    membersMap[member.memberId] = {
+                        member,
+                        bookingData: Object.assign({}, oneMemberObject),
+                        membershipFee: membershipsMap[member.memberId] || 0,
+                    };
                 });
 
-                const allFees = [];
+                const reservationIdsForAdditionalData = [];
 
-                allIncidents.forEach((incident) => allFees.push(createFeeFromIncident(incident)));
-                allActiveBookings.forEach((booking) => allFees.push(createFeeFromBooking(booking, resourceMappings)));
+                const allActiveBookings = [];
+                allBookings.forEach((booking) => {
+                    const {reservationId, memberId, start, end, timezone, canceled, hourlyRate} = booking.get();
+                    const startMoment = moment.tz(start, timezone);
+                    const endMoment = moment.tz(end, timezone);
 
-                allFees.forEach((fee) => {
-                    fee.team = memberIdTeamMappings[fee.member] || null;
+                    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) {
+                            reservationIdsForAdditionalData.push(reservationId);
+                        } else {
+                            membersMap[memberId].bookingData.totalChargedHours += bookingLength;
+
+                            const bookingFee = bookingLength * hourlyRate;
+                            membersMap[memberId].bookingData.totalBookingChargedFee += bookingFee;
+                        }
+                    }
                 });
 
-                resolve(allFees);
+                getChargedCanceledReservations(reservationIdsForAdditionalData)
+                    .then((incidents) => {
+                        incidents.forEach((incident) => {
+                            const {memberId, oldBookingStart, oldBookingEnd, chargeFee} = incident.get();
+
+                            const startMoment = moment.tz(oldBookingStart, UI_TIMEZONE);
+                            const endMoment = moment.tz(oldBookingEnd, UI_TIMEZONE);
+
+                            if (startMoment.isValid() && endMoment.isValid()) {
+                                const bookingLength = endMoment.diff(startMoment, 'hours', true);
+
+                                membersMap[memberId].bookingData.totalChargedHours += bookingLength;
+                                membersMap[memberId].bookingData.totalBookingChargedFee += chargeFee;
+                            }
+                        });
+
+                        const memberIdTeamMappings = {};
+                        membersList.forEach((member) => {
+                            memberIdTeamMappings[member.memberId] = member.teamId;
+                        });
+
+                        const allFees = [];
+
+                        allIncidents.forEach((incident) => allFees.push(createFeeFromIncident(incident)));
+                        allActiveBookings.forEach((booking) => allFees.push(createFeeFromBooking(booking, resourceMappings)));
+
+                        //add discount
+                        memberIds.forEach((memberId) => {
+                            allFees.push(createNegativeFeeForDiscount(membersMap[memberId]));
+                        });
+
+                        allFees.forEach((fee) => {
+                            fee.team = memberIdTeamMappings[fee.member] || null;
+                        });
+
+                        resolve(allFees);
+                    })
+                    .catch((error) => reject(error));
             })
             .catch((error) => {
                 console.log(error);