feat(endpoint): User can rate an accomodation

 - Creates rating model and migration
 - Creates seeders
 - Writes tests
 [finishes #167891606]

Author: femitj

src/controllers/Rating.js

@@ -0,0 +1,77 @@
+import db from '../database/models';
+import Response from '../helpers/Response';
+
+const { Accomodation, Rating } = db;
+
+/** Rating Class */
+class Ratings {
+  /**
+   * @param {req} req
+   * @param {res} res
+   * @returns {object} object
+   */
+  static async create(req, res) {
+    try {
+      const { payload } = req.payload;
+      const { id: userId } = payload;
+
+      const {
+        accomodationId, ratingValue
+      } = req.body;
+
+      const accomodation = await Accomodation.findOne({ where: { id: accomodationId } });
+      if (!accomodation) {
+        const response = new Response(
+          false,
+          404,
+          'This accomodation does not exist'
+        );
+        return res.status(response.code).json(response);
+      }
+
+      const previousRating = await Rating.findOne(
+        {
+          where: { userId, accomodationId }
+        }
+      );
+
+      if (!previousRating) {
+        const ratingDetails = await Rating.create({
+          userId,
+          accomodationId,
+          ratingValue
+        });
+        const response = new Response(
+          true,
+          201,
+          'Thank you for rating this accomodation',
+          { rating: ratingDetails }
+        );
+        return res.status(response.code).json(response);
+      }
+      const ratingDetails = await Rating.update(
+        { ratingValue },
+        {
+          where: { userId, accomodationId },
+          returning: true,
+        }
+      );
+      const response = new Response(
+        true,
+        200,
+        'Thank you for rating this accomodation',
+        { rating: ratingDetails }
+      );
+      return res.status(response.code).json(response);
+    } catch (err) {
+      const response = new Response(
+        false,
+        500,
+        'Server error, Please try again later',
+      );
+      return res.status(response.code).json(response);
+    }
+  }
+}
+
+export default Ratings;

src/database/migrations/20190915143950-create-rating.js

@@ -0,0 +1,48 @@
+module.exports = {
+  up: (queryInterface, Sequelize) => {
+    return queryInterface.createTable('Ratings', {
+      id: {
+        allowNull: false,
+        primaryKey: true,
+        type: Sequelize.UUID,
+        defaultValue: Sequelize.literal('uuid_generate_v4()')
+      },
+      userId: {
+        type: Sequelize.UUID,
+        allowNull: false,
+        references: {
+          model: 'Users',
+          key: 'id'
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE'
+      },
+      accomodationId: {
+        type: Sequelize.UUID,
+        allowNull: false,
+        references: {
+          model: 'Accomodations',
+          key: 'id'
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE'
+      },
+      ratingValue: {
+        type: Sequelize.INTEGER,
+        allowNull: true,
+        defaultValue: null
+      },
+      createdAt: {
+        allowNull: false,
+        type: Sequelize.DATE,
+        defaultValue: Sequelize.fn('now')
+      },
+      updatedAt: {
+        allowNull: false,
+        type: Sequelize.DATE,
+        defaultValue: Sequelize.fn('now')
+      }
+    });
+  },
+  down: queryInterface => queryInterface.dropTable('Ratings')
+};

src/database/models/rating.js

@@ -0,0 +1,24 @@
+module.exports = (sequelize, DataTypes) => {
+  const Rating = sequelize.define('Rating', {
+    userId: DataTypes.UUID,
+    accomodationId: DataTypes.UUID,
+    ratingValue: DataTypes.INTEGER,
+  },
+  {
+    indexes: [
+      {
+        unique: true,
+        fields: ['userId', 'accomodationId'],
+      },
+    ],
+  });
+  Rating.associate = (models) => {
+    Rating.belongsTo(models.Accomodation, {
+      foreignKey: 'accomodationId',
+    });
+    Rating.belongsTo(models.User, {
+      foreignKey: 'userId',
+    });
+  };
+  return Rating;
+};

src/database/seeders/20190915144553-Ratings.js

@@ -0,0 +1,10 @@
+module.exports = {
+  up: (queryInterface) => queryInterface.bulkInsert('Ratings', [
+    {
+      userId: '91542e6f-94bc-4e80-a667-586fb0752f23',
+      accomodationId: '3dd3b34a-7554-425e-a688-36afda199619',
+      ratingValue: 3
+    }
+  ]),
+  down: queryInterface => queryInterface.bulkDelete('Ratings', null, {})
+};

src/routes/index.js

@@ -8,6 +8,7 @@ import searchRoute from './search.routes';
 import accomodationRoutes from './accomodation.routes';
 import commentRoute from './comment.routes';
 import notificationOptRoute from './notificationOpt.routes';
+import ratingRoute from './rating.routes';
 
 const router = Router();
 
@@ -21,5 +22,6 @@ router.use('/admin/accomodation', accomodationRoutes);
 router.use('/user/accomodation', accomodationRoutes);
 router.use('/trips', commentRoute);
 router.use('/', adminRoute);
+router.use('/accomodation', ratingRoute);
 
 export default router;

src/routes/rating.routes.js

@@ -0,0 +1,18 @@
+import { Router } from 'express';
+import Ratings from '../controllers/Rating';
+import ratingSchema from '../validation/ratingSchema';
+import validator from '../middlewares/validator';
+import middleware from '../middlewares/AuthMiddlewares';
+import tokenHelper from '../helpers/Token';
+
+const ratingRoute = Router();
+
+ratingRoute.post(
+  '/ratings',
+  tokenHelper.verifyToken,
+  middleware.isUserVerified,
+  validator(ratingSchema),
+  Ratings.create
+);
+
+export default ratingRoute;

src/validation/ratingSchema.js

@@ -0,0 +1,21 @@
+import { check } from 'express-validator';
+
+const rating = [
+  check('accomodationId')
+    .exists().withMessage('Accomodation Id is required')
+    .isUUID(4)
+    .withMessage('Invalid Accomodation Id format'),
+
+  check('ratingValue')
+    .exists().withMessage('Rating is required')
+    .isInt()
+    .withMessage('Ratings should be a number between 0 to 5')
+    .custom((value, { req }) => {
+      if (value > 5) {
+        throw new Error('Ratings should be between the number 0 to 5');
+      }
+      return true;
+    })
+];
+
+export default rating;

test/mockData/mockRatings.js

@@ -0,0 +1,32 @@
+const accomodationRatings = [
+  {
+    accomodationId: '3dd3b34a-7554-425e-a688-36afda199615',
+    ratingValue: 2
+  },
+  {
+    accomodationId: '3dd3b34a-7554-425e-a688-36afda199619',
+    ratingValue: 5
+  },
+  {
+    accomodationId: '3dd3b34a-7554-425e-a688-36afda199617',
+    ratingValue: 2
+  },
+  {
+    ratingValue: 2
+  },
+  {
+    accomodationId: '3dd3b34a-7554-425e-a688-36afda199619'
+  },
+  {
+    accomodationId: '3dd3b34a-7554-425e-a688-36afda199619',
+    ratingValue: 7
+  }
+];
+
+const userOne = {
+  email: 'tjhakeemus1@gmail.com',
+  password: '12345678',
+  code: '4RHJHJJKSK'
+};
+
+export default { accomodationRatings, userOne };

test/ratings.test.js

@@ -0,0 +1,126 @@
+import chai from 'chai';
+import chaiHttp from 'chai-http';
+import sinon from 'sinon';
+import app from '../src/index';
+import db from '../src/database/models';
+import users from './mockData/mockAuth';
+import ratings from './mockData/mockRatings';
+
+const { expect } = chai;
+chai.use(chaiHttp);
+
+const baseURL = '/api/v1';
+
+const { Rating } = db;
+const { user10 } = users;
+const { accomodationRatings, userOne } = ratings;
+
+let validToken;
+
+// check successful post
+describe('Ratings', () => {
+  describe('Users post a request to rate an accomodation', () => {
+    it('should return a valid token', (done) => {
+      chai
+        .request(app)
+        .post(`${baseURL}/auth/login`)
+        .send(user10)
+        .end((err, res) => {
+          const { user } = res.body.data;
+          // eslint-disable-next-line prefer-destructuring
+          validToken = user.token;
+          done();
+        });
+    });
+    it('should succesfully update if previous rating is found for an accomodation', (done) => {
+      chai
+        .request(app)
+        .post(`${baseURL}/accomodation/ratings`)
+        .send(accomodationRatings[1])
+        .set('authorization', validToken)
+        .end((err, res) => {
+          expect(res).to.have.status(200);
+          expect(res.body.message).to.eq('Thank you for rating this accomodation');
+          done();
+        });
+    });
+    it('should succesfully rate an accomodation', (done) => {
+      chai
+        .request(app)
+        .post(`${baseURL}/accomodation/ratings`)
+        .send(accomodationRatings[0])
+        .set('authorization', validToken)
+        .end((err, res) => {
+          expect(res).to.have.status(201);
+          done();
+        });
+    });
+    it('should return an error if accomodation does not exist', (done) => {
+      chai
+        .request(app)
+        .post(`${baseURL}/accomodation/ratings`)
+        .send(accomodationRatings[2])
+        .set('authorization', validToken)
+        .end((err, res) => {
+          expect(res).to.have.status(404);
+          expect(res.body).to.be.an('object');
+          done(err);
+        });
+    });
+    it('should return an error if accomodation Id is not supplied', (done) => {
+      chai
+        .request(app)
+        .post(`${baseURL}/accomodation/ratings`)
+        .send(accomodationRatings[3])
+        .set('authorization', validToken)
+        .end((err, res) => {
+          expect(res).to.have.status(400);
+          expect(res.body).to.be.an('object');
+          expect(res.body.message).to.eql('Validation Error!');
+          expect(res.body.data.accomodationId).to.eql('Accomodation Id is required');
+          done(err);
+        });
+    });
+    it('should return an error if rating value is not supplied', (done) => {
+      chai
+        .request(app)
+        .post(`${baseURL}/accomodation/ratings`)
+        .send(accomodationRatings[4])
+        .set('authorization', validToken)
+        .end((err, res) => {
+          expect(res).to.have.status(400);
+          expect(res.body).to.be.an('object');
+          expect(res.body.message).to.eql('Validation Error!');
+          expect(res.body.data.ratingValue).to.eql('Rating is required');
+          done(err);
+        });
+    });
+    it('should return an error if rating is greater than 5', (done) => {
+      chai
+        .request(app)
+        .post(`${baseURL}/accomodation/ratings`)
+        .send(accomodationRatings[5])
+        .set('authorization', validToken)
+        .end((err, res) => {
+          expect(res).to.have.status(400);
+          expect(res.body).to.be.an('object');
+          expect(res.body.message).to.eql('Validation Error!');
+          expect(res.body.data.ratingValue).to.eql('Ratings should be between the number 0 to 5');
+          done(err);
+        });
+    });
+    it('should return a 500 error when an error occurs on the server', (done) => {
+      const stub = sinon.stub(Rating, 'update')
+        .rejects(new Error('Server error, Please try again later'));
+      chai.request(app)
+        .post(`${baseURL}/accomodation/ratings`)
+        .send(accomodationRatings[0])
+        .set('authorization', validToken)
+        .end((err, res) => {
+          expect(res.status).to.equal(500);
+          stub.restore();
+          done();
+        });
+    });
+  });
+});