Supporting Release For Connect 2.4.12

.circleci/config.yml

@@ -102,7 +102,7 @@ workflows:
           context : org-global
           filters:
             branches:
-              only: [dev, 'feature/general-purpose-notifications-usage']
+              only: [dev, 'hotfix/V5-API-Standards']
       - "build-prod":
           context : org-global
           filters:

config/default.js

@@ -32,6 +32,7 @@ module.exports = {
   TC_API_V4_BASE_URL: process.env.TC_API_V4_BASE_URL || '',
   TC_API_V5_BASE_URL: process.env.TC_API_V5_BASE_URL || '',
   API_CONTEXT_PATH: process.env.API_CONTEXT_PATH || '/v5/notifications',
+  TC_API_BASE_URL: process.env.TC_API_BASE_URL || '',
 
   // Configuration for generating machine to machine auth0 token.
   // The token will be used for calling another internal API.
@@ -45,56 +46,57 @@ module.exports = {
   AUTH0_PROXY_SERVER_URL: process.env.AUTH0_PROXY_SERVER_URL,
 
   KAFKA_CONSUMER_RULESETS: {
-    // key is Kafka topic name, value is array of ruleset which have key as handler function name defined in src/processors/index.js
+    // key is Kafka topic name, value is array of ruleset which have key as
+    // handler function name defined in src/processors/index.js
     'challenge.notification.events': [
       {
         handleChallenge: /** topic handler name */
         {
           type: 'UPDATE_DRAFT_CHALLENGE',
-          roles: ["Submitter" /** Competitor */, "Copilot", "Reviewer"],
+          roles: ['Submitter' /** Competitor */, 'Copilot', 'Reviewer'],
           notification:
           {
             id: 0, /** challengeid or projectid  */
             name: '', /** challenge name */
             group: 'Challenge',
-            title: 'Challenge specification is modified.'
-          }
-        }
-      }
+            title: 'Challenge specification is modified.',
+          },
+        },
+      },
     ],
     'notifications.autopilot.events': [
       {
         handleAutoPilot:
         {
           phaseTypeName: 'Checkpoint Screening',
           state: 'START',
-          roles: ["Copilot", "Reviewer"],
+          roles: ['Copilot', 'Reviewer'],
           notification:
           {
             id: 0, /** challengeid or projectid  */
             name: '', /** challenge name */
             group: 'Challenge',
-            title: 'Challenge checkpoint review.'
-          }
-        }
-      }
+            title: 'Challenge checkpoint review.',
+          },
+        },
+      },
     ],
     'submission.notification.create': [
       {
         handleSubmission:
         {
           resource: 'submission',
-          roles: ["Copilot", "Reviewer"],
+          roles: ['Copilot', 'Reviewer'],
           selfOnly: true /** Submitter only */,
           notification:
           {
             id: 0, /** challengeid or projectid  */
             name: '', /** challenge name */
             group: 'Submission',
-            title: 'A new submission is uploaded.'
-          }
-        }
-      }
+            title: 'A new submission is uploaded.',
+          },
+        },
+      },
     ],
     //'notifications.community.challenge.created': ['handleChallengeCreated'],
     //'notifications.community.challenge.phasewarning': ['handleChallengePhaseWarning'],

connect/connectNotificationServer.js

@@ -9,6 +9,7 @@ const config = require('./config');
 const notificationServer = require('../index');
 const _ = require('lodash');
 const service = require('./service');
+const helpers = require('./helpers');
 const { BUS_API_EVENT } = require('./constants');
 const EVENTS = require('./events-config').EVENTS;
 const PROJECT_ROLE_RULES = require('./events-config').PROJECT_ROLE_RULES;
