Merge pull request #19 from topcoder-platform/dev

Production release

Author: gondzo

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([]);
   }
@@ -51,6 +52,49 @@ const getTopCoderMembersNotifications = (eventConfig) => {
   });
 };
 
+/**
+ * Get notifications for mentioned users
+ *
+ * @param  {Object} eventConfig event configuration
+ * @param  {Object} message content
+ *
+ * @return {Promise}            resolves to a list of notifications
+ */
+const getNotificationsForMentionedUser = (eventConfig, content) => {
+  if (!eventConfig.toMentionedUsers) {
+    return Promise.resolve([]);
+  }
+
+  let notifications = [];
+  const regexUserHandle = /title=\"@([a-zA-Z0-9-_.{}\[\]]+)\"/g;
+  let handles=[];
+  let matches = regexUserHandle.exec(content); 
+  console.log(content)
+  while (matches) {
+    let handle = matches[1].toString();
+    notifications.push({
+      userHandle: handle,
+      newType: 'notifications.connect.project.post.mention',
+      contents: {
+        toUserHandle: true,
+      },
+    });
+    matches = regexUserHandle.exec(content);
+    handles.push(handle);
+  }
+  // only one per userHandle
+  notifications = _.uniqBy(notifications, 'userHandle');
+
+  return new Promise((resolve)=>{
+    service.getUsersByHandle(handles).then((users)=>{
+      _.map(notifications,(notification)=>{
+        notification.userId = _.find(users,{handle:notification.userHandle}).userId;
+      });
+      resolve(notifications);
+    })
+  });
+};
+
 /**
  * Get project members notifications
  *
@@ -59,8 +103,13 @@ const getTopCoderMembersNotifications = (eventConfig) => {
  *
  * @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', []);
 
@@ -96,8 +145,8 @@ const getProjectMembersNotifications = (eventConfig, project) => (
     notifications = _.uniqBy(notifications, 'userId');
 
     resolve(notifications);
-  })
-);
+  });
+};
 
 /**
  * Get notifications for users obtained from userId
@@ -147,12 +196,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
@@ -194,18 +295,23 @@ const handler = (topic, message, callback) => {
       //       - check that event has everything required or throw error
       getNotificationsForTopicStarter(eventConfig, message.topicId),
       getNotificationsForUserId(eventConfig, message.userId),
+      message.postContent ? getNotificationsForMentionedUser(eventConfig, message.postContent) : Promise.resolve([]),
       getProjectMembersNotifications(eventConfig, project),
       getTopCoderMembersNotifications(eventConfig),
     ]).then((notificationsPerSource) => (
       // 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;
+      allNotifications = _.filter(notifications,notification=>notification.userId!=message.initiatorUserId);
 
       // 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];
@@ -214,10 +320,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,20 +103,28 @@ 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,
+  }, {
+    type: 'notifications.connect.project.post.mention',
   },
   {
     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],
   },
 ];

connect/service.js

@@ -89,6 +89,36 @@ const getUsersById = (ids) => {
     });
 };
 
+/**
+ * Get users details by ids
+ *
+ * @param  {Array} ids list of user ids
+ *
+ * @return {Promise}   resolves to the list of user details
+ */
+const getUsersByHandle = (handles) => {
+  const query = _.map(handles, (handle) => 'handle:' + handle).join(' OR ');
+  return request
+    .get(`${config.TC_API_V3_BASE_URL}/members/_search?fields=userId,handle,firstName,lastName&query=${query}`)
+    .set('accept', 'application/json')
+    .set('authorization', `Bearer ${config.TC_ADMIN_TOKEN}`)
+    .then((res) => {
+      if (!_.get(res, 'body.result.success')) {
+        throw new Error(`Failed to get users by handle: ${handles}`);
+      }
+
+      const users = _.get(res, 'body.result.content');
+
+      return users;
+    }).catch((err) => {
+      const errorDetails = _.get(err, 'response.body.result.content.message');
+      throw new Error(
+        `Failed to get users by handles: ${handles}.` +
+        (errorDetails ? ' Server response: ' + errorDetails : '')
+      );
+    });
+};
+
 /**
  * Get topic details
  *
@@ -119,5 +149,6 @@ module.exports = {
   getProject,
   getRoleMembers,
   getUsersById,
+  getUsersByHandle,
   getTopic,
 };

migrations/v1.1.sql

@@ -0,0 +1,6 @@
+-- Column: public."Notifications".version
+
+-- ALTER TABLE public."Notifications" DROP COLUMN version;
+
+ALTER TABLE public."Notifications"
+    ADD COLUMN version smallint;

src/app.js

@@ -52,7 +52,8 @@ function startKafkaConsumer(handlers) {
       // save notifications
       .then((notifications) => Promise.all(_.map(notifications, (notification) => models.Notification.create({
         userId: notification.userId,
-        type: topicName,
+        type: notification.newType || topicName,
+        version: notification.version || null,
         contents: _.extend({}, messageJSON, notification.contents),
         read: false,
       }))))

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(),
 };

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 };