Fix terms duplicates (PM-2114), fixes group check during search to show challenges in matching groups to member (PM-2207)

Author: jmgasper

src/common/helper.js

@@ -700,12 +700,13 @@ async function getCompleteUserGroupTreeIds(userId) {
       },
     });
 
+    const normalizedGroupIds = normalizeGroupIdsFromResponse(result.data);
     logger.debug(
       `helper.getCompleteUserGroupTreeIds: response status ${result.status} (groups=${
-        _.get(result, "data.length", 0) || 0
+        normalizedGroupIds.length
       })`
     );
-    return result.data || [];
+    return normalizedGroupIds;
   } catch (err) {
     logger.debug(
       `helper.getCompleteUserGroupTreeIds: error for user ${userId} - status ${
@@ -716,6 +717,79 @@ async function getCompleteUserGroupTreeIds(userId) {
   }
 }
 
+/**
+ * Normalize group payload into a flat list of group identifier strings.
+ *
+ * @param {Array|Object|String|Number} groupPayload raw response from Groups API
+ * @returns {Array<String>} normalized group identifiers
+ */
+function normalizeGroupIdsFromResponse(groupPayload) {
+  const ids = new Set();
+
+  const pushId = (value) => {
+    if (_.isNil(value)) {
+      return;
+    }
+    if (typeof value === "number" || typeof value === "bigint") {
+      ids.add(value.toString());
+      return;
+    }
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      if (!trimmed) {
+        return;
+      }
+      const lowered = trimmed.toLowerCase();
+      if (lowered === "null" || lowered === "undefined") {
+        return;
+      }
+      ids.add(trimmed);
+    }
+  };
+
+  const visit = (payload, depth = 0) => {
+    if (_.isNil(payload) || depth > 6) {
+      return;
+    }
+    if (Array.isArray(payload)) {
+      payload.forEach((item) => visit(item, depth + 1));
+      return;
+    }
+    if (_.isPlainObject(payload)) {
+      const identifierKeys = ["id", "groupId", "oldId", "legacyId", "uuid"];
+      identifierKeys.forEach((key) => {
+        if (!_.isNil(payload[key])) {
+          pushId(payload[key]);
+        }
+      });
+
+      const nestedKeys = [
+        "path",
+        "pathIds",
+        "pathGroupIds",
+        "parentGroups",
+        "ancestors",
+        "ancestorGroupIds",
+        "subGroups",
+        "children",
+        "groupIds",
+        "membershipGroupIds",
+      ];
+      nestedKeys.forEach((key) => {
+        if (!_.isNil(payload[key])) {
+          visit(payload[key], depth + 1);
+        }
+      });
+      return;
+    }
+
+    pushId(payload);
+  };
+
+  visit(groupPayload);
+  return Array.from(ids);
+}
+
 /**
  * Get all subgroups for the given group ID
  * @param {String} groupId the group ID
@@ -938,19 +1012,41 @@ async function getProjectDefaultTerms(projectId) {
   }
 }
 
+/**
+ * Remove duplicate term entries by "id" and "roleId" combination.
+ *
+ * @param {Array<Object>} terms list of challenge terms
+ * @returns {Array<Object>} unique term definitions
+ */
+function dedupeChallengeTerms(terms = []) {
+  if (!Array.isArray(terms)) {
+    return [];
+  }
+
+  return _.uniqBy(
+    terms.filter((term) => !_.isNil(term)),
+    (term) => {
+      const idKey = _.toString(term.id).trim();
+      const roleKey = _.isNil(term.roleId) ? "" : _.toString(term.roleId).trim();
+      return `${idKey}:${roleKey}`;
+    }
+  );
+}
+
 /**
  * This function gets the challenge terms array with the terms data
  * The terms data is retrieved from the terms API using the specified terms ids
  *
  * @param {Array<Object>} terms The array of terms {id, roleId} to retrieve from terms API
  */
 async function validateChallengeTerms(terms = []) {
-  if (terms.length === 0) {
+  const uniqueTerms = dedupeChallengeTerms(terms);
+  if (uniqueTerms.length === 0) {
     return [];
   }
   const listOfTerms = [];
   const token = await m2mHelper.getM2MToken();
-  for (let term of terms) {
+  for (let term of uniqueTerms) {
     // Get the terms details from the API
     try {
       await axios.get(`${config.TERMS_API_URL}/${term.id}`, {
@@ -1374,6 +1470,7 @@ module.exports = {
   createResource,
   getUserGroups,
   ensureNoDuplicateOrNullElements,
+  dedupeChallengeTerms,
   postBusEvent,
   calculateChallengeEndDate,
   listChallengesByMember,

src/common/prisma-helper.js

@@ -2,6 +2,7 @@ const _ = require("lodash");
 const Decimal = require("decimal.js");
 const constants = require("../../app-constants");
 const { PrizeSetTypeEnum } = require("@prisma/client");
+const { dedupeChallengeTerms } = require("./helper");
 /**
  * Convert phases data to prisma model.
  *
@@ -346,7 +347,8 @@ function convertModelToResponse(ret) {
   delete ret.overviewTotalPrizes;
 
   // convert terms
-  ret.terms = _.map(ret.terms, (t) => ({ id: t.termId, roleId: t.roleId }));
+  const serializedTerms = _.map(ret.terms, (t) => ({ id: t.termId, roleId: t.roleId }));
+  ret.terms = dedupeChallengeTerms(serializedTerms);
   // convert skills - basic transformation, enrichment happens in service layer
   ret.skills = _.map(ret.skills, (s) => ({ id: s.skillId }));
   // convert attachments

src/services/ChallengeService.js

@@ -419,6 +419,33 @@ async function searchChallenges(currentUser, criteria) {
 
   const _hasAdminRole = hasAdminRole(currentUser);
 
+  const normalizeGroupIdValue = (value) => {
+    if (_.isNil(value)) {
+      return null;
+    }
+    const normalized = _.toString(value).trim();
+    if (!normalized) {
+      return null;
+    }
+    const lowered = normalized.toLowerCase();
+    if (lowered === "null" || lowered === "undefined") {
+      return null;
+    }
+    return normalized;
+  };
+
+  const normalizeGroupIdList = (list) => {
+    if (_.isNil(list)) {
+      return [];
+    }
+    const arrayValue = Array.isArray(list) ? list : [list];
+    return _.uniq(
+      arrayValue
+        .map((value) => normalizeGroupIdValue(value))
+        .filter((value) => !_.isNil(value))
+    );
+  };
+
   let includedTrackIds = _.isArray(criteria.trackIds) ? criteria.trackIds : [];
   let includedTypeIds = _.isArray(criteria.typeIds) ? criteria.typeIds : [];
 
@@ -745,52 +772,63 @@ async function searchChallenges(currentUser, criteria) {
 
   let groupsToFilter = [];
   let accessibleGroups = [];
+  let accessibleGroupsSet = new Set();
 
   if (currentUser && !currentUser.isMachine && !_hasAdminRole) {
-    accessibleGroups = await helper.getCompleteUserGroupTreeIds(currentUser.userId);
+    const rawAccessibleGroups = await helper.getCompleteUserGroupTreeIds(currentUser.userId);
+    accessibleGroups = normalizeGroupIdList(rawAccessibleGroups);
+    accessibleGroupsSet = new Set(accessibleGroups);
   }
 
   // Filter all groups from the criteria to make sure the user can access those
   if (!_.isUndefined(criteria.group) || !_.isUndefined(criteria.groups)) {
+    const criteriaGroupsList = _.isNil(criteria.groups) ? [] : [].concat(criteria.groups);
+
     // check group access
     if (_.isUndefined(currentUser)) {
-      if (criteria.group) {
-        const group = await helper.getGroupById(criteria.group);
+      const normalizedGroup = normalizeGroupIdValue(criteria.group);
+      if (normalizedGroup) {
+        const group = await helper.getGroupById(normalizedGroup);
         if (group && !group.privateGroup) {
-          groupsToFilter.push(criteria.group);
+          groupsToFilter.push(normalizedGroup);
         }
       }
-      if (criteria.groups && criteria.groups.length > 0) {
-        const promises = [];
-        _.each(criteria.groups, (g) => {
-          promises.push(
-            (async () => {
-              const group = await helper.getGroupById(g);
-              if (group && !group.privateGroup) {
-                groupsToFilter.push(g);
-              }
-            })()
-          );
+
+      if (criteriaGroupsList.length > 0) {
+        const promises = criteriaGroupsList.map(async (groupValue) => {
+          const normalized = normalizeGroupIdValue(groupValue);
+          if (!normalized) {
+            return;
+          }
+          const group = await helper.getGroupById(normalized);
+          if (group && !group.privateGroup) {
+            groupsToFilter.push(normalized);
+          }
         });
         await Promise.all(promises);
       }
     } else if (!currentUser.isMachine && !_hasAdminRole) {
-      if (accessibleGroups.includes(criteria.group)) {
-        groupsToFilter.push(criteria.group);
+      const normalizedGroup = normalizeGroupIdValue(criteria.group);
+      if (normalizedGroup && accessibleGroupsSet.has(normalizedGroup)) {
+        groupsToFilter.push(normalizedGroup);
       }
-      if (criteria.groups && criteria.groups.length > 0) {
-        _.each(criteria.groups, (g) => {
-          if (accessibleGroups.includes(g)) {
-            groupsToFilter.push(g);
+
+      if (criteriaGroupsList.length > 0) {
+        criteriaGroupsList.forEach((groupValue) => {
+          const normalized = normalizeGroupIdValue(groupValue);
+          if (normalized && accessibleGroupsSet.has(normalized)) {
+            groupsToFilter.push(normalized);
           }
         });
       }
     } else {
-      groupsToFilter = [...(criteria.groups ? criteria.groups : [])];
-      if (criteria.group) {
-        groupsToFilter.push(criteria.group);
+      groupsToFilter = normalizeGroupIdList(criteriaGroupsList);
+      const normalizedGroup = normalizeGroupIdValue(criteria.group);
+      if (normalizedGroup) {
+        groupsToFilter.push(normalizedGroup);
       }
     }
+
     groupsToFilter = _.uniq(groupsToFilter);
 
     if (groupsToFilter.length === 0) {
@@ -2261,7 +2299,7 @@ async function updateChallenge(currentUser, challengeId, data) {
   }
 
   if (!_.isUndefined(data.terms)) {
-    await helper.validateChallengeTerms(data.terms);
+    data.terms = await helper.validateChallengeTerms(data.terms);
   }
 
   if (data.phases && data.phases.length > 0) {
@@ -2784,7 +2822,8 @@ function sanitizeChallenge(challenge) {
     }));
   }
   if (challenge.terms) {
-    sanitized.terms = _.map(challenge.terms, (term) => _.pick(term, ["id", "roleId"]));
+    const uniqueTerms = helper.dedupeChallengeTerms(challenge.terms || []);
+    sanitized.terms = _.map(uniqueTerms, (term) => _.pick(term, ["id", "roleId"]));
   }
   if (challenge.attachments) {
     sanitized.attachments = _.map(challenge.attachments, (attachment) =>