:bug: refactor bug fixes for active memberships

backend/lib/routes/membership/active.js

             const membershipType = request.query.type
 
             const profileId = request.params.profile_id
-            let groupings = await membershipService.findGroupingsByProfileId(
+            const groupings = await membershipService.findGroupingsByProfileId(
                 profileId,
                 membershipType,
             )
-            let memberships = await membershipService.findMemberships(
-                groupings.map(grouping => grouping.grouping_id),
+            const groupingIds = groupings.map(grouping => grouping.grouping_id)
+            const memberships = await membershipService.findMemberships(
+                groupingIds,
+            )
+            const profileIds = memberships
+                .filter(membership => membership.profile_id != profileId)
+                .map(membership => membership.profile_id)
+
+            /** Assemble complete profiles to reference and pass */
+            const completedProfiles = await profileService.getProfilesFor(
+                profileIds,
+                'participant',
             )
 
             /**
              * Heavily process the result by storing just a profile_id
              * and attach complete profiles
+             * !: This still assumes only ONE other profile
+             * TODO: should be refactored to many other profiles
              */
-            let pIds = groupings.reduce((ids, grouping) => {
-                grouping.profiles.forEach(p => {
-                    if (p.profile_id == profileId) return
-                    ids.push(p.profile_id)
-                    grouping.profile = p.profile_id
-                })
+            const reformattedGroupings = groupings.map(grouping => {
+                const otherPid = grouping.profiles.find(
+                    p => p.profile_id != profileId,
+                ).profile_id
+                grouping.profile = completedProfiles.find(
+                    p => otherPid == p.profile_id,
+                )
+                grouping.is_paired = _activeGroupingIds(memberships).includes(
+                    grouping.grouping_id,
+                )
                 delete grouping.profiles
-                return ids
-            }, [])
-            /** Assemble complete profiles to reference and pass */
-            const completedProfiles = await profileService.getProfilesFor(
-                pIds,
-                'participant',
-            )
+                return grouping
+            })
 
             /** Grabs revealTags */
-            const profileIdsFromCompletedProfiles = completedProfiles.map(
-                p => p.profile_id,
-            )
-            const groupingIdsFromGroupings = groupings.map(g => g.grouping_id)
             const revealTags = await profileService.getTagsFor(
-                profileIdsFromCompletedProfiles,
-                groupingIdsFromGroupings,
+                profileIds,
+                groupingIds,
                 'reveal',
             )
 
              * removed and replaced with the completedProfile's user information
              * Otherwise the completedProfiles remain unchanged
              */
-            const userIdsFromCompletedProfiles = completedProfiles.map(
-                p => p.user_id,
-            )
             const user = await userService.findById(
-                userIdsFromCompletedProfiles,
+                completedProfiles.map(p => p.user_id),
             )
-            if (revealTags && user) {
-                for (const t of revealTags) {
-                    if (t.tag.tag_description) {
-                        completedProfiles[0][t.tag.tag_description] =
-                            user[t.tag.tag_description]
-                    }
-                }
-            }
 
-            const reformattedGroupings = groupings.map(g => {
-                completedProfiles.forEach(p => {
-                    g.profile = g.profile == p.profile_id ? p : g.profile
+            // TODO: Refactor this. Is it safe to always use completedProfiles[0]?
+            if (revealTags && user) {
+                revealTags.forEach(t => {
+                    if (!t.tag.tag_description) return
+                    completedProfiles[0][t.tag.tag_description] =
+                        user[t.tag.tag_description]
                 })
-                g.is_paired = _activeGroupingIds(memberships).includes(
-                    g.grouping_id,
-                )
-                return g
-            })
+            }
 
             try {
                 return {

backend/lib/services/profile/index.js

         await this._setScoreLookup()
         await this._setTagLookup()
 
-        // profilesEntries is profiles in dataaspect_labelsbase row order
+        // profilesEntries is profiles in database row order
         const profilesEntries = await Profile.query()
             .whereIn('profile_id', profileIdArray)
             .withGraphFetched('tags')

backend/lib/services/profile/profiler.js

 }
 const _makeCompleteProfile = (profileEntry, type, tagLookup) => {
     profileEntry.tags = profileEntry.tags.map(tag => tagLookup[tag.tag_id])
-    return new CompleteProfile(profileEntry, type)
+    const complete = new CompleteProfile(profileEntry, type)
+    return complete
 }
 
+/**
+ * Get complete profiles and return in order
+ * @param {Array} orderedProfileIds
+ * @param {Array} profilesEntries
+ * @param {String} type
+ * @param {Object} tagLookup
+ * @returns {Array}
+ */
 const makeOrderedCompleteProfiles = (
     orderedProfileIds,
     profilesEntries,
     tagLookup,
 ) => {
     return orderedProfileIds.map(pid => {
-        const foundEntry = profilesEntries.find(entry => {
-            pid == entry.profile_id
-        })
-        return _makeCompleteProfile(foundEntry, type, tagLookup)
+        const found = profilesEntries.find(entry => entry.profile_id == pid)
+        return _makeCompleteProfile(found, type, tagLookup)
     })
 }
-const makeCompleteFromProfileEntries = (profilesEntries, type, tagLookup) =>
-    profilesEntries.map(entry => _makeCompleteProfile(entry, type, tagLookup))
+
+/**
+ * Get complete profiles from dB rows
+ * @param {Array} profilesEntries
+ * @param {String} type
+ * @param {Object} tagLookup
+ * @returns {Array}
+ */
+const makeCompleteFromProfileEntries = (profilesEntries, type, tagLookup) => {
+    return profilesEntries.map(entry =>
+        _makeCompleteProfile(entry, type, tagLookup),
+    )
+}
 
 module.exports = {
     CompleteProfile,