Merge dcaa248 into 67c9ddf

package.json

@@ -62,6 +62,7 @@
         "passport-google-oauth20": "^2.0.0",
         "pg": "^7.11.0",
         "pg-hstore": "^2.3.3",
+        "pusher": "^2.2.1",
         "sequelize": "^5.8.12",
         "sequelize-cli": "^5.5.0",
         "sinon-chai": "^3.3.0",

src/controllers/notification.controller.js

@@ -0,0 +1,124 @@
+import BaseRepository from '../repository/base.repository';
+import responseGenerator from '../helpers/responseGenerator';
+import db from '../database/models';
+
+const { User, Notification } = db;
+
+/**
+ * @class NotificationController
+ */
+class NotificationController {
+  /**
+   * Get all notifications
+   * @async
+   * @param {Object} req - Object of the HTTP request
+   * @param {Object} res - Object of the HTTP response
+   * @returns {json} Returns json Object
+   * @static
+   */
+  static async getNotifications(req, res) {
+    const { id: recieverId } = req.currentUser;
+    try {
+      const notification = await BaseRepository.findAll(Notification, {
+        recieverId
+      });
+
+      if (notification.length > 0) {
+        return responseGenerator.sendSuccess(res, 200, notification);
+      }
+
+      return responseGenerator.sendError(res, 404, 'You have no notifications');
+    } catch (error) {
+      return responseGenerator.sendError(res, 500, error.message);
+    }
+  }
+
+  /**
+   * Mark if the notification was read
+   * @async
+   * @param {Object} req - Object of the HTTP request
+   * @param {Object} res - Object of the HTTP response
+   * @returns {json} Returns json Object
+   * @static
+   */
+  static async readNotification(req, res) {
+    const read = true;
+    const { notificationId } = req.params;
+    const { id: receiverId } = req.currentUser;
+    try {
+      const notification = await BaseRepository.findOneByField(Notification, {
+        id: notificationId,
+        receiverId
+      });
+
+      if (notification) {
+        const notificationRead = notification.read;
+        if (notificationRead === true) {
+          return responseGenerator.sendError(
+            res,
+            200,
+            'Notification has been read'
+          );
+        }
+        const markRead = await BaseRepository.update(
+          Notification,
+          { read },
+          { id: notificationId, receiverId }
+        );
+
+        if (markRead) {
+          return responseGenerator.sendError(
+            res,
+            200,
+            'Notification has been marked as read'
+          );
+        }
+      }
+      return responseGenerator.sendError(
+        res,
+        404,
+        'Notification does not exist'
+      );
+    } catch (error) {
+      return responseGenerator.sendError(res, 500, error.message);
+    }
+  }
+
+  /**
+   * Mark if the notification was read
+   * @async
+   * @param {Object} req - Object of the HTTP request
+   * @param {Object} res - Object of the HTTP response
+   * @returns {json} Returns json Object
+   * @static
+   */
+  static async toggleNotification(req, res) {
+    const { emailNotify } = req.body;
+    const { id } = req.currentUser;
+    try {
+      const emailNotification = await BaseRepository.update(
+        User,
+        { emailNotify },
+        { id }
+      );
+
+      if (emailNotification && emailNotify) {
+        return responseGenerator.sendError(
+          res,
+          200,
+          'Email notifications has been enabled'
+        );
+      }
+
+      return responseGenerator.sendError(
+        res,
+        200,
+        'Email notifications has been disabled'
+      );
+    } catch (error) {
+      return responseGenerator.sendError(res, 500, error.message);
+    }
+  }
+}
+
+export default NotificationController;

src/controllers/user.controller.js

@@ -4,9 +4,10 @@ import utility from '../helpers/utils';
 import db from '../database/models';
 import Pagination from '../helpers/pagination';
 import mailer from '../helpers/mailer';
+import NotificationHelper from '../helpers/notifications';
 
 const { jwtSigner, verifyPassword } = utility;
-
+const { onFollowNotification } = NotificationHelper;
 /**
  * @class UserController
  */
