implement booking reservation change log

cronServices/checkBookingChanges.js

@@ -4,18 +4,26 @@ require('dotenv').config();
 const { fetchAllBookings, bulkWriteReservationsWithChangesTracking } = require('../services/officeRnD/bookings');
 
 const { chargeBookingChanges } = require('../services/integration/bookingChangeCharges');
+const { bulkWriteChanges } = require('../services/integration/bookingChangeLog');
 
 const checkBookingChanges = () => {
     fetchAllBookings()
         .then((reservations) => {
             bulkWriteReservationsWithChangesTracking(reservations)
                 .then((changes) => {
-                    chargeBookingChanges(changes)
+                    bulkWriteChanges(changes)
                         .then(() => {
-                            process.exit();
+                            chargeBookingChanges(changes)
+                                .then(() => {
+                                    process.exit();
+                                })
+                                .catch((error) => {
+                                    console.log('Error creating charges ', error);
+                                    process.exit();
+                                });
                         })
                         .catch((error) => {
-                            console.log('Error creating charges ', error);
+                            console.log('Error bulk write booking reservation change log :', error);
                             process.exit();
                         });
                 })

migrations/20190711071404-add-booking-reservation-change-logs-table.js

@@ -0,0 +1,35 @@
+'use strict';
+
+module.exports = {
+  up: (queryInterface, Sequelize) => {
+    return queryInterface.createTable('bookingReservationChangeLogs', {
+      id: {
+        allowNull: false,
+        autoIncrement: true,
+        primaryKey: true,
+        type: Sequelize.INTEGER
+      },
+      reservationId: Sequelize.TEXT,
+      memberId: Sequelize.TEXT,
+      officeId: Sequelize.TEXT,
+      oldResourceId: Sequelize.TEXT,
+      newResourceId: Sequelize.TEXT,
+      oldStart: Sequelize.DATE,
+      oldEnd: Sequelize.DATE,
+      newStart: Sequelize.DATE,
+      newEnd: Sequelize.DATE,
+      canceled: Sequelize.BOOLEAN,
+      createdAt: {
+        allowNull: false,
+        type: Sequelize.DATE
+      },
+      updatedAt: {
+        allowNull: false,
+        type: Sequelize.DATE
+      }
+    });
+  },
+  down: (queryInterface, Sequelize) => {
+    return queryInterface.dropTable('bookingReservationChangeLogs');
+  }
+};

models/bookingReservationChangeLog.js

@@ -0,0 +1,20 @@
+'use strict';
+
+module.exports = (sequelize, DataTypes) => {
+    const bookingReservationChangeLog = sequelize.define('bookingReservationChangeLog', {
+        reservationId: DataTypes.TEXT,
+        memberId: DataTypes.TEXT,
+        officeId: DataTypes.TEXT,
+        oldResourceId: DataTypes.TEXT,
+        newResourceId: DataTypes.TEXT,
+        oldStart: DataTypes.DATE,
+        oldEnd: DataTypes.DATE,
+        newStart: DataTypes.DATE,
+        newEnd: DataTypes.DATE,
+        canceled: DataTypes.BOOLEAN,
+    }, {});
+    bookingReservationChangeLog.associate = function(models) {
+        // associations can be defined here
+    };
+    return bookingReservationChangeLog;
+};

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(
+            const asyncReservationUpdate = () => {
-                db.bookingReservation.update(reservation, {
+                return new Promise((resolve, reject) => {
-                    where: {
+                    db.bookingReservation.update(reservation, {
-                        reservationId: reservation.reservationId,
+                        where: {
-                    },
+                            reservationId: reservation.reservationId,
-                    returning: true,
+                        },
-                    individualHooks: true,
+                        returning: true,
-                })
+                        individualHooks: true,
-                    .then(([updateCount, updatedInstances]) => {
-                        if (updateCount === 0){
-                            db.bookingReservation.upsert(reservation);
-                        }
                     })
-                    .catch((error) => {
+                        .then(([updateCount, updatedInstances]) => {
-                        console.log('Error updating');
+                            if (updateCount === 0){
-                        console.log(error);
+                                const oldReservation = {
-                        reject(error);
+                                    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)