Merge 64abd19 into 5dc177e

.babelrc

@@ -1,3 +1,4 @@
 {
+  "plugins": ["transform-es2015-destructuring", "transform-object-rest-spread"],
   "presets": [ "es2015" ]
 }

controllers/articles.js

@@ -1,5 +1,4 @@
-import { Article } from '../models';
-
+import { Article, User } from '../models';
 /**
  * @class ArticleController
  * @override
@@ -17,13 +16,20 @@ export default class ArticleController {
   static async createArticle(req, res) {
     const images = req.images || [];
     const {
-      title, description, body, slug
+      title, description, body, slug, categoryId
     } = req.body;
     const taglist = req.body.taglist ? req.body.taglist.split(',') : [];
     const { id } = req.user;
     try {
       const result = await Article.create({
-        title, description, body, slug, images, taglist, userId: id
+        title,
+        description,
+        body,
+        slug,
+        images,
+        taglist,
+        userId: id,
+        categoryId: categoryId || 1
       });
       return res.status(201).json({
         success: true,
@@ -34,4 +40,119 @@ export default class ArticleController {
       return res.status(500).json({ success: false, error: [error.message] });
     }
   }
+
+  /**
+   * @description - Search for articles
+   * @static
+   * @param {Object} req - the request object
+   * @param {Object} res - the response object
+   * @memberof ArticleController
+   * @returns {Object} class instance
+   */
+  static async searchForArticles(req, res) {
+    try {
+      const searchTerms = ArticleController.generateSearchQuery(req.query);
+      const results = await Article.findAll({
+        raw: true,
+        where: {
+          ...searchTerms,
+        },
+        include: [{
+          model: User,
+          attributes: ['username', 'email', 'name', 'bio'],
+          as: 'author'
+        }]
+      });
+      return res.status(200).json({
+        results,
+        success: true
+      });
+    } catch (error) {
+      return res.status(200).json({
+        results: [],
+        success: true,
+        message: 'Oops, no article with your search terms was found.'
+      });
+    }
+  }
+
+  /**
+   * @description - Generate queries for search and filter
+   * @static
+   * @param {Object}  searchTerms - the terms that the user wants to search for
+   * @memberof ArticleController
+   * @returns {Object} class instance
+   */
+  static generateSearchQuery(searchTerms) {
+    const {
+      author, term, endDate, startDate, tags, categoryId
+    } = searchTerms;
+
+    const filterFields = {
+      '$user.username$': {
+        $like: author
+      },
+      createdAt: {
+        $between: [startDate, endDate]
+      },
+      title: {
+        $like: `%${term}%`,
+      },
+      description: {
+        $like: `%${term}%`,
+      },
+      taglist: {
+        $contains: tags ? [...tags.split(',')] : []
+      },
+      categoryId: Number(categoryId),
+    };
+
+    if (!author) {
+      delete filterFields['$user.username$'];
+    }
+    if (!startDate || !endDate) {
+      delete filterFields.createdAt;
+    }
+    if (!categoryId) {
+      delete filterFields.categoryId;
+    }
+    return filterFields;
+  }
+
+  /**
+   * @description - Get article by slug
+   * @static
+   * @param {Object} req - the request object
+   * @param {Object} res - the response object
+   * @memberof ArticleController
+   * @returns {Object} class instance
+   */
+  static async getArticleBySlug(req, res) {
+    try {
+      const {
+        params: {
+          slug
+        }
+      } = req;
+      const article = await Article.findOne({
+        where: {
+          slug
+        },
+        include: [{
+          as: 'author',
+          model: User,
+          attributes: ['username', 'email', 'name', 'bio'],
+        }]
+      });
+      return res.status(200).json({
+        success: true,
+        article: article.dataValues
+      });
+    } catch (error) {
+      return res.status(404).json({
+        success: false,
+        errors: ['Article not found.'],
+      });
+    }
+  }
 }

controllers/category.js

@@ -0,0 +1,47 @@
+import dotenv from 'dotenv';
+import { Category } from '../models';
+
+dotenv.config();
+
+/**
+ * @class CategoryController
+ *  @override
+ * @export
+ */
+export default class CategoryController {
+  /**
+     * @description - Creates a new category
+     * @static
+     * @param {object} req - HTTP Request
+     * @param {object} res - HTTP Response
+     * @memberof CategoryController
+     * @returns {object} Class instance
+     */
+  static async addNew(req, res) {
+    const {
+      body: {
+        category
+      }
+    } = req;
+    try {
+      const returnValue = await Category.create({ categoryName: category });
+      const { dataValues: { categoryName } } = returnValue;
+      return res.status(201).json({
+        success: true,
+        message: 'Category successfully added.',
+        categoryName
+      });
+    } catch (error) {
+      if (error.errors[0].type === 'unique violation') {
+        return res.status(409).json({
+          success: false,
+          errors: [error.errors[0].message]
+        });
+      }
+      return res.status(500).json({
+        success: false,
+        errors: ['Internal server error']
+      });
+    }
+  }
+}

