Merge 44a401a into bf789fb

.gitignore

@@ -40,3 +40,5 @@ node_modules
 
 # package-lock.json file
 package-lock.json
+
+.vscode

mail.config.js

@@ -116,4 +116,4 @@ module.exports = {
   ethereal: {
     driver: 'ethereal'
   }
-}
+};

src/controllers/article.controller.js

@@ -13,7 +13,8 @@ import {
   updateArticleService,
   deleteArticleService,
   articleRatingsService,
-  fetchRatingsService
+  fetchRatingsService,
+  likeCommentService
 } from '../services/article.service';
 
 import Helper from '../services/helper';
@@ -381,7 +382,36 @@ export default {
     if (result === `Article with id: ${articleId} does not exist`) {
       return Helper.failResponse(response, 404, result);
     }
-
     return Helper.successResponse(response, 200, result);
+  },
+
+  /**
+   * @method likeComment
+   * @description handles the logic to like a comment
+   * Route: POST: /articles/ratings
+   * @param {object} request containing the user request metadata
+   * @param {object} response contains the response to the question
+   *
+   * @returns {object} contains the appropriate response
+   */
+
+  async likeComment(request, response) {
+    const { id } = request.user;
+    const { slug, commentId } = request.params;
+
+    const result = await likeCommentService(slug, commentId, id);
+
+    if (result === `The article with the specified slug does not exist`) {
+      return Helper.failResponse(response, 404, {
+        message: result
+      });
+    }
+
+    if (result === `The comment with the specified id does not exist`) {
+      return Helper.failResponse(response, 404, {
+        message: result
+      });
+    }
+    if (result) return Helper.successResponse(response, 200, result);
   }
 };

src/db/migrations/20190712173952-create-comment-reaction.js

@@ -0,0 +1,45 @@
+module.exports = {
+  up: (queryInterface, Sequelize) => {
+    return queryInterface.createTable('CommentReactions', {
+      id: {
+        allowNull: false,
+        autoIncrement: true,
+        primaryKey: true,
+        type: Sequelize.INTEGER
+      },
+      userId: {
+        type: Sequelize.INTEGER,
+        allowNull: {
+          args: false,
+          references: {
+            models: 'Users',
+            key: 'id',
+            as: 'liker'
+          }
+        }
+      },
+      commentId: {
+        type: Sequelize.INTEGER,
+        allowNull: {
+          args: false,
+          references: {
+            models: 'Comments',
+            key: 'id',
+            as: 'liked'
+          }
+        }
+      },
+      createdAt: {
+        allowNull: false,
+        type: Sequelize.DATE
+      },
+      updatedAt: {
+        allowNull: false,
+        type: Sequelize.DATE
+      }
+    });
+  },
+  down: queryInterface => {
+    return queryInterface.dropTable('CommentReactions');
+  }
+};

src/db/models/article.js

@@ -89,15 +89,6 @@ export default (sequelize, DataTypes) => {
     suffixSource: ['hash']
   });
 
