implement booking reservation change log

services/integration/bookingChangeCharges.js

@@ -24,7 +24,6 @@ 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){
@@ -97,14 +96,10 @@ const chargeBookingChanges = (changes) => {
                             }
                         }
                     }else{
-                        errors.push(change);
+                        // New reservation or canceled, not an incident
                     }
                 }
             });
-            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 !');

services/integration/bookingChangeLog.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const db = require('../../models/index');
+
+const bulkWriteChanges = ((changes) => {
+    const changeLogsForDB = [];
+
+    changes.forEach((change) => {
+        const { oldReservation, newReservation } = change;
+        const { reservationId, memberId, officeId, resourceId, start, end, canceled } = newReservation;
+
+        const logEntry = {
+            reservationId: oldReservation.reservationId || reservationId,
+            memberId: oldReservation.memberId || memberId,
+            officeId: oldReservation.officeId || officeId,
+            oldResourceId: oldReservation.resourceId || resourceId,
+            newResourceId: resourceId,
+            oldStart: oldReservation.start || start,
+            newStart: start,
+            oldEnd: oldReservation.end || end,
+            newEnd: end,
+            canceled,
+        };
+
+        if (!oldReservation.start && !oldReservation.end && !oldReservation.resourceId){
+            // new reservation
+            logEntry.oldResourceId = null;
+            logEntry.oldStart = null;
+            logEntry.oldEnd = null;
+        }
+
+        if (newReservation.canceled){
+            logEntry.newResourceId = null;
+            logEntry.newStart = null;
+            logEntry.newEnd = null;
+        }
+
+        changeLogsForDB.push(logEntry);
+    });
+
+    return db.bookingReservationChangeLog.bulkCreate(changeLogsForDB);
+    // console.log(changeLogsForDB);
+    // return new Promise((resolve) => resolve());
+});
+
+module.exports = {
+    bulkWriteChanges,
+};

services/officeRnD/bookings.js

@@ -174,7 +174,7 @@ const bulkWriteReservationsWithChangesTracking = (reservations) => {
             const changedKeys = instance.changed();
             const previous = instance.previous();
 
-            const lookupKeys = ['start', 'end', 'resourceId'];
+            const lookupKeys = ['start', 'end', 'resourceId', 'canceled'];
 
             let realChange = false;
             lookupKeys.forEach((key) => {
@@ -193,25 +193,41 @@ const bulkWriteReservationsWithChangesTracking = (reservations) => {
         });
 
         reservations.forEach((reservation) => {
-            asyncJobs.push(
-                db.bookingReservation.update(reservation, {
-                    where: {
-                        reservationId: reservation.reservationId,
-                    },
-                    returning: true,
-                    individualHooks: true,
-                })
-                    .then(([updateCount, updatedInstances]) => {
-                        if (updateCount === 0){
-                            db.bookingReservation.upsert(reservation);
-                        }
+            const asyncReservationUpdate = () => {
+                return new Promise((resolve, reject) => {
+                    db.bookingReservation.update(reservation, {
+                        where: {
+                            reservationId: reservation.reservationId,
+                        },
+                        returning: true,
+                        individualHooks: true,
                     })
-                    .catch((error) => {
-                        console.log('Error updating');
-                        console.log(error);
-                        reject(error);
-                    })
-            );
+                        .then(([updateCount, updatedInstances]) => {
+                            if (updateCount === 0){
+                                const oldReservation = {
+                                    start: null,
+                                    end: null,
+                                    resourceId: null,
+                                };
+
+                                changes.push({
+                                    oldReservation,
+                                    newReservation: reservation,
+                                });
+                                resolve(db.bookingReservation.upsert(reservation));
+                            }else{
+                                resolve();
+                            }
+                        })
+                        .catch((error) => {
+                            console.log('Error updating');
+                            console.log(error);
+                            reject(error);
+                        })
+                });
+            };
+
+            asyncJobs.push(asyncReservationUpdate());
         });
 
         Promise.all(asyncJobs)