Merge branch 'dev' into handle_notification

Author: passimm

connect/config.js

@@ -6,7 +6,7 @@ module.exports = {
   TC_API_V3_BASE_URL: process.env.TC_API_V3_BASE_URL || 'https://api.topcoder-dev.com/v3',
   TC_API_V4_BASE_URL: process.env.TC_API_V4_BASE_URL || 'https://api.topcoder-dev.com/v4',
   // eslint-disable-next-line max-len
-  TC_ADMIN_TOKEN: process.env.TC_ADMIN_TOKEN,
+  TC_ADMIN_TOKEN: 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJyb2xlcyI6WyJUb3Bjb2RlciBVc2VyIiwiQ29ubmVjdCBNYW5hZ2VyIiwiQ29ubmVjdCBBZG1pbiJdLCJpc3MiOiJodHRwczovL2FwaS50b3Bjb2Rlci1kZXYuY29tIiwiaGFuZGxlIjoicGF0X21vbmFoYW4iLCJleHAiOjE1MTk4NDIyMzYsInVzZXJJZCI6IjQwMTUyOTMzIiwiaWF0IjoxNTE0MzE4NTA0LCJlbWFpbCI6ImRldm9wcytwYXRfbW9uYWhhbkB0b3Bjb2Rlci5jb20iLCJqdGkiOiIwOThjMGNjOS05OTljLTRlZjktYmM5ZS0yNTExZWJkZmJkMzIifQ.N3rbYMOfniLZ3TV3z08MAD46TwgFUGJ--UYhQVuu1Uw',
 
   // Probably temporary variables for TopCoder role ids for 'Connect Manager', 'Connect Copilot' and 'administrator'
   // These are values for development backend. For production backend they may be different.

connect/connectNotificationServer.js

@@ -22,6 +22,7 @@ const PROJECT_ROLE_OWNER = require('./events-config').PROJECT_ROLE_OWNER;
  * @return {Promise}            resolves to a list of notifications
  */
 const getTopCoderMembersNotifications = (eventConfig) => {
+  // if event doesn't have to be notified to topcoder member, just ignore
   if (!eventConfig.topcoderRoles) {
     return Promise.resolve([]);
   }
@@ -91,8 +92,13 @@ const getNotificationsForMentionedUser = (eventConfig, content) => {
  *
  * @return {Promise}            resolves to a list of notifications
  */
-const getProjectMembersNotifications = (eventConfig, project) => (
-  new Promise((resolve) => {
+const getProjectMembersNotifications = (eventConfig, project) => {
+  // if event doesn't have to be notified to project member, just ignore
+  if (!eventConfig.projectRoles) {
+    return Promise.resolve([]);
+  }
+
+  return new Promise((resolve) => {
     let notifications = [];
     const projectMembers = _.get(project, 'members', []);
 
@@ -128,8 +134,8 @@ const getProjectMembersNotifications = (eventConfig, project) => (
     notifications = _.uniqBy(notifications, 'userId');
 
     resolve(notifications);
-  })
-);
+  });
+};
 
 /**
  * Get notifications for users obtained from userId
@@ -179,12 +185,64 @@ const getNotificationsForTopicStarter = (eventConfig, topicId) => {
     return Promise.reject(new Error('Missing topicId in the event message.'));
   }
 
-  return service.getTopic(topicId).then((topic) => ({
-    userId: topic.userId.toString(),
-    contents: {
-      toTopicStarter: true,
-    },
-  }));
+  return service.getTopic(topicId).then((topic) => {
+    const userId = topic.userId.toString();
+
+    // special case: if topic created by CoderBot, don't send notification to him
+    if (userId === 'CoderBot') {
+      return [];
+    }
+
+    return [{
+      userId,
+      contents: {
+        toTopicStarter: true,
+      },
+    }];
+  });
+};
+
+/**
+ * Exclude notifications using exclude rules of the event config
+ *
+ * @param {Array}  notifications notifications list
+ * @param {Object} eventConfig   event configuration
+ * @param {Object} message       message
+ * @param {Object} data          any additional data which is retrieved once
+ *
+ * @returns {Promise} resolves to the list of filtered notifications
+ */
+const excludeNotifications = (notifications, eventConfig, message, data) => {
+  // if there are no rules to exclude notifications, just return all of them untouched
+  if (!eventConfig.exclude) {
+    return Promise.resolve(notifications);
+  }
+
+  const { project } = data;
+  // create event config using rules to exclude notifications
+  const excludeEventConfig = Object.assign({
+    type: eventConfig.type,
+  }, eventConfig.exclude);
+
+  // get notifications using rules for exclude notifications
+  // and after filter out such notifications from the notifications list
+  // TODO move this promise all together with `_.uniqBy` to one function
+  //      and reuse it here and in `handler` function
+  return Promise.all([
+    getNotificationsForTopicStarter(excludeEventConfig, message.topicId),
+    getNotificationsForUserId(excludeEventConfig, message.userId),
+    getProjectMembersNotifications(excludeEventConfig, project),
+    getTopCoderMembersNotifications(excludeEventConfig),
+  ]).then((notificationsPerSource) => (
+    _.uniqBy(_.flatten(notificationsPerSource), 'userId')
+  )).then((excludedNotifications) => {
+    const excludedUserIds = _.map(excludedNotifications, 'userId');
+    const filteredNotifications = notifications.filter((notification) => (
+      !_.includes(excludedUserIds, notification.userId)
+    ));
+
+    return filteredNotifications;
+  });
 };
 
 // set configuration for the server, see ../config/default.js for available config parameters
@@ -233,12 +291,16 @@ const handler = (topic, message, callback) => {
       // first found notification for one user will be send, the rest ignored
       // NOTE all userId has to be string
       _.uniqBy(_.flatten(notificationsPerSource), 'userId')
+    )).then((notifications) => (
+      excludeNotifications(notifications, eventConfig, message, {
+        project,
+      })
     )).then((notifications) => {
       allNotifications = notifications;
 
       // now let's retrieve some additional data
 
-      // if message has userId such messages will likely need userHandle
+      // if message has userId such messages will likely need userHandle and user full name
       // so let's get it
       if (message.userId) {
         const ids = [message.userId];
@@ -247,10 +309,12 @@ const handler = (topic, message, callback) => {
       return [];
     }).then((users) => {
       _.map(allNotifications, (notification) => {
+        notification.version = eventConfig.version;
         notification.contents.projectName = project.name;
         // if found a user then add user handle
         if (users.length) {
           notification.contents.userHandle = users[0].handle;
+          notification.contents.userFullName = `${users[0].firstName} ${users[0].lastName}`;
         }
       });
       callback(null, allNotifications);

connect/events-config.js

@@ -34,10 +34,14 @@ const TOPCODER_ROLE_RULES = {
  *
  * Each event configuration object has
  *   type           {String}  [mandatory] Event type
+ *   version        {Number}  [optional]  Version of the event.
  *   projectRoles   {Array}   [optional]  List of project member roles which has to get notification
  *   topcoderRoles  {Array}   [optional]  List of TopCoder member roles which has to get notification
  *   toUserHandle   {Boolean} [optional]  If set to true, user defined in `message.userHandle` will get notification
- *   toTopicStarter {Boolean} [optional]  If set to true, than will find who started topic `message.topicId` and send notification to him
+ *   toTopicStarter {Boolean} [optional]  If set to true, than will find who started topic `message.topicId` and
+ *                                        send notification to him
+ *   exclude        {Object}  [optional]  May contains any rules like `projectRoles`, `toUserHandle` etc
+ *                                        but these rules will forbid sending notifications to members who satisfy them
  *
  * @type {Array}
  */
@@ -46,6 +50,9 @@ const EVENTS = [
   {
     type: 'notifications.connect.project.created',
     projectRoles: [PROJECT_ROLE_OWNER],
+    exclude: {
+      topcoderRoles: [ROLE_CONNECT_MANAGER, ROLE_ADMINISTRATOR],
+    },
   }, {
     type: 'notifications.connect.project.submittedForReview',
     projectRoles: [PROJECT_ROLE_OWNER],
@@ -73,13 +80,16 @@ const EVENTS = [
     projectRoles: [PROJECT_ROLE_OWNER, PROJECT_ROLE_COPILOT, PROJECT_ROLE_MANAGER],
   }, {
     type: 'notifications.connect.project.member.left',
+    version: 2,
     projectRoles: [PROJECT_ROLE_MANAGER],
   }, {
     type: 'notifications.connect.project.member.removed',
+    version: 2,
     projectRoles: [PROJECT_ROLE_MANAGER],
     toUserHandle: true,
   }, {
     type: 'notifications.connect.project.member.assignedAsOwner',
+    version: 2,
     projectRoles: [PROJECT_ROLE_COPILOT, PROJECT_ROLE_MANAGER],
     toUserHandle: true,
   }, {
@@ -93,9 +103,11 @@ const EVENTS = [
   // Project activity
   {
     type: 'notifications.connect.project.topic.created',
+    version: 2,
     projectRoles: [PROJECT_ROLE_OWNER, PROJECT_ROLE_COPILOT, PROJECT_ROLE_MANAGER, PROJECT_ROLE_MEMBER],
   }, {
     type: 'notifications.connect.project.post.created',
+    version: 2,
     projectRoles: [PROJECT_ROLE_OWNER, PROJECT_ROLE_COPILOT, PROJECT_ROLE_MANAGER, PROJECT_ROLE_MEMBER],
     toTopicStarter: true,
     toMentionedUsers: true,
@@ -104,12 +116,15 @@ const EVENTS = [
   },
   {
     type: 'notifications.connect.project.linkCreated',
+    version: 2,
     projectRoles: [PROJECT_ROLE_OWNER, PROJECT_ROLE_COPILOT, PROJECT_ROLE_MANAGER, PROJECT_ROLE_MEMBER],
   }, {
     type: 'notifications.connect.project.fileUploaded',
+    version: 2,
     projectRoles: [PROJECT_ROLE_OWNER, PROJECT_ROLE_COPILOT, PROJECT_ROLE_MANAGER, PROJECT_ROLE_MEMBER],
   }, {
     type: 'notifications.connect.project.specificationModified',
+    version: 2,
     projectRoles: [PROJECT_ROLE_OWNER, PROJECT_ROLE_COPILOT, PROJECT_ROLE_MANAGER, PROJECT_ROLE_MEMBER],
   },
 ];

src/app.js

@@ -53,6 +53,7 @@ function startKafkaConsumer(handlers) {
       .then((notifications) => Promise.all(_.map(notifications, (notification) => models.Notification.create({
         userId: notification.userId,
         type: notification.newType | topicName,
+        version: notification.version || null,
         contents: _.extend({}, messageJSON, notification.contents),
         read: false,
       }))))
@@ -110,6 +111,28 @@ function start(handlers) {
     });
   });
 
+  app.use('/notifications/debug', (req, res) => {
+    const options = {
+      from: new Date - 1 * 60 * 60 * 1000,
+      until: new Date,
+      limit: 100000,
+      start: 0,
+      order: 'desc',
+    };
+
+    //
+    // Find items logged between today and yesterday.
+    //
+    logger.query(options, (err, results) => {
+      if (err) {
+        res.status(500).json(err);
+        return;
+      }
+
+      res.status(200).json({ history: results, env: process.env });
+    });
+  });
+
   app.use('/', apiRouter);
 
 

src/models/Notification.js

@@ -16,6 +16,7 @@ module.exports = (sequelize, DataTypes) => sequelize.define('Notification', {
   type: { type: DataTypes.STRING, allowNull: false },
   contents: { type: DataTypes.JSONB, allowNull: false },
   read: { type: DataTypes.BOOLEAN, allowNull: false },
+  version: { type: DataTypes.SMALLINT, allowNull: true },
 }, {});
 
 // sequelize will generate and manage createdAt, updatedAt fields

src/models/index.js

@@ -18,5 +18,5 @@ const NotificationSetting = require('./NotificationSetting')(sequelize, DataType
 module.exports = {
   Notification,
   NotificationSetting,
-  init: () => sequelize.sync({ }),
+  init: () => sequelize.sync({ force: true }),
 };

src/services/NotificationService.js

@@ -87,12 +87,11 @@ function* updateSettings(data, userId) {
  */
 function* listNotifications(query, userId) {
   const settings = yield getSettings(userId);
-  
 
   const filter = { where: {
     userId,
   }, offset: query.offset, limit: query.limit, order: [['createdAt', 'DESC']] };
-  if (_.keys(settings).length>0){
+  if (_.keys(settings).length > 0) {
     // only filter out notifications types which were explicitly set to 'no' - so we return notification by default
     const notificationTypes = _.keys(settings).filter((notificationType) => settings[notificationType].web !== 'no');
     filter.where.type = { $in: notificationTypes };