feat(pagination): Delivers Pagination on articles

- Write unit tests
- Modify the Tags and Article relationship
- Add queryHelper.js file
- Add seeds to article seeding file
- Add paginationValidation in ArticleValidation.js
- Add getAllArticles method in ArticleController.js
- Add getUserArticles method in ArticleController.js
- Add getSingleArticle method in ArticleController.js
- Add sendPaginationResponse in ArticleController
- Test endpoints with POSTMAN

[Delivers #159204728]

server/controllers/ArticleController.js

@@ -1,8 +1,14 @@
 import models from '../models';
 import randomString from '../helpers/randomString';
 import dashReplace from '../helpers/replaceDash';
+import queryHelper from '../helpers/queryHelper';
 
 const { Article } = models;
+const error = {
+  message: 'Request can not be processed at the moment, please try again shortly,',
+  status: 400,
+};
+
 /**
  * This class contains all the methods responsible for creating and querying
  * articles on the app
@@ -161,4 +167,113 @@ export default class ArticleController {
         error: 'Article can not be deleted'
       }));
   }
+
+  /**
+   * Gets a list of paginated articles
+   *
+   * @param {Object} req The HTTP request object
+   * @param {Object} res The HTTP response object
+   * @param {Object} next The next middleware to be called
+   */
+  static getAllArticles(req, res, next) {
+    const limit = req.query.limit || 100;
+    const offset = req.query.offset || 0;
+    Article.findAll(
+      Object.assign({}, queryHelper.allArticles, { offset, limit })
+    ).then((articles) => {
+      ArticleController.sendPaginationResponse(res, articles, false);
+    })
+      .catch(() => next(error));
+  }
+
+  /**
+   * Gets a list of paginated articles belonging to the user
+   * in the url route parameter
+   *
+   * @param {Object} req The HTTP request object
+   * @param {Object} res The HTTP response object
+   * @param {Object} next The next middleware to be called
+   */
+  static getUserArticles(req, res, next) {
+    const limit = req.query.limit || 100;
+    const offset = req.query.offset || 0;
+    let { userId } = req.params;
+    if (!/[0-9]/.test(userId)) {
+      return res.status(400).json({
+        status: 'fail',
+        errors: { userId: ['userId must be a number.'] }
+      });
+    }
+    userId = Number.parseInt(userId, 10);
+    Article.findAll(
+      Object.assign({}, queryHelper.allArticles, { where: { userId }, offset, limit }),
+    ).then((articles) => {
+      ArticleController.sendPaginationResponse(res, articles, userId);
+    })
+      .catch(() => next(error));
+  }
+
+  /**
+  * Gets a single article with the slug specified
+  * in the url route parameter
+  *
+  * @param {Object} req The HTTP request object
+  * @param {Object} res The HTTP response object
+  * @param {Object} next The next middleware to be called
+  */
+  static getSingleArticle(req, res, next) {
+    const { slug } = req.params;
+    Article.findOne(
+      Object.assign({}, queryHelper.allArticles, { where: { slug } }),
+    ).then((article) => {
+      if (article) {
+        return res.status(200).json({
+          status: 'success',
+          article,
+        });
+      }
+      return res.status(404).json({
+        status: 'fail',
+        errors: {
+          article: [`Article with slug: ${slug} not found.`],
+        },
+      });
+    })
+      .catch(() => next(error));
+  }
+
+  /**
+   * Sends the response to the user when a list of paginated articles are requested
+   * For a given user or random articles
+   *
+   * @param {Object} res The HTTP response object
+   * @param {Object} articles A list of articles returned
+   * @param {String} userId The userId of the user whose articles are requested
+   * @returns {Object} The response object returned to the user
+   */
+  static sendPaginationResponse(res, articles, userId) {
+    // Returns a 20 when a list of articles are requested and found
+    if (articles[0]) {
+      return res.status(200).json({
+        status: 'success',
+        articles,
+      });
+    }
+    // Returns a 404 when a list of user articles are requested but not found
+    if (userId) {
+      return res.status(404).json({
+        status: 'fail',
+        errors: {
+          articles: [`Articles not found for user with userId: ${userId}.`],
+        },
+      });
+    }
+    // Returns a 404 when a list of articles are requested but not found
+    return res.status(404).json({
+      status: 'fail',
+      errors: {
+        articles: ['No articles found.'],
+      },
+    });
+  }
 }

