Merge pull request #62 from andela/Bug/167919006/fix-for-get-follower…

…s-following

167919006 Bug Fix to get followers and following by username of a user

controllers/membership/index.js

@@ -10,50 +10,51 @@ export default {
 
     if (followId === id) {
       return res.status(400).send({
-        error: 'you can\'t follow yourself'
+        error: "you can't follow yourself",
       });
     }
 
     try {
       const userExist = await db.User.findOne({
-        where: { id: followId }
+        where: { id: followId },
       });
 
       if (!userExist) {
         return res.status(404).send({
-          error: 'user not found'
+          error: 'user not found',
         });
       }
       const following = await db.MemberShip.findOne({
         where: {
           followerId,
-          followId
-        }
+          followId,
+        },
       });
       if (following) {
         // unfollow user
         await following.destroy();
         return res.status(200).send({
-          message: 'unfollow successful'
+          message: 'unfollow successful',
         });
       }
       const result = await db.MemberShip.create({
         followerId,
-        followId
+        followId,
       });
 
-      await Notification.followNotification({
+      Notification.followNotification({
         userId: followerId,
-        followedUserId: followId
+        followedUserId: followId,
       });
 
       return res.status(200).send({
-        user: result
+        user: result,
+        message: 'Follow successful',
       });
     } catch (e) {
       /* istanbul ignore next */
       return res.status(500).send({
-        error: 'something went wrong'
+        error: 'something went wrong',
       });
     }
   },
@@ -75,5 +76,100 @@ export default {
     return res.status(200).send({
       user,
     });
-  }
+  },
+
+  getFollowingByUsername: async (req, res) => {
+    const { id } = req.user;
+    const { username } = req.params;
+    const include = id
+      ? [
+        {
+          model: db.MemberShip,
+          as: 'followers',
+          where: { followerId: id },
+          required: false,
+        },
+      ]
+      : [];
+
+    const user = await db.User.findOne({
+      where: {
+        username,
+      },
+      attributes: ['id', 'username', 'email', 'firstName', 'lastName', 'image'],
+      include: [
+        {
+          model: db.MemberShip,
+          as: 'following',
+          include: [
+            {
+              model: db.User,
+              as: 'followed',
+              include,
+              attributes: [
+                'id',
+                'username',
+                'email',
+                'firstName',
+                'lastName',
+                'image',
+              ],
+            },
+          ],
+        },
+      ],
+    });
+
+    return res.status(200).send({
+      user,
+    });
+  },
+
+  getFollowersByUsername: async (req, res) => {
+    const { id } = req.user;
+    const { username } = req.params;
+
+    const include = id
+      ? [
+        {
+          model: db.MemberShip,
+          as: 'followers',
+          where: { followerId: id },
+          required: false,
+        },
+      ]
+      : [];
+
+    const user = await db.User.findOne({
+      where: {
+        username,
+      },
+      attributes: ['id', 'username', 'email', 'firstName', 'lastName', 'image'],
+      include: [
+        {
+          model: db.MemberShip,
+          as: 'followers',
+          include: [
+            {
+              model: db.User,
+              as: 'follower',
+              include,
+              attributes: [
+                'id',
+                'username',
+                'email',
+                'firstName',
+                'lastName',
+                'image',
+              ],
+            },
+          ],
+        },
+      ],
+    });
+
+    return res.status(200).send({
+      user,
+    });
+  },
 };

controllers/profiles/index.js

@@ -2,9 +2,28 @@ import db from '../../db/models';
 
 export default {
   getProfile: async (req, res) => {
+    const { userId } = req.query;
+    let isFollowed = null;
+    const include = userId ? [
+      {
+        model: db.MemberShip,
+        as: 'followers',
+        where: { followerId: userId },
+        required: false,
+      }
+    ] : [];
     try {
       const user = await db.User.findOne({
         where: { username: req.params.username },
+        attributes: ['id',
+          'username',
+          'email',
+          'firstName',
+          'lastName',
+          'image',
+          'bio',
+        ],
+        include
       });
 
       if (!user) {
@@ -13,6 +32,10 @@ export default {
         });
       }
 
+      if (userId) {
+        isFollowed = (user.dataValues.followers.length > 0);
+      }
+
       const followingNo = await db.MemberShip.count({
         where: { followerId: user.id },
       });
@@ -21,13 +44,13 @@ export default {
         where: { followId: user.id },
       });
 
-      const data = user.response(false);
       return res.status(200).json({
         user: {
-          ...data,
+          ...user.dataValues,
+          isFollowed,
           followersNo,
           followingNo,
-        },
+        }
       });
     } catch (e) {
       /* istanbul ignore next */

controllers/users/index.js

@@ -89,7 +89,7 @@ export default {
           where: { username: req.body.username }
         });
         if (foundUser) {
-          if (foundUser !== req.user) {
+          if (foundUser.id !== req.user.id) {
             return res.status(400).json({
               message: 'Username already exist'
             });

routes/v1/members.js

@@ -2,11 +2,14 @@ import express from 'express';
 import Members from '../../controllers/membership';
 import Middleware from '../../middlewares';
 import Validation from '../../validators/membership';
+import { decodeUser } from '../../utils';
 
 const router = express.Router();
 
 router.post('/', Middleware.authenticate, Middleware.isblackListedToken, Validation.follow, Members.createFollowing);
 router.get('/following', Middleware.authenticate, Middleware.isblackListedToken, Members.getFollowing);
 router.get('/followers', Middleware.authenticate, Middleware.isblackListedToken, Members.getFollowers);
+router.get('/:username/following', decodeUser, Members.getFollowingByUsername);
+router.get('/:username/followers', decodeUser, Members.getFollowersByUsername);
 
 export default router;

utils/index.js

@@ -175,3 +175,22 @@ export const storeRating = async (foundArticleId) => {
     rating: parseFloat(articleAvg).toFixed(2),
   });
 };
+
+export const decodeUser = async (req, res, next) => {
+  const token = req.headers['x-access-token'];
+
+  try {
+    const decodedToken = decodeToken(token);
+
+    const { email } = decodedToken;
+
+    const user = await db.User.findOne({
+      where: { email },
+    });
+
+    req.user = user;
+  } catch (error) {
+    req.user = null;
+  }
+  next();
+};