-  Article.associate = models => {
-    // associations can be defined here
-    Article.belongsTo(models.User, {
-      foreignKey: 'userId',
-      as: 'author',
-      onDelete: 'CASCADE'
-    });
-  };
-
   Article.associate = models => {
     // associations can be defined here
     Article.belongsTo(models.User, {

src/db/models/comment.js

@@ -34,7 +34,7 @@ export default (sequelize, DataTypes) => {
       slug: {
         type: DataTypes.STRING,
         allowNull: false,
-        unique: true
+        unique: false
       },
       highlightedText: {
         type: DataTypes.TEXT,

src/db/models/commentReaction.js

@@ -0,0 +1,39 @@
+module.exports = (sequelize, DataTypes) => {
+  const CommentReaction = sequelize.define('CommentReaction', {
+    userId: {
+      type: DataTypes.INTEGER,
+      allowNull: {
+        args: false,
+        references: {
+          model: 'Users',
+          key: 'id',
+          as: 'liker'
+        }
+      }
+    },
+    commentId: {
+      type: DataTypes.INTEGER,
+      allowNull: {
+        args: false,
+        references: {
+          model: 'Comments',
+          key: 'id',
+          as: 'liked'
+        }
+      }
+    }
+  });
+  CommentReaction.associate = models => {
+    // associations can be defined here
+    CommentReaction.belongsTo(models.User, {
+      foreignKey: 'userId',
+      as: 'liker'
+    });
+
+    CommentReaction.belongsTo(models.Comment, {
+      foreignKey: 'commentId',
+      as: 'liked'
+    });
+  };
+  return CommentReaction;
+};

src/db/models/rating.js

@@ -24,7 +24,7 @@ module.exports = (sequelize, DataTypes) => {
     },
     rating: {
       type: DataTypes.INTEGER,
-      allowNull: { args: false }
+      allowNull: false
     }
   });
   Rating.associate = models => {

src/routes/v1/article.route.js

@@ -9,6 +9,7 @@ import commentsCheck from '../../middlewares/commentsCheck.middleware';
 import reportController from '../../controllers/report.controller';
 
 const { validator, checkValidationResult } = articleValidator;
+const { verifyToken, adminCheck } = authorization;
 
 const {
   validator: paginationValidator,
@@ -28,15 +29,14 @@ const {
   userGetAllPublishedArticles,
   unPublishArticle,
   getUserPublishedArticles,
-  userGetAllDraftArticles
+  userGetAllDraftArticles,
+  likeComment
 } = articleController;
 
 const { getCommentHistory, editComment, getSingleComment } = commentController;
 
 const { editCommentCheck, getArticlesCommentsCheck } = commentsCheck;
 
-const { verifyToken, adminCheck } = authorization;
-
 const { createReport, removeArticle } = reportController;
 
 const router = express.Router();
@@ -72,7 +72,7 @@ router
   .delete('/:slug', verifyToken, deleteArticle)
   .post(
     '/ratings',
-    authorization.verifyToken,
+    verifyToken,
     validator('rating'),
     checkValidationResult,
     articleController.ratings
@@ -87,7 +87,7 @@ router
   )
   .get(
     '/:articleId/ratings',
-    authorization.verifyToken,
+    verifyToken,
     validator('fetchRating'),
     checkValidationResult,
     articleController.fetchRatings
@@ -105,6 +105,13 @@ router
     adminCheck,
     checkValidationResult,
     removeArticle
+  )
+  .get(
+    '/:slug/comments/:commentId/reactions',
+    verifyToken,
+    validator('commentLike'),
+    checkValidationResult,
+    likeComment
   );
 
 router.get(

src/services/article.service.js

@@ -1,11 +1,10 @@
-import fs from 'fs';
 import moment from 'moment';
 import { upload } from '../helpers/image.helper';
 import model from '../db/models';
 import Helper from './helper';
 import { paginationQueryMetadata, pageMetadata } from '../helpers/pagination';
 
-const { Comment, Article, User, Follow, Rating } = model;
+const { Comment, Article, User, Follow, Rating, CommentReaction } = model;
 /** Istanbul ignore next */
 /**
  * @method createArticleService
@@ -558,6 +557,81 @@ export const articleRatingsService = async (articleId, rating, userId) => {
   }
 };
 
+export const getCommentLikesCount = async commentId => {
+  const likeCount = await CommentReaction.findAndCountAll({
+    where: { commentId }
+  });
+
+  return likeCount.count;
+};
+/**
+ * @method likeCommentService
+ *  - helps populate the reaction table with comment liked
+ *
+ * @param {string} slug - the comment that is liked
+ * @param {integer} commentId - the comment that is liked
+ * @param {integer} userId - the person that reacted to this comment
+ * @param {string} reaction - the reaction value -like or dislike
+ */
+
+export const likeCommentService = async (slug, commentId, userId) => {
+  try {
+    const articleExist = await Article.findOne({ where: { slug } });
+
+    const commentExist = await Comment.findByPk(commentId);
+
+    if (!articleExist) {
+      return `The article with the specified slug does not exist`;
+    }
+
+    if (!commentExist) {
+      return 'The comment with the specified id does not exist';
+    }
+
+    const findReaction = await CommentReaction.findOne({
+      where: {
+        userId,
+        commentId
+      }
+    });
+
+    if (!findReaction) {
+      await CommentReaction.create({
+        userId,
+        commentId
+      });
+
+      const likeCount = await getCommentLikesCount(commentId);
+
+      const result = {
+        likeCount,
+        message: 'you have successfully liked this comment',
+        commentId,
+        userId
+      };
+      return result;
+    }
+    await CommentReaction.destroy({
+      where: {
+        userId,
+        commentId
+      }
+    });
+
+    const likeCount = await getCommentLikesCount(commentId);
+
+    const result = {
+      likeCount,
+      message: 'you have successfully unliked this comment',
+      commentId,
+      userId
+    };
+    return result;
+  } catch (error) {
+    return error.message;
+  }
+};
+
 /**
  * @method fetchRatingsService
  * - helps fetch all ratings on an article

src/services/comment.service.js

@@ -1,5 +1,6 @@
 import moment from 'moment';
 import model from '../db/models';
+import { getCommentLikesCount } from './article.service';
 
 const { Comment, Article, User } = model;
 
@@ -55,6 +56,8 @@ export const getSingleArticleComment = async (id, slug) => {
 
   if (!commentRecord) return false;
 
+  const likeCount = await getCommentLikesCount(id);
+
   const { body } = commentRecord.get({ plain: true });
   const latestTimestamp = Object.keys(body)[Object.keys(body).length - 1];
   const latestComment = body[latestTimestamp];
@@ -63,6 +66,7 @@ export const getSingleArticleComment = async (id, slug) => {
     createdAt: latestTimestamp,
     updatedAt: commentRecord.updatedAt,
     body: latestComment,
+    likeCount,
     author: {
       username: commentRecord.userComment.userName,
       bio: commentRecord.userComment.bio,