server/helpers/queryHelper.js

@@ -0,0 +1,21 @@
+import models from '../models';
+
+const {
+  User, Rating, Tag,
+} = models;
+
+/*
+* Holds the query helper object which contains the various query templates
+*/
+export default {
+  allArticles: {
+    order: [
+      ['createdAt', 'DESC']
+    ],
+    attributes: ['id', 'slug', 'userId', 'categoryId', 'title', 'body', 'imageUrl', 'createdAt', 'updatedAt'],
+    include: [
+      { model: User, attributes: ['username', 'firstName', 'lastName', 'bio', 'image'] },
+      { model: Tag, as: 'tags', attributes: ['id', 'articleId', 'title', 'createdAt', 'updatedAt'] },
+    ],
+  },
+};

server/middlewares/validations/ArticleValidation.js

@@ -61,4 +61,28 @@ export default class ArticleValidation {
       });
     });
   }
+
+  /**
+   * Validates the offset and limit parameters in the
+   * url query
+   * @param {Object} req The HTTP request object
+   * @param {Object} res The HTTP response object
+   * @param {Object} next The next middleware on the route
+   */
+  static paginationValidation(req, res, next) {
+    const queryProperties = {
+      offset: 'integer|min:0',
+      limit: 'integer|min:0'
+    };
+
+    const validator = new Validator(req.query, queryProperties);
+    validator.passes(() => next());
+    validator.fails(() => {
+      const errors = validator.errors.all();
+      return res.status(400).json({
+        status: 'error',
+        errors,
+      });
+    });
+  }
 }

server/migrations/20180806205551-create-article.js

