Frontend Release to Main [4.65]

src/actions/badgeManagement.js

@@ -47,38 +47,6 @@ export const fetchAllBadges = (forceRefresh = false) => {
     }
   };
 };
-
-// Return updated badgeCollection
-export const returnUpdatedBadgesCollection = (badgeCollection, selectedBadgesId) => {
-  const personalMaxBadge = '666b78265bca0bcb94080605'; // backend id for Personal Max badge
-  const badgeMap = new Map(badgeCollection?.map(badge => [badge.badge, badge]));
-
-  const currentTs = Date.now();
-  const currentDate = formatDate();
-  selectedBadgesId.forEach(originalBadgeId => {
-    const badgeId = originalBadgeId.replace('assign-badge-', '');
-    if (badgeMap.has(badgeId)) {
-      // Update the existing badge record
-      if (badgeId !== personalMaxBadge) {
-        const badge = badgeMap.get(badgeId);
-        badge.count = (badge.count || 0) + 1;
-        badge.lastModified = currentTs;
-        badge.earnedDate.push(currentDate);
-      }
-    } else {
-      // Add the new badge record
-      badgeMap.set(badgeId, {
-        badge: badgeId,
-        count: 1,
-        lastModified: currentTs,
-        earnedDate: [currentDate],
-      });
-    }
-  });
-
-  return Array.from(badgeMap.values());
-};
-
 export const gotCloseAlert = () => ({ type: CLOSE_ALERT });
 
 const getBadgeCountSuccess = badgeCount => ({
@@ -167,7 +135,7 @@ export const validateBadges = (firstName, lastName) => {
     if (!firstName || !lastName) {
       dispatch(
         getMessage(
-          'The Name Find function does not work without entering a name. Nice try though.',
+          'The Name Find function does not work without entering first and last name. Nice try though.',
           'danger',
         ),
       );
@@ -180,7 +148,105 @@ export const validateBadges = (firstName, lastName) => {
   };
 };
 
-export const assignBadges = (firstName, lastName, selectedBadges) => {
+
+
+export const returnUpdatedBadgesCollection = (badgeCollection, selectedBadgesId) => {
+  let newBadgeCollection = Array.from(badgeCollection);
+
+  // Object to track updated or newly added badges to prevent duplicates
+  const updatedOrAddedBadges = {};
+
+  selectedBadgesId.forEach(originalBadgeId => {
+    let badgeId = originalBadgeId;
+
+    // Remove "assign-badge-" from badgeId
+    if (badgeId.includes('assign-badge-')) badgeId = badgeId.replace('assign-badge-', '');
+
+    if (!updatedOrAddedBadges[badgeId]) {
+      // Flag to check if the badge is already in the collection
+      let included = false;
+      const currentTs = Date.now();
+      const currentDate = formatDate();
+
+      for (let i = 0; i < newBadgeCollection.length; i+=1) {
+        const badgeObj = newBadgeCollection[i];
+        if (badgeId === badgeObj.badge) {
+          // If the badge is found, increment the count and mark it as included
+          badgeObj.count = badgeObj.count ? badgeObj.count + 1 : 1;
+          badgeObj.lastModified = currentTs;
+          badgeObj.earnedDate.push(currentDate);
+          included = true;
+          // Mark this badge ID as updated so it's not added again
+          updatedOrAddedBadges[badgeId] = true;
+          break; // Exit loop after finding and updating the badge
+        }
+      }
+
+      // If the badge was not already in the collection, add it as a new entry
+      if (!included) {
+        newBadgeCollection.push({
+          badge: badgeId,
+          count: 1,
+          lastModified: currentTs,
+          earnedDate: [currentDate],
+        });
+        // Mark this badge ID as added
+        updatedOrAddedBadges[badgeId] = true;
+      }
+    }
+  });
+
+  return newBadgeCollection;
+};
+
+export const returnUpdatedBadgesCollectionSingleUser = (badgeCollection, selectedBadgesId) => {
+  let newBadgeCollection = Array.from(badgeCollection);
+
+  const updatedOrAddedBadges = {};
+
+  selectedBadgesId.forEach(originalBadgeId => {
+    let badgeId = originalBadgeId;
+    if (badgeId.includes('assign-badge-')) badgeId = badgeId.replace('assign-badge-', '');
+
+    if (!updatedOrAddedBadges[badgeId]) {
+      let included = false;
+      const currentTs = Date.now();
+      const currentDate = formatDate();
+
+      newBadgeCollection = newBadgeCollection.map(badgeObj => {
+                            if (badgeId === badgeObj.badge) {
+                              if (!included) {
+                                included = true;
+                                updatedOrAddedBadges[badgeId] = true;
+                                return {
+                                  ...badgeObj,
+                                  count: badgeObj.count ? badgeObj.count + 1 : 1,
+                                  lastModified: currentTs,
+                                  earnedDate: [...badgeObj.earnedDate, currentDate]
+                                };
+                              }
+                              updatedOrAddedBadges[badgeId] = true;
+                            }
+                            return badgeObj;
+       });
+
+      if (!included) {
+        newBadgeCollection.push({
+          badge: badgeId,
+          count: 1,
+          lastModified: currentTs,
+          earnedDate: [currentDate],
+        });
+        updatedOrAddedBadges[badgeId] = true;
+      }
+    }
+  });
+
+  return newBadgeCollection;
+};
+
+
+export const assignBadgesByUserID = (userId, selectedBadges) => {
   return async dispatch => {
     if (selectedBadges.length === 0) {
       dispatch(
@@ -189,17 +255,13 @@ export const assignBadges = (firstName, lastName, selectedBadges) => {
           'danger',
         ),
       );
-      if (ALERT_DELAY === 0) {
+      setTimeout(() => {
         dispatch(closeAlert());
-      } else {
-        setTimeout(() => dispatch(closeAlert()), ALERT_DELAY);
-      }
+      }, 6000);
       return;
     }
 
-    const userAssigned = `${firstName} ${lastName}`;
-
-    const res = await axios.get(ENDPOINTS.USER_PROFILE_BY_NAME(userAssigned));
+    const res = await axios.get(ENDPOINTS.USER_PROFILE(userId));
 
     if (res.data.length === 0) {
       dispatch(
@@ -208,18 +270,22 @@ export const assignBadges = (firstName, lastName, selectedBadges) => {
           'danger',
         ),
       );
-      if (ALERT_DELAY === 0) {
+      setTimeout(() => {
         dispatch(closeAlert());
-      } else {
-        setTimeout(() => dispatch(closeAlert()), ALERT_DELAY);
-      }
+      }, 6000);
       return;
     }
+    const { badgeCollection } = res.data;
+    for (let i = 0; i < badgeCollection.length; i+=1) {
+      badgeCollection[i].badge = badgeCollection[i].badge._id;
+    }
 
-    const { badgeCollection } = res.data[0];
-    const userToBeAssignedBadge = res.data[0]._id;
-    const newBadgeCollection = returnUpdatedBadgesCollection(badgeCollection, selectedBadges);
-
+    const userToBeAssignedBadge = res.data._id;
+    const newBadgeCollection = returnUpdatedBadgesCollectionSingleUser(
+      badgeCollection,
+      selectedBadges,
+    );
+    // send updated badgeCollection to backend
     const url = ENDPOINTS.BADGE_ASSIGN(userToBeAssignedBadge);
     try {
       await axios.put(url, {
@@ -232,23 +298,19 @@ export const assignBadges = (firstName, lastName, selectedBadges) => {
           'success',
         ),
       );
-      if (ALERT_DELAY === 0) {
+      setTimeout(() => {
         dispatch(closeAlert());
-      } else {
-        setTimeout(() => dispatch(closeAlert()), ALERT_DELAY);
-      }
+      }, 6000);
     } catch (e) {
       dispatch(getMessage('Oops, something is wrong!', 'danger'));
-      if (ALERT_DELAY === 0) {
+      setTimeout(() => {
         dispatch(closeAlert());
-      } else {
-        setTimeout(() => dispatch(closeAlert()), ALERT_DELAY);
-      }
+      }, 6000);
     }
   };
 };
 
-export const assignBadgesByUserID = (userId, selectedBadges) => {
+export const assignBadgesToMultipleUserID = (userIds, selectedBadges) => {
   return async dispatch => {
     if (selectedBadges.length === 0) {
       dispatch(
@@ -257,45 +319,80 @@ export const assignBadgesByUserID = (userId, selectedBadges) => {
           'danger',
         ),
       );
-      setTimeout(() => dispatch(closeAlert()), ALERT_DELAY || 0);
+      setTimeout(() => {
+        dispatch(closeAlert());
+      }, 6000);
       return;
     }
 
     try {
-      const res = await axios.get(ENDPOINTS.USER_PROFILE(userId));
-      const userData = Array.isArray(res.data) ? res.data[0] : res.data;
+      const response = await axios.post(ENDPOINTS.BADGE_ASSIGN_MULTIPLE, {
+        userIds,
+        selectedBadges,
+      });
 
-      if (!userData || !userData._id) {
-        dispatch(getMessage('User data is incomplete. Cannot assign badges.', 'danger'));
-        setTimeout(() => dispatch(closeAlert()), ALERT_DELAY || 0);
-        return;
+      if (response.status === 200) {
+        dispatch(
+          getMessage(
+            "Awesomesauce! You've increased badges and proportionally increased life happiness for multiple users!",
+            'success',
+          ),
+        );
+      } else {
+        throw new Error('Failed to assign badges');
       }
+    } catch (error) {
+      dispatch(getMessage('Oops, something went wrong while assigning badges!', 'danger'));
+    } finally {
+      setTimeout(() => {
+        dispatch(closeAlert());
+      }, 6000);
+    }
+  };
+};
 
-      const badgeCollectionToSend = selectedBadges.map(badgeId => ({
-        badge: badgeId,
-        count: 1,
-        lastModified: Date.now(),
-        featured: false,
-        earnedDate: []
-      }));
-
-      await axios.put(ENDPOINTS.BADGE_ASSIGN(userData._id), {
-        badgeCollection: badgeCollectionToSend,
-        newBadges: selectedBadges.length
-      });
-
+export const assignBadges = (firstName, lastName, selectedBadges) => {
+  return async dispatch => {
+    if (selectedBadges.length === 0) {
       dispatch(
         getMessage(
-          "Awesomesauce! Not only have you increased a person's badges, you've also proportionally increased their life happiness!",
-          'success',
+          "Um no, that didn't work. Badge Select Function must include actual selection of badges to work. Better luck next time!",
+          'danger',
         ),
       );
+      setTimeout(() => {
+        dispatch(closeAlert());
+      }, 6000);
+      return;
+    }
 
-      setTimeout(() => dispatch(closeAlert()), ALERT_DELAY || 0);
-    } catch (e) {
-      toast.error('Badge assignment error:', e);
-      dispatch(getMessage('Oops, something is wrong!', 'danger'));
-      setTimeout(() => dispatch(closeAlert()), ALERT_DELAY || 0);
+    const userAssigned = `${firstName} ${lastName}`;
+
+    try {
+      const res = await axios.get(ENDPOINTS.USER_PROFILE_BY_NAME(userAssigned));
+      if (res.data.length === 0) {
+        dispatch(
+          getMessage(
+            "Can't find that user. Step 1 to getting badges: Be in the system. Not in the system? No badges for you!",
+            'danger',
+          ),
+        );
+        setTimeout(() => {
+          dispatch(closeAlert());
+        }, 6000);
+      }
+      const userToBeAssignedBadge = res.data[0]._id;
+      await dispatch(assignBadgesByUserID([userToBeAssignedBadge], selectedBadges));
+    } catch (error) {
+      dispatch(
+        getMessage(
+          'Oops, something is wrong!',
+          'danger',
+        ),
+      );
+      setTimeout(() => {
+        dispatch(closeAlert());
+      }, 6000);
     }
   };
 };
@@ -306,30 +403,24 @@ export const sendUpdatedBadgeCollectionReq = async (
   selectedBadges,
   userToBeAssignedBadge,
 ) => {
-  return async dispatch => {
-    const url = ENDPOINTS.BADGE_ASSIGN(userToBeAssignedBadge);
-    try {
-      await axios.put(url, { badgeCollection, newBadges: selectedBadges.length });
-      dispatch(
-        getMessage(
-          "Awesomesauce! Not only have you increased a person's badges, you've also proportionally increased their life happiness!",
-          'success',
-        ),
-      );
-      if (ALERT_DELAY === 0) {
-        dispatch(closeAlert());
-      } else {
-        setTimeout(() => dispatch(closeAlert()), ALERT_DELAY);
-      }
-    } catch (e) {
-      dispatch(getMessage('Oops, something is wrong!', 'danger'));
-      if (ALERT_DELAY === 0) {
-        dispatch(closeAlert());
-      } else {
-        setTimeout(() => dispatch(closeAlert()), ALERT_DELAY);
-      }
-    }
-  };
+  const url = ENDPOINTS.BADGE_ASSIGN(userToBeAssignedBadge);
+  try {
+    await axios.put(url, { badgeCollection, newBadges: selectedBadges.length });
+    dispatch(
+      getMessage(
+        "Awesomesauce! Not only have you increased a person's badges, you've also proportionally increased their life happiness!",
+        'success',
+      ),
+    );
+    setTimeout(() => {
+      dispatch(closeAlert());
+    }, 6000);
+  } catch (e) {
+    dispatch(getMessage('Oops, something is wrong!', 'danger'));
+    setTimeout(() => {
+      dispatch(closeAlert());
+    }, 6000);
+  }
 };
 
 export const changeBadgesByUserID = (userId, badgeCollection) => {