doc.json

@@ -20,7 +20,7 @@
     "http"
   ],
   "paths": {
-    "/user": {
+    "/user/signup": {
       "post": {
         "tags": [
           "Authentication"
@@ -272,6 +272,71 @@
           }
         }
       }
+    },
+    "/articles/search": {
+      "get": {
+        "tags": [
+          "Articles"
+        ],
+        "summary": "Search for an article",
+        "description": "",
+        "operationId": "searchArticle",
+        "consumes": [
+          "application/json"
+        ],
+        "produces": [
+          "application/json"
+        ],
+        "parameters": [
+          {
+            "name": "term",
+            "in": "query",
+            "description": "A string to search for ",
+            "required": true,
+            "type": "string"
+          },
+          {
+            "name": "categoryId",
+            "in": "query",
+            "description": "A categoryId to search from",
+            "required": false,
+            "type": "number"
+          },
+          {
+            "name": "author",
+            "in": "query",
+            "description": "Username or name of an author to search from",
+            "required": false,
+            "type": "string"
+          },
+          {
+            "name": "startDate",
+            "in": "query",
+            "description": "A start date for a date range search",
+            "required": false,
+            "type": "string"
+          },
+          {
+            "name": "endDate",
+            "in": "query",
+            "description": "An end date for a date range search",
+            "required": false,
+            "type": "string"
+          },
+          {
+            "name": "tags",
+            "in": "query",
+            "description": "Tags to search from",
+            "required": false,
+            "type": "string"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Search results were found"
+          }
+        }
+      }
     }
   },
   "definitions": {

middleware/auth.js

@@ -17,14 +17,14 @@ class Auth {
     if (!token) {
       return res.status(401).json({
         success: false,
-        message: 'Unauthorized! You are required to be logged in to perform this operation.',
+        errors: ['Unauthorized! You are required to be logged in to perform this operation.'],
       });
     }
     jwt.verify(token, JWT_SECRET, (err, decoded) => {
       if (err) {
         return res.status(401).json({
           success: false,
-          message: 'Your session has expired, please login again to continue',
+          errors: ['Your session has expired, please login again to continue'],
         });
       }
       req.user = decoded;

middleware/validation.js

@@ -83,3 +83,20 @@ export const validateLogin = [
     .custom(value => !/\s/.test(value))
     .withMessage('Please provide a valid password.'),
 ];
+
+export const validateCategory = [
+  check('category')
+    .exists()
+    .withMessage('No category provided. Please provide a category.')
+    .isLength({ min: 3, max: 30 })
+    .withMessage('Category must be at least 3 characters long and no more than 15.')
+    .isString()
+    .withMessage('Category must be alphanumeric characters, please remove leading and trailing whitespaces.')
+];
+
+
+export const validateSearch = [
+  check('term')
+    .isString()
+    .withMessage('Please provide a valid search term.')
+];

migrations/20190312203553-add-userId.js

@@ -14,4 +14,4 @@ module.exports = {
       'userId'
     );
   },
-};
+};

migrations/20190313193812-create-category.js

@@ -0,0 +1,24 @@
+module.exports = {
+  up: (queryInterface, Sequelize) => queryInterface.createTable('Categories', {
+    id: {
+      allowNull: false,
+      autoIncrement: true,
+      primaryKey: true,
+      type: Sequelize.INTEGER
+    },
+    categoryName: {
+      type: Sequelize.STRING,
+      allowNull: false,
+      unique: true
+    },
+    createdAt: {
+      allowNull: false,
+      type: Sequelize.DATE
+    },
+    updatedAt: {
+      allowNull: false,
+      type: Sequelize.DATE
+    }
+  }),
+  down: queryInterface => queryInterface.dropTable('Categories')
+};

migrations/20190313195119-add_category_Id_to_article.js

@@ -0,0 +1,18 @@
+module.exports = {
+  up: (queryInterface, Sequelize) => queryInterface.addColumn(
+    'Articles',
+    'categoryId',
+    {
+      type: Sequelize.INTEGER,
+      allowNull: true,
+      unique: false
+    }
+  ),
+
+  down(queryInterface) {
+    return queryInterface.removeColumn(
+      'Articles',
+      'categoryId'
+    );
+  },
+};

migrations/20190314104937-insert-default-category.js

@@ -0,0 +1,21 @@
+module.exports = {
+  up: queryInterface => queryInterface.bulkInsert(
+    'Categories',
+    [
+      {
+        categoryName: 'Uncategorized',
+        createdAt: new Date(),
+        updatedAt: new Date()
+      }
+    ]
+  ),
+
+  down: queryInterface => queryInterface.bulkDelete(
+    'Categories',
+    [
+      {
+        categoryName: 'Uncategorized'
+      }
+    ]
+  ),
+};