edit open trip request feature (#83)

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,67 @@ class TripController {
     ResponseService.setSuccess(200, 'List of all available locations', availableLocations);
     return ResponseService.send(res);
   }
+
+  /**
+*
+*
+* @static
+* @param {currentTrip} currentTrip
+* @param {id} id
+* @param {origin} origin
+* @param {destination} destination
+* @returns {object} This function updates origin(s) and destination(s)
+* @memberof TripController
+*/
+  static async updateOriginOrDestination(currentTrip, id, origin, destination) {
+    const sameTripRequestMulticityTrips = await TripService.findAllByProperty({
+      requestId: currentTrip.requestId
+    });
+    const previousTrip = sameTripRequestMulticityTrips.find(prevTrip => prevTrip.id === currentTrip.id - 1);
+    if (previousTrip && origin && previousTrip.originId !== origin) {
+      await TripService.updateTrip(
+        { id: currentTrip.id - 1 },
+        { destinationId: origin }
+      );
+    }
+    const nextTrip = sameTripRequestMulticityTrips.find(nexTrip => nexTrip.id === currentTrip.id + 1);
+    if (nextTrip && destination && nextTrip.destinationId !== destination) {
+      await TripService.updateTrip(
+        { id: currentTrip.id + 1 },
+        { originId: destination }
+      );
+    }
+  }
+
+  /**
+ *
+ *
+ * @static
+ * @param {req} req
+ * @param {res} res
+ * @returns {response} @memberof TripController
+ */
+  static async updateOpenTripRequest(req, res) {
+    const tripId = parseInt(req.params.tripId, 10);
+    const currentTrip = req.currentTrip;
+    if (currentTrip.tripType === 'multi-city') {
+      await TripController.updateOriginOrDestination(
+        req.currentTrip,
+        tripId,
+        req.body.originId,
+        req.body.destinationId
+      );
+    }
+    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);
+  }
 }
 
 export default TripController;

src/middlewares/trip.middleware.js

@@ -1,12 +1,38 @@
+/* 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';
+import RequestService from '../services/request.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 +51,135 @@ 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 returnDate is inputted on one-way and multi-city trips
+* @memberof TripMiddleware
+*/
+  static async checkRequestStatus(req, res, next) {
+    const currentTrip = await TripService.findTripByProperty({
+      id: parseInt(req.params.tripId, 10)
+    });
+    const currentRequest = await RequestService.findRequestByProperty(
+      {
+        id: currentTrip.requestId
+      }
+    );
+    if (currentRequest.status !== 'pending') {
+      ResponseService.setError(400, 'Only Pending Trip Request Can Be Updated');
+      ResponseService.send(res);
+    }
+    req.currentTrip = currentTrip;
+    req.currentRequest = currentRequest;
+    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: previousTripOriginId
+          });
+          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 destinationData = await LocationService.findLocationByProperty({
+            id: nextTripDestinationId
+          });
+          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,14 @@ 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,
+  TripMiddleware.checkRequestStatus,
+  TripController.updateOpenTripRequest);
 
 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');