Merge d2c0acb into 889153c

src/controllers/trip.controller.js

@@ -1,3 +1,5 @@
+/* eslint-disable no-unused-vars */
+/* eslint-disable max-len */
 /* eslint-disable function-paren-newline */
 import TripService from '../services/trip.service';
 import ResponseService from '../services/response.service';
@@ -144,6 +146,84 @@ class TripController {
     ResponseService.setSuccess(200, 'List of all available locations', availableLocations);
     return ResponseService.send(res);
   }
+
+  /**
+*
+*
+* @static
+* @param {req} req
+* @param {res} res
+* @param {next} next
+* @returns {object} This function check multicity Trip Data
+* @memberof TripMiddleware
+*/
+  static async updateMulticityPrevNextTrips(req) {
+    const currentTrip = await TripService.findTripByProperty({
+      id: parseInt(req.params.tripId, 10)
+    });
+    const multicityPrevNextTrips = await TripService.findAllByProperty({
+      requestId: currentTrip.requestId
+    });
+    const previousTripId = currentTrip.id - 1;
+    const nextTripId = currentTrip.id + 1;
+    let previousTrip;
+    let nextTrip;
+    if (previousTripId !== 0) {
+      previousTrip = multicityPrevNextTrips.find(prevTrip => prevTrip.id === currentTrip.id - 1);
+      if (previousTrip && req.body.originId && previousTrip.originId !== req.body.originId) {
+        await TripService.updateTrip(
+          { id: previousTripId },
+          { destinationId: req.body.originId }
+        );
+      }
+    }
+    if (nextTripId !== 0) {
+      nextTrip = multicityPrevNextTrips.find(nexTrip => nexTrip.id === currentTrip.id + 1);
+      if (nextTrip && req.body.destinationId && nextTrip.destinationId !== req.body.destinationId) {
+        await TripService.updateTrip(
+          { id: nextTripId },
+          { originId: req.body.destinationId }
+        );
+      }
+    }
+  }
+
+  /**
+ *
+ *
+ * @static
+ * @param {req} req
+ * @param {res} res
+ * @returns {response} @memberof Trips
+ */
+  static async editOpenTripRequest(req, res) {
+    const tripId = parseInt(req.params.tripId, 10);
+    const currentTrip = await TripService.findTripByProperty({
+      id: parseInt(req.params.tripId, 10)
+    });
+    const currentRequest = await RequestService.findRequestByProperty(
+      {
+        id: currentTrip.requestId
+      }
+    );
+    if (currentRequest.status === 'pending') {
+      if (currentTrip.tripType === 'multi-city') {
+        await TripController.updateMulticityPrevNextTrips(req);
+      }
+      await Promise.all(Object.keys(req.body).map(async (key, index) => {
+        await TripService.updateTrip(
+          { id: tripId },
+          { [key]: (Object.values(req.body)[index]) }
+        );
+      }));
+      const updatedTrip = await TripService.findTripByProperty({ id: tripId });
+      ResponseService.setSuccess(200, 'Trip Updated successfully', updatedTrip);
+      ResponseService.send(res);
+    } else {
+      ResponseService.setError(400, 'Only Pending Trip Request Can Be Updated');
+      ResponseService.send(res);
+    }
+  }
 }
 
 export default TripController;

src/middlewares/trip.middleware.js

@@ -1,12 +1,37 @@
+/* eslint-disable no-trailing-spaces */
+/* eslint-disable no-mixed-operators */
+/* eslint-disable max-len */
+/* eslint-disable no-unused-vars */
 import ResponseService from '../services/response.service';
 import TripService from '../services/trip.service';
