create incidents for booking changes

services/integration/bookingChangeCharges.js

@@ -1,2 +1,115 @@
 'use strict';
 
+const moment = require('moment-timezone');
+const db = require('../../models/index');
+
+const { UI_TIMEZONE, BOOKING_CHANGE_PERCENTAGE_CHARGE, incidentType } = require('../../constants/constants');
+
+const bulkWriteBookingChangeIncidents = (incidents) => {
+    return new Promise((resolve, reject) => {
+        const asyncJobs = [];
+        incidents.forEach((incident) => {
+            asyncJobs.push(db.bookingChangeIncident.findOrCreate({where: incident, defaults: incident}));
+        });
+
+        Promise.all(asyncJobs)
+            .then(() => {
+                resolve();
+            })
+            .catch((error) => reject(error));
+    });
+};
+
+const chargeBookingChanges = (changes) => {
+    return new Promise((resolve, reject) => {
+        if (Array.isArray(changes)){
+            const incidents = [];
+            const errors = [];
+            changes.forEach((change) => {
+                const { oldReservation, newReservation } = change;
+                if (oldReservation && newReservation){
+                    const oldStart = oldReservation.start ? moment.utc(oldReservation.start) : null;
+                    const oldEnd = oldReservation.end ? moment.utc(oldReservation.end) : null;
+
+                    const newStart = newReservation.start ? moment.utc(newReservation.start) : null;
+                    const newEnd = newReservation.end ? moment.utc(newReservation.end) : null;
+
+                    const reservationTimezone = newReservation.timezone ? newReservation.timezone : UI_TIMEZONE;
+                    const reservationHourlyRate = newReservation.hourlyRate ? newReservation.hourlyRate : undefined;
+
+                    if (oldStart && oldEnd && newStart && newEnd && reservationHourlyRate){
+                        const oldReservationLength = oldEnd.diff(oldStart, 'hours', true);
+                        const newReservationLength = newEnd.diff(newStart, 'hours', true);
+
+                        const differenceFromNow = oldStart.diff(moment.utc(), 'hours');
+
+                        if (differenceFromNow && (differenceFromNow < 24)){
+                            // Changed reservation that was within 24hrs from now
+
+                            // Check if new reservation is on same day
+                            const sameDay = oldStart.tz(reservationTimezone).isSame(newStart.tz(reservationTimezone), 'day');
+
+                            const { reservationId, memberId, resourceId, hourlyRate } = newReservation;
+
+                            if (sameDay){
+                                // Reservation moved in same day
+                                // Check if member shortened the reservation
+
+                                if (newReservationLength < oldReservationLength){
+
+                                    const differenceInLength = oldReservationLength - newReservationLength;
+                                    const chargeFee = differenceInLength*hourlyRate*BOOKING_CHANGE_PERCENTAGE_CHARGE/100;
+
+                                    const incident = {
+                                        reservationId,
+                                        memberId,
+                                        resourceId,
+                                        oldBookingStart: oldReservation.start,
+                                        oldBookingEnd: oldReservation.end,
+                                        newBookingStart: newReservation.start,
+                                        newBookingEnd: newReservation.end,
+                                        incidentType: incidentType.BOOKING_SHORTENED,
+                                        chargeFee,
+                                    };
+
+                                    incidents.push(incident);
+                                }
+                            }else{
+                                // Reservation moved to another day
+                                // Add cancellation charge
+                                const chargeFee = oldReservationLength*hourlyRate*BOOKING_CHANGE_PERCENTAGE_CHARGE/100;
+
+                                const incident = {
+                                    reservationId,
+                                    memberId,
+                                    resourceId,
+                                    oldBookingStart: oldReservation.start,
+                                    oldBookingEnd: oldReservation.end,
+                                    newBookingStart: newReservation.start,
+                                    newBookingEnd: newReservation.end,
+                                    incidentType: incidentType.BOOKING_MOVED_TO_ANOTHER_DAY,
+                                    chargeFee,
+                                };
+
+                                incidents.push(incident);
+                            }
+                        }
+                    }else{
+                        errors.push(change);
+                    }
+                }
+            });
+            if (errors.length > 0){
+                console.log('There were some errors with incomplete bookings : ');
+                console.log(errors);
+            }
+            resolve(bulkWriteBookingChangeIncidents(incidents));
+        }else{
+            reject('Input argument is not an array !');
+        }
+    });
+};
+
+module.exports = {
+    chargeBookingChanges,
+};

services/officeRnD/bookings.js

@@ -15,6 +15,10 @@ const fetchAllBookings = () => {
                 const bookingData = result && result.data ? result.data : [];
 
                 bookingData.forEach((fullBookingEntry) => {
+                    const fees = fullBookingEntry && fullBookingEntry.fees ? fullBookingEntry.fees : [];
+                    const firstFee = fees.length > 0 && fees[0].fee ? fees[0].fee : undefined;
+                    const hourlyRate = firstFee && firstFee.price ? firstFee.price : undefined;
+
                     cleanedBookingReservations.push({
                         reservationId: fullBookingEntry['_id'],
                         memberId: fullBookingEntry.member,
@@ -24,6 +28,7 @@ const fetchAllBookings = () => {
                         end: fullBookingEntry.end.dateTime,
                         timezone: fullBookingEntry.timezone,
                         canceled: fullBookingEntry.canceled || false,
+                        hourlyRate,
                     });
                 });
                 resolve(cleanedBookingReservations);
@@ -145,7 +150,19 @@ const getFirstReservationInBlock = (reservation) => {
 };
 
 const writeBookingReservation = (bookingReservation) => {
-    return db.bookingReservation.findOrCreate({where: {...bookingReservation}, defaults: {...bookingReservation}});
+    const { reservationId, memberId, officeId, resourceId, start, end, timezone, canceled, hourlyRate } = bookingReservation;
+    const bookingReservationForDB = {
+        reservationId,
+        memberId,
+        officeId,
+        resourceId,
+        start,
+        end,
+        timezone,
+        canceled,
+        hourlyRate,
+    };
+    return db.bookingReservation.findOrCreate({where: {...bookingReservationForDB}, defaults: {...bookingReservationForDB}});
 };
 
 const bulkWriteReservationsWithChangesTracking = (reservations) => {
@@ -157,28 +174,21 @@ const bulkWriteReservationsWithChangesTracking = (reservations) => {
             const changedKeys = instance.changed();
             const previous = instance.previous();
 
-            const indexOfUpdatedAt = changedKeys.indexOf('updatedAt');
+            const lookupKeys = ['start', 'end'];
 
-            if (indexOfUpdatedAt !== -1){
-                changedKeys.splice(indexOfUpdatedAt, 1);
-            }
-
-            if (changedKeys.length > 0){
-                //check if there is really difference, reservation start and end timestamps are reported as changed but they are not
-
-                let realChange = false;
-                changedKeys.forEach((changedKey) => {
-                    if (JSON.stringify(previous[changedKey]) !== JSON.stringify(instance[changedKey])){
+            let realChange = false;
+            lookupKeys.forEach((key) => {
+                if ((changedKeys.indexOf(key) !== -1) &&
+                    (JSON.stringify(previous[key]) !== JSON.stringify(instance[key]))){
                         realChange = true;
-                    }
-                });
-
-                if (realChange){
-                    changes.push({
-                        oldReservation: previous,
-                        newReservation: instance.get(),
-                    });
                 }
+            });
+
+            if (realChange){
+                changes.push({
+                    oldReservation: previous,
+                    newReservation: instance.get(),
+                });
             }
         });