:recycle: Continuing refactoring of hidden, almost there...?

backend/lib/routes/membership/active.js

                 groupings.map(grouping => grouping.grouping_id),
             )
 
+            // NOTE: Current implementation works okay, it only reveals the targetID's
+            // hidden info on the page currently, it does NOT reveal OUR OWN information
+            // to ourselves when revealed
+
             /**
              * Heavily process the result by storing just a profile_id
              * and attach complete profiles
              */
+            // NOTE: only returns the pId for the target
             let pIds = groupings.reduce((ids, grouping) => {
                 grouping.profiles.forEach(p => {
-                    if (p.profile_id == profileId) return
+                    // you'd think to comment out here, but it still only returns CompleteProfile of target
+                    // pIds would be both currentProfile id and target id though
+                    if (p.profile_id == profileId) return 
                     ids.push(p.profile_id)
                     grouping.profile = p.profile_id
                 })
                 delete grouping.profiles
                 return ids
             }, [])
-
+            console.log('pIds :=>', pIds) // only returns single array of target id
             /** Assemble complete profiles to reference and pass */
             const completedProfiles = await profileService.getProfilesFor(
                 pIds,
                 false,
             )
 
-            const revealTags = []
-            completedProfiles.forEach(p => {
-                p.tags.forEach(t => {
-                    if (t.tag_category === 'reveal') {
-                        if (t.tag_description === 'user_email' || t.tag_description === 'user_name') {
-                            revealTags.push(t)
+            // NOTE: Doesn't rely on profile reveal field to get reveal tags
+            const getGroupingRevealTags = async () => {
+                const groupingRevealTags = []
+                for (const grouping of groupings) {
+                    for (const profile of completedProfiles) {
+                        const revealTags = await profileService.getTagsFor(profile.profile_id, grouping.grouping_id, 'reveal')
+                        if (revealTags.length) {
+                            groupingRevealTags.push(revealTags)
                         }
                     }
-                })
-            })
+                }
+                return groupingRevealTags
+            }
 
+            const revealTags = await getGroupingRevealTags()
+            // TODO: Refactor, triple for of loop...
             const getRevealInfo = async () => {
                 const profilesWithRevealed = []
                 for (const profile of completedProfiles) {
                     const userInfo = await userService.findById(profile.user_id)
-                    for (const tag of revealTags) {
-                        profile[tag.tag_description] = userInfo[tag.tag_description]
+                    if (userInfo && revealTags.length) {
+                        for (const tags of revealTags) {
+                            for (const tag of tags) {
+                                if (tag.tag.tag_description) {
+                                    profile[tag.tag.tag_description] = userInfo[tag.tag.tag_description]
+                                }
+                            }
+                        }
+                        profilesWithRevealed.push(profile)
                     }
-                    profilesWithRevealed.push(profile)
                 }
-                return profilesWithRevealed
+                if (profilesWithRevealed.length)
+                    return profilesWithRevealed
+                else
+                    return completedProfiles
             }
 
-            const revealedInfo = await getRevealInfo()
-            console.log('revealedInfo :=>', revealedInfo)
-            // if revealTags.length, return revealInfo, otherwise return completeProfiles...
+            const completedProfilesWithRevealedInfo = await getRevealInfo()
 
+            // ISSUE: renders target ID but not currentProfileID in ChatView.vue
             const reformattedGroupings = groupings.map(g => {
-                completedProfiles.forEach(p => {
+                completedProfilesWithRevealedInfo.forEach(p => {
                     g.profile = g.profile == p.profile_id ? p : g.profile
                 })
                 g.is_paired = _activeGroupingIds(memberships).includes(
                 )
                 return g
             })
-
+            console.log('reformattedGroupings :=>', reformattedGroupings)
             try {
                 return {
                     ok: true,

backend/lib/routes/membership/reveal.js

         auth: false,
         cors: true,
         handler: async function (request, h) {
-            const { membershipService, profileService } =
+            const { membershipService, profileService, userService } =
                 request.server.services()
             const grouping_id = request.params.grouping_id
             const { profile_id, tag_id } = request.query
                 }
 
                 const tag_description = returnedTag().tag.tag_description
-                // TODO: Refactor completeProfile[0]... code smell
-                const revealInfo = completeProfile[0][tag_description]
+                const userInfo = await userService.findById(completeProfile[0].user_id)
+                const revealInfo = userInfo[tag_description]
 
                 idsInGroup.forEach(profile_id => {
                     request.server.methods.notify(

backend/lib/schemas/profiles.js

     responses: surveyResponseSchema.list,
     reveal: Joi.array().items(),
     tags: tagSchema.list,
+    image: Joi.any(),
+    blurb: Joi.any(),
     user_type: Joi.any(),
     user: userSchema.single,
     profile_description: Joi.string().allow(null, ''),

backend/lib/services/profile/profiler.js

         this.responses = []
         this.user_type = type
         // NOTE: just have all the tags in one place
-        this.tags = profile.tags
+        this.tags = profile.tags.filter(t => t.tag_category !== 'reveal')
         // TODO: generalize this for multiple images, and languages
         this.profile_description = ''
         this.profile_media = []
         this.profile_languages = []
         this.profile_prefs = {}
+        this.image = ''
+        this.blurb = ''
 
         // TODO: Use reveal tags to add or remove information from profile!
         // TODO: ---

frontend/src/entities/profile/profile.schema.js

         user_name: Joi.string(),
         user_id: Joi.number(),
         user_email: Joi.string(),
+        image: Joi.any(),
+        blurb: Joi.any(),
         profile_id: Joi.number(),
         profile_description: Joi.string().allow(null, ''),
         profile_media: Joi.array().items(Joi.string()),

frontend/src/services/notification.service.js

                 tag_category: "reveal",
                 tag_description: parsed.description,
                 tag_id: parsed.tag,
-                for_profile_id: foundGrouping.profile.profile_id
             }
             const target_desc = parsed.description
             tagFromNotification[target_desc] = parsed.revealed_info