@@ -85,27 +86,28 @@ const getNotificationsForMentionedUser = (logger, eventConfig, content) => {
   // only one per userHandle
   notifications = _.uniqBy(notifications, 'userHandle');
 
-  return new Promise((resolve, reject) => { // eslint-disable-line no-unused-vars
-    const handles = _.map(notifications, 'userHandle');
-    if (handles.length > 0) {
-      service.getUsersByHandle(handles).then((users) => {
-        _.forEach(notifications, (notification) => {
-          const mentionedUser = _.find(users, { handle: notification.userHandle });
-          notification.userId = mentionedUser ? mentionedUser.userId.toString() : notification.userHandle;
-        });
-        resolve(notifications);
-      }).catch((error) => {
-        if (logger) {
-          logger.error(error);
-          logger.info('Unable to send notification to mentioned user')
+  const handles = _.map(notifications, 'userHandle');
+  if (handles.length > 0) {
+    return service.getUsersByHandle(handles).then((users) => {
+      _.forEach(notifications, (notification) => {
+        const mentionedUser = _.find(users, { handle: notification.userHandle });
+        notification.userId = mentionedUser ? mentionedUser.userId.toString() : null;
+        if (!notification.userId && logger) {// such notifications would be discarded later after aggregation
+          logger.info(`Unable to find user with handle ${notification.userHandle}`);
         }
-        //resolves with empty notification which essentially means we are unable to send notification to mentioned user
-        resolve([]);
       });
-    } else {
-      resolve([]);
-    }
-  });
+      return Promise.resolve(notifications);
+    }).catch((error) => {
+      if (logger) {
+        logger.error(error);
+        logger.info('Unable to send notification to mentioned user');
+      }
+      //resolves with empty notification which essentially means we are unable to send notification to mentioned user
+      return Promise.resolve([]);
+    });
+  } else {
+    return Promise.resolve([]);
+  }
 };
 
 /**
@@ -150,7 +152,7 @@ const getProjectMembersNotifications = (eventConfig, project) => {
     return Promise.resolve([]);
   }
 
-  return new Promise((resolve) => {
+  return Promise.promisify((callback) => {
     let notifications = [];
     const projectMembers = _.get(project, 'members', []);
 
@@ -185,8 +187,8 @@ const getProjectMembersNotifications = (eventConfig, project) => {
     // only one per userId
     notifications = _.uniqBy(notifications, 'userId');
 
-    resolve(notifications);
-  });
+    callback(null, notifications);
+  })();
 };
 
 /**
@@ -254,6 +256,83 @@ const getNotificationsForTopicStarter = (eventConfig, topicId) => {
   });
 };
 
+/**
+ * Filter members by project roles
+ *
+ * @params {Array} List of project roles
+ * @params {Array} List of project members
+ *
+ * @returns {Array} List of objects with user ids
+ */
+const filterMembersByRoles = (roles, members) => {
+  let result = [];
+
+  roles.forEach(projectRole => {
+    result = result.concat(
+      _.filter(members, PROJECT_ROLE_RULES[projectRole])
+        .map(projectMember => ({
+          userId: projectMember.userId.toString(),
+        }))
+    );
+  });
+
+  return result;
+};
+
+/**
+ * Exclude private posts notification
+ *
+ * @param  {Object} eventConfig event configuration
+ * @param  {Object} project     project details
+ * @param  {Array}  tags        list of message tags
+ *
+ * @return {Promise}            resolves to a list of notifications
+ */
+const getExcludedPrivatePostNotifications = (eventConfig, project, tags) => {
+  // skip if message is not private or exclusion rule is not configured
+  if (!_.includes(tags, 'MESSAGES') || !eventConfig.privatePostsForProjectRoles) {
+    return Promise.resolve([]);
+  }
+
+  const members = _.get(project, 'members', []);
+  const notifications = filterMembersByRoles(eventConfig.privatePostsForProjectRoles, members);
+
+  return Promise.resolve(notifications);
+};
+
+/**
+ * Exclude notifications about posts inside draft phases
+ *
+ * @param  {Object} eventConfig event configuration
+ * @param  {Object} project     project details
+ * @param  {Array}  tags        list of message tags
+ *
+ * @return {Promise}            resolves to a list of notifications
+ */
+const getExcludeDraftPhasesNotifications = (eventConfig, project, tags) => {
+  // skip is no exclusion rule is configured
+  if (!eventConfig.draftPhasesForProjectRoles) {
+    return Promise.resolve([]);
+  }
+
+  const phaseId = helpers.extractPhaseId(tags);
+  // skip if it is not phase notification
+  if (!phaseId) {
+    return Promise.resolve([]);
+  }
+
+  // exclude all user with configured roles if phase is in draft state
+  return service.getPhase(project.id, phaseId)
+    .then((phase) => {
+      if (phase.status === 'draft') {
+        const members = _.get(project, 'members', []);
+        const notifications = filterMembersByRoles(eventConfig.draftPhasesForProjectRoles, members);
+
+        return Promise.resolve(notifications);
+      }
+    });
+};
+
 /**
  * Exclude notifications using exclude rules of the event config
  *
@@ -281,12 +360,17 @@ const excludeNotifications = (logger, notifications, eventConfig, message, data)
   // 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
+  const tags = _.get(message, 'tags', []);
+
   return Promise.all([
     getNotificationsForTopicStarter(excludeEventConfig, message.topicId),
     getNotificationsForUserId(excludeEventConfig, message.userId),
     getNotificationsForMentionedUser(logger, excludeEventConfig, message.postContent),
     getProjectMembersNotifications(excludeEventConfig, project),
     getTopCoderMembersNotifications(excludeEventConfig),
+    // these are special exclude rules which are only working for excluding notifications but not including
+    getExcludedPrivatePostNotifications(excludeEventConfig, project, tags),
+    getExcludeDraftPhasesNotifications(excludeEventConfig, project, tags),
   ]).then((notificationsPerSource) => (
     _.uniqBy(_.flatten(notificationsPerSource), 'userId')
   )).then((excludedNotifications) => {
@@ -332,10 +416,10 @@ const handler = (topic, message, logger, callback) => {
   }
 
   // get project details
-  service.getProject(projectId).then(project => {
+  return service.getProject(projectId).then(project => {
     let allNotifications = [];
 
-    Promise.all([
+    return Promise.all([
       // the order in this list defines the priority of notification for the SAME user
       // upper in this list - higher priority
       // NOTE: always add all handles here, they have to check by themselves:
@@ -357,7 +441,7 @@ const handler = (topic, message, logger, callback) => {
         project,
       })
     )).then((notifications) => {
-      allNotifications = _.filter(notifications, notification => notification.userId !== `${message.initiatorUserId}`);
+      allNotifications = _.filter(notifications, n => n.userId && n.userId !== `${message.initiatorUserId}`);
 
       if (eventConfig.includeUsers && message[eventConfig.includeUsers] &&
           message[eventConfig.includeUsers].length > 0) {

connect/events-config.js

@@ -5,6 +5,7 @@ const { BUS_API_EVENT } = require('./constants');
 
 // project member role names
 const PROJECT_ROLE_OWNER = 'owner';
+const PROJECT_ROLE_CUSTOMER = 'customer';
 const PROJECT_ROLE_COPILOT = 'copilot';
 const PROJECT_ROLE_MANAGER = 'manager';
 const PROJECT_ROLE_MEMBER = 'member';
@@ -13,13 +14,15 @@ const PROJECT_ROLE_ACCOUNT_MANAGER = 'account_manager';
 // project member role rules
 const PROJECT_ROLE_RULES = {
   [PROJECT_ROLE_OWNER]: { role: 'customer', isPrimary: true },
+  [PROJECT_ROLE_CUSTOMER]: { role: 'customer' },
   [PROJECT_ROLE_COPILOT]: { role: 'copilot' },
   [PROJECT_ROLE_MANAGER]: { role: 'manager' },
   [PROJECT_ROLE_ACCOUNT_MANAGER]: { role: 'account_manager' },
   [PROJECT_ROLE_MEMBER]: {},
 };
 
 // TopCoder roles
+// eslint-disable-next-line no-unused-vars
 const ROLE_CONNECT_COPILOT = 'Connect Copilot';
 const ROLE_CONNECT_MANAGER = 'Connect Manager';
 const ROLE_CONNECT_COPILOT_MANAGER = 'Connect Copilot Manager';
@@ -123,31 +126,53 @@ const EVENTS = [
     version: 2,
     projectRoles: [PROJECT_ROLE_OWNER, PROJECT_ROLE_COPILOT, PROJECT_ROLE_MANAGER, PROJECT_ROLE_MEMBER],
     toMentionedUsers: true,
+    exclude: {
+      privatePostsForProjectRoles: [PROJECT_ROLE_CUSTOMER],
+    },
   }, {
     type: BUS_API_EVENT.CONNECT.POST.CREATED,
     version: 2,
     projectRoles: [PROJECT_ROLE_OWNER, PROJECT_ROLE_COPILOT, PROJECT_ROLE_MANAGER, PROJECT_ROLE_MEMBER],
     toTopicStarter: true,
     toMentionedUsers: true,
+    exclude: {
+      draftPhasesForProjectRoles: [PROJECT_ROLE_CUSTOMER],
+      privatePostsForProjectRoles: [PROJECT_ROLE_CUSTOMER],
+    },
   }, {
     type: BUS_API_EVENT.CONNECT.POST.UPDATED,
     version: 2,
     projectRoles: [PROJECT_ROLE_OWNER, PROJECT_ROLE_COPILOT, PROJECT_ROLE_MANAGER, PROJECT_ROLE_MEMBER],
     toTopicStarter: true,
     toMentionedUsers: true,
+    exclude: {
+      draftPhasesForProjectRoles: [PROJECT_ROLE_CUSTOMER],
+      privatePostsForProjectRoles: [PROJECT_ROLE_CUSTOMER],
+    },
   }, {
     type: BUS_API_EVENT.CONNECT.POST.MENTION,
+    exclude: {
+      draftPhasesForProjectRoles: [PROJECT_ROLE_CUSTOMER],
+      privatePostsForProjectRoles: [PROJECT_ROLE_CUSTOMER],
+    },
   },
   {
     type: BUS_API_EVENT.CONNECT.TOPIC.DELETED,
     version: 2,
     projectRoles: [PROJECT_ROLE_OWNER, PROJECT_ROLE_COPILOT, PROJECT_ROLE_MANAGER, PROJECT_ROLE_MEMBER],
     toTopicStarter: false,
+    exclude: {
+      privatePostsForProjectRoles: [PROJECT_ROLE_CUSTOMER],
+    },
   },
   {
     type: BUS_API_EVENT.CONNECT.POST.DELETED,
     version: 2,
     projectRoles: [PROJECT_ROLE_OWNER, PROJECT_ROLE_COPILOT, PROJECT_ROLE_MANAGER, PROJECT_ROLE_MEMBER],
+    exclude: {
+      draftPhasesForProjectRoles: [PROJECT_ROLE_CUSTOMER],
+      privatePostsForProjectRoles: [PROJECT_ROLE_CUSTOMER],
+    },
   },
   {
     type: BUS_API_EVENT.CONNECT.PROJECT.LINK_CREATED,

connect/helpers.js

@@ -2,6 +2,9 @@
  * Helper functions
  */
 const Remarkable = require('remarkable');
+const _ = require('lodash');
+
+const PHASE_ID_REGEXP = /phase#(\d+)/;
 
 /**
  * Convert markdown into raw draftjs state
@@ -42,7 +45,20 @@ const sanitizeEmail = (email) => {
   return '';
 };
 
+/**
+ * Helper method to extract phaseId from tag
+ *
+ * @param {Array} tags list of message tags
+ *
+ * @returns {String} phase id
+ */
+const extractPhaseId = (tags) => {
+  const phaseIds = tags.map((tag) => _.get(tag.match(PHASE_ID_REGEXP), '1', null));
+  return _.find(phaseIds, (phaseId) => phaseId !== null);
+};
+
 module.exports = {
   markdownToHTML,
   sanitizeEmail,
+  extractPhaseId,
 };