@@ -1,3 +1,4 @@
+
 module.exports = {
   up: (queryInterface, Sequelize) => queryInterface.createTable('Articles', {
     id: {

server/models/article.js

@@ -40,7 +40,7 @@ export default (sequelize, DataTypes) => {
       onUpdate: 'CASCADE',
     });
     Article.hasMany(models.Tag, {
-      foreignKey: 'tagId',
+      foreignKey: 'articleId',
       as: 'tags'
     });
     Article.hasMany(models.Rating, {

server/models/rating.js

@@ -1,12 +1,11 @@
-
 export default (sequelize, DataTypes) => {
   const Rating = sequelize.define('Rating', {
     userId: {
       type: DataTypes.INTEGER,
       allowNull: false
     },
-    articleSlug: {
-      type: DataTypes.TEXT,
+    articleId: {
+      type: DataTypes.INTEGER,
       allowNull: false
     },
     value: {

server/routes/article.js

@@ -26,5 +26,8 @@ articleRouter.delete('/:slug/comments/:id', isLoggedIn, CommentController.delete
 
 articleRouter.post('/:author/:slug/:rating', isLoggedIn, RatingController.rateArticle);
 
+articleRouter.get('/', ArticleValidation.paginationValidation, ArticleController.getAllArticles);
+
+articleRouter.get('/:slug', ArticleController.getSingleArticle);
 
 export default articleRouter;

server/routes/users.js

@@ -2,6 +2,8 @@ import { Router } from 'express';
 import PasswordResetController from '../controllers/PasswordResetController';
 import UserValidation from '../middlewares/validations/UserValidation';
 import checkToken from '../middlewares/checkToken';
+import ArticleValidation from '../middlewares/validations/ArticleValidation';
+import ArticleController from '../controllers/ArticleController';
 
 const userRouter = Router();
 
@@ -22,4 +24,10 @@ userRouter.put(
   PasswordResetController.updateUserPassword
 );
 
+userRouter.get(
+  '/:userId/articles',
+  ArticleValidation.paginationValidation,
+  ArticleController.getUserArticles
+);
+
 export default userRouter;

server/seeders/20180808181558-demo-Article.js

@@ -64,6 +64,46 @@ module.exports = {
       createdAt: '2018-08-01 21:54:49',
       updatedAt: '2018-08-04 21:54:49'
     },
+    {
+      title: 'Unmissable steps before, during, and after user research',
+      slug: 'unmissable-steps-before-74U33U38N3IHF1',
+      userId: 1,
+      categoryId: 2,
+      body: 'As a UX designer, I’m expected to run research studies to mine meaningful insights for my products. I often conduct usability studies to get a pulse of what users think, need or expect from a new product. I was fortunate to work on consumer-facing as well as enterprise products, as a result of which, I gained a diverse experience relevant to conducting user studies in industrial settings. While the commercial products gave us the liberty to find and interview users in person, the enterprise products on the other hand make it difficult to find or access the right users, resulting in remote usability studies.',
+      imageUrl: 'https://cloudinary/ah/images/miss.jpg',
+      createdAt: 'NOW()',
+      updatedAt: 'NOW()'
+    },
+    {
+      title: 'Unmissable steps before, during, and after user research',
+      slug: 'unmissable-steps-before-74U33U38N3IHF2',
+      userId: 1,
+      categoryId: 1,
+      body: 'As a UX designer, I’m expected to run research studies to mine meaningful insights for my products. I often conduct usability studies to get a pulse of what users think, need or expect from a new product. I was fortunate to work on consumer-facing as well as enterprise products, as a result of which, I gained a diverse experience relevant to conducting user studies in industrial settings. While the commercial products gave us the liberty to find and interview users in person, the enterprise products on the other hand make it difficult to find or access the right users, resulting in remote usability studies.',
+      imageUrl: 'https://cloudinary/ah/images/miss.jpg',
+      createdAt: 'NOW()',
+      updatedAt: 'NOW()'
+    },
+    {
+      title: 'Unmissable steps before, during, and after user research',
+      slug: 'unmissable-steps-before-74U33U38N3IHF3',
+      userId: 1,
+      categoryId: 1,
+      body: 'As a UX designer, I’m expected to run research studies to mine meaningful insights for my products. I often conduct usability studies to get a pulse of what users think, need or expect from a new product. I was fortunate to work on consumer-facing as well as enterprise products, as a result of which, I gained a diverse experience relevant to conducting user studies in industrial settings. While the commercial products gave us the liberty to find and interview users in person, the enterprise products on the other hand make it difficult to find or access the right users, resulting in remote usability studies.',
+      imageUrl: 'https://cloudinary/ah/images/miss.jpg',
+      createdAt: 'NOW()',
+      updatedAt: 'NOW()'
+    },
+    {
+      title: 'Unmissable steps before, during, and after user research',
+      slug: 'unmissable-steps-before-74U33U38N3IHF4',
+      userId: 1,
+      categoryId: 1,
+      body: 'As a UX designer, I’m expected to run research studies to mine meaningful insights for my products. I often conduct usability studies to get a pulse of what users think, need or expect from a new product. I was fortunate to work on consumer-facing as well as enterprise products, as a result of which, I gained a diverse experience relevant to conducting user studies in industrial settings. While the commercial products gave us the liberty to find and interview users in person, the enterprise products on the other hand make it difficult to find or access the right users, resulting in remote usability studies.',
+      imageUrl: 'https://cloudinary/ah/images/miss.jpg',
+      createdAt: 'NOW()',
+      updatedAt: 'NOW()'
+    },
   ]),
   down: () => {
   }