@@ -289,6 +290,8 @@ class UserController {
       const [user, created] = followedUser;
 
       if (created) {
+        await onFollowNotification({ followerId, followeeId });
+
         return responseGenerator.sendSuccess(
           res,
           200,

src/database/migrations/20190702165504-create-user.js

@@ -41,6 +41,10 @@ module.exports = {
         values: ['unverified', 'active', 'inactive'],
         defaultValue: 'unverified'
       },
+      emailNotify: {
+        type: Sequelize.BOOLEAN,
+        defaultValue: false
+      },
       createdAt: {
         allowNull: false,
         defaultValue: new Date(),

src/database/migrations/20190717203358-create-notification.js

@@ -0,0 +1,38 @@
+module.exports = {
+  up: (queryInterface, Sequelize) => {
+    return queryInterface.createTable('Notifications', {
+      id: {
+        allowNull: false,
+        autoIncrement: true,
+        primaryKey: true,
+        type: Sequelize.INTEGER
+      },
+      message: {
+        type: Sequelize.TEXT
+      },
+      read: {
+        type: Sequelize.BOOLEAN,
+        defaultValue: false
+      },
+      receiverId: {
+        type: Sequelize.INTEGER
+      },
+      link: {
+        type: Sequelize.STRING
+      },
+      createdAt: {
+        allowNull: false,
+        defaultValue: new Date(),
+        type: Sequelize.DATE
+      },
+      updatedAt: {
+        allowNull: false,
+        defaultValue: new Date(),
+        type: Sequelize.DATE
+      }
+    });
+  },
+  down: (queryInterface /* , Sequelize */) => {
+    return queryInterface.dropTable('Notifications');
+  }
+};

src/database/models/article.js

@@ -25,13 +25,13 @@ export default (sequelize, DataTypes) => {
     },
     {}
   );
+
   Article.associate = models => {
     Article.belongsTo(models.User, {
-      through: 'Articles',
-      foreignKey: 'authorId'
+      foreignKey: 'authorId',
+      as: 'author'
     });
-  };
-  Article.associate = models => {
+
     Article.belongsToMany(models.User, {
       through: 'Bookmarks',
       foreignKey: 'articleId',

src/database/models/follower.js

@@ -35,8 +35,6 @@ module.exports = (sequelize, DataTypes) => {
       foreignKey: 'followerId',
       as: 'follower'
     });
-  };
-  Follower.associate = models => {
     Follower.belongsTo(models.User, {
       foreignKey: 'followeeId',
       as: 'followee'

src/database/models/notification.js

@@ -0,0 +1,32 @@
+module.exports = (sequelize, DataTypes) => {
+  const Notification = sequelize.define(
+    'Notification',
+    {
+      message: DataTypes.TEXT,
+      read: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: false
+      },
+      receiverId: DataTypes.INTEGER,
+      link: DataTypes.STRING,
+      createdAt: {
+        allowNull: false,
+        defaultValue: new Date(),
+        type: DataTypes.DATE
+      },
+      updatedAt: {
+        allowNull: false,
+        defaultValue: new Date(),
+        type: DataTypes.DATE
+      }
+    },
+    {}
+  );
+  Notification.associate = models => {
+    Notification.belongsTo(models.User, {
+      as: 'notifications',
+      foreignKey: 'receiverId'
+    });
+  };
+  return Notification;
+};

src/database/models/user.js

@@ -22,6 +22,10 @@ module.exports = (sequelize, DataTypes) => {
         type: DataTypes.ENUM,
         values: ['unverified', 'active', 'inactive']
       },
+      emailNotify: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: false
+      },
       createdAt: {
         allowNull: false,
         defaultValue: new Date(),
@@ -50,25 +54,36 @@ module.exports = (sequelize, DataTypes) => {
       as: 'follower',
       foreignKey: 'followerId'
     });
-  };
-  User.associate = models => {
     User.belongsToMany(models.User, {
       through: 'Followers',
       as: 'followee',
       foreignKey: 'followeeId'
     });
-
+  };
+  User.associate = models => {
     User.hasMany(models.Rating, {
       foreignKey: 'userId',
       as: 'rating'
     });
   };
+
   User.associate = models => {
+    User.hasMany(models.Article, {
+      foreignKey: 'authorId',
+      as: 'article'
+    });
     User.belongsToMany(models.Article, {
       through: 'Bookmarks',
       foreignKey: 'userId',
       as: 'articleId'
     });
   };
+
+  User.associate = models => {
+    User.hasMany(models.Notification, {
+      as: 'notifications',
+      foreignKey: 'receiverId'
+    });
+  };
   return User;
 };