-
+import LocationService from '../services/location.service';
 /**
  *
  *
  * @class CommentMiddleware
  */
 class TripMiddleware {
+  /**
+*
+*
+* @static
+* @param {req} req
+* @param {res} res
+* @param {next} next
+* @returns {object} This function check if trip exists
+* @memberof TripMiddleware
+*/
+  static async checkTripExist(req, res, next) {
+    const currentTrip = await TripService.findTripByProperty({
+      id: parseInt(req.params.tripId, 10)
+    });
+    if (!currentTrip) {
+      ResponseService.setError(404, 'Trip Not Found.Try Another tripId');
+      return ResponseService.send(res);
+    }
+    next();
+  }
+
   /**
  *
  *
@@ -25,6 +50,108 @@ class TripMiddleware {
     }
     next();
   }
+
+  /**
+*
+*
+* @static
+* @param {req} req
+* @param {res} res
+* @param {next} next
+* @returns {object} This function check if returnDate is inputted on one-way and multi-city trips
+* @memberof TripMiddleware
+*/
+  static async checkReturnDate(req, res, next) {
+    const currentTrip = await TripService.findTripByProperty({
+      id: parseInt(req.params.tripId, 10)
+    });
+    if ((currentTrip.tripType !== 'return-trip') && (req.body.returnDate)) {
+      ResponseService.setError(400, 'Return Date Only Allowed On return Trip');
+      return ResponseService.send(res);
+    }
+    next();
+  }
+
+  /**
+*
+*
+* @static
+* @param {req} req
+* @param {res} res
+* @param {next} next
+* @returns {object} This function check if origin is not equal due to the upate from sibling trip update
+* @memberof TripMiddleware
+*/
+  static async checkTripOrigin(req, res, next) {
+    const currentTrip = await TripService.findTripByProperty({
+      id: parseInt(req.params.tripId, 10)
+    });
+    const multicityPrevNextTrips = await TripService.findAllByProperty({
+      requestId: currentTrip.requestId
+    });
+    let previousTripOriginId;
+
+    const previousTripId = currentTrip.id - 1;
+    let previousTrip;
+    if (previousTripId !== 0) {
+      previousTrip = multicityPrevNextTrips.find(prevTrip => prevTrip.id === currentTrip.id - 1);
+      if (previousTrip && req.body.originId) {
+        previousTripOriginId = previousTrip.originId;
+        if (previousTripOriginId === req.body.originId) {
+          req.body.originId = currentTrip.originId;
+          const originData = await LocationService.findLocationByProperty({
+            id: req.body.originId
+          });
+          const originName = originData.country;
+          ResponseService.setError(400, `Origin must be different to previous trip origin(${originName})`);
+          ResponseService.send(res);
+        }
+      }
+    }
+    next();
+  }
+
+  /**
+*
+*
+* @static
+* @param {req} req
+* @param {res} res
+* @param {next} next
+* @returns {object} This function check if destination is not equal due to the upate from sibling trip update
+* @memberof TripMiddleware
+*/
+  static async checkTripDestination(req, res, next) {
+    const currentTrip = await TripService.findTripByProperty({
+      id: parseInt(req.params.tripId, 10)
+    });
+    const multicityPrevNextTrips = await TripService.findAllByProperty({
+      requestId: currentTrip.requestId
+    });
+
+    let nextTripDestinationId;
+
+    const nextTripId = currentTrip.id + 1;
+    let nextTrip;
+
+    if (nextTripId !== 0) {
+      nextTrip = multicityPrevNextTrips.find(nexTrip => nexTrip.id === currentTrip.id + 1);
+      if (nextTrip && req.body.destinationId) {
+        nextTripDestinationId = nextTrip.destinationId;
+        if (nextTripDestinationId === req.body.destinationId) {
+          req.body.destinationId = currentTrip.destinationId;
+          // const destId = req.body.destinationId;
+          const destinationData = await LocationService.findLocationByProperty({
+            id: req.body.destinationId
+          });
+          const destinationName = destinationData.country;
+          ResponseService.setError(400, `Destination must be different to next trip Destination(${destinationName})`);
+          ResponseService.send(res);
+        }
+      }
+    }
+    next();
+  }
 }
 
 export default TripMiddleware;

src/routes/trip.route.js

@@ -20,5 +20,13 @@ router.get('/locations', authMiddleware.checkUserLoggedIn, TripController.viewAv
 router.post('/requests/:tripId/comments', authMiddleware.checkUserLoggedIn, UserValidation.validateUserComment, CommentController.addCommentOnTripRequest); // user comment on request trip route
 router.delete('/:tripId/comments/:commentId', authMiddleware.checkUserLoggedIn, UserValidation.validateDeleteTripComment, CommentMiddleware.checkCommentExist, CommentController.deleteComment); // user deletes comment route
 router.get('/request/:tripId/comments', authMiddleware.checkUserLoggedIn, CommentMiddleware.validateViewComment, CommentController.viewCommentPostedOnTripRequest); // user view comment posted on the thread
+router.patch('/:tripId/edit',
+  authMiddleware.checkUserLoggedIn,
+  TripMiddleware.checkTripExist,
+  TripMiddleware.checkOriginDestinationEquality,
+  TripMiddleware.checkReturnDate,
+  TripMiddleware.checkTripOrigin,
+  TripMiddleware.checkTripDestination,
+  TripController.editOpenTripRequest); // Edit open trip request
 
 export default router;

src/services/trip.service.js

@@ -120,6 +120,22 @@ class TripService {
   static createMultiCityTrip(newTrip) {
     return Trip.bulkCreate(newTrip);
   }
+
+  /**
+   *
+   *
+   * @static
+   * @param {item} tripId trip column to be updated
+   * @param {value} newTripInfo to be updated
+   * @returns {updated} @memberof TripService
+   */
+  static updateTrip(tripId, newTripInfo) {
+    return Trip.update(newTripInfo, {
+      where: tripId,
+      individualHooks: true,
+      returning: true
+    });
+  }
 }
 
 

src/tests/accomodation/accommodation.test.js

@@ -197,7 +197,7 @@ describe('Create accommmodation', () => {
       .set('Authorization', travelAdminToken)
       .send({ ...newAccomodation,
         locationId: faker.random.number({ min: 1, max: 9 }),
-        typeId: faker.random.number({ min: 10, max: 15 }), })
+        typeId: faker.random.number({ min: 10000000000, max: 15000000000 }), })
       .end((err, res) => {
         expect(res).to.have.status(404);
         expect(res.body).to.have.property('message');