:recycle: cleaning up profiler | simplifying in some areas

backend/db/data-generator/config.json

         "91401",
         "97075"
     ],
-    "resKeys": [1, 2, 3, 4, 5, 6],
+    "scoreKeys": [1, 2, 3, 4, 5, 6],
+    "nameKey": 7,
+    "emailKey": 8,
+    "passwordKey": 9,
     "zipcodeKey": 10,
     "mediaKey": 12,
     "langKey": 13,
+    "durationKey": 14,
+    "presenceKey": 15,
     "blurbKey": 16,
-    "comment": "Make this match profiler.js complete profile constructor",
-    "prefKeys": [10, 14, 15, 17, 18, 19],
-    "maxDistanceKey": 19
+    "urgencyKey": 17,
+    "pronounsKey": 18,
+    "distanceKey": 19
 }

backend/db/data-generator/index.js

                     case config.langKey:
                         resToEdit.val = random.language()
                         break
-                    case 10:
+                    case config.durationKey:
                         resToEdit.val = random.duration()
                         break
-                    case 11:
+                    case config.presenceKey:
                         resToEdit.val = random.location()
                         break
                     case config.blurbKey:

backend/lib/routes/membership/active.js

              */
             let pIds = groupings.reduce((ids, grouping) => {
                 grouping.profiles.forEach(p => {
-                    if (p.profile_id == profileId) return 
+                    if (p.profile_id == profileId) return
                     ids.push(p.profile_id)
                     grouping.profile = p.profile_id
                 })
             const completedProfiles = await profileService.getProfilesFor(
                 pIds,
                 'participant',
-                false,
             )
 
             /** Grabs revealTags */
-            const profileIdsFromCompletedProfiles = completedProfiles.map(p => p.profile_id)
+            const profileIdsFromCompletedProfiles = completedProfiles.map(
+                p => p.profile_id,
+            )
             const groupingIdsFromGroupings = groupings.map(g => g.grouping_id)
-            const revealTags = await profileService.getTagsFor(profileIdsFromCompletedProfiles, groupingIdsFromGroupings, 'reveal')
+            const revealTags = await profileService.getTagsFor(
+                profileIdsFromCompletedProfiles,
+                groupingIdsFromGroupings,
+                'reveal',
+            )
 
             /** If the revealTags exist, the completedProfile's hidden info is
              * 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)
+            const userIdsFromCompletedProfiles = completedProfiles.map(
+                p => p.user_id,
+            )
+            const user = await userService.findById(
+                userIdsFromCompletedProfiles,
+            )
             if (revealTags && user) {
                 for (const t of revealTags) {
                     if (t.tag.tag_description) {
-                        completedProfiles[0][t.tag.tag_description] = user[t.tag.tag_description]
+                        completedProfiles[0][t.tag.tag_description] =
+                            user[t.tag.tag_description]
                     }
                 }
             }

backend/lib/routes/membership/reveal.js

             const grouping_id = request.params.grouping_id
             const { profile_id, tag_id } = request.query
             try {
-                const tags = await profileService.revealProfileInfo({
+                const associations = await profileService.revealProfileInfo({
                     profile_id,
                     grouping_id,
                     tag_id,
                     membership => membership.profile_id,
                 )
                 if (idsInGroup.length > 2)
-                    return console.error('ERROR: idsInGroup cannot have more than 2 entries: ', idsInGroup)
+                    return console.error(
+                        'ERROR: idsInGroup cannot have more than 2 entries: ',
+                        idsInGroup,
+                    )
                 // Grab User Info from Users Table
-                const completeProfile = await profileService.getProfilesFor([profile_id], 'participant')
+                const completeProfile = await profileService.getProfilesFor(
+                    [profile_id],
+                    'participant',
+                )
+                const userInfo = await userService.findById(
+                    completeProfile[0].user_id,
+                )
 
                 // Grab the TagAssociation that matches the revealed profile
-                // TODO: Check if there are multiple matching tags(?)(there shouldn't be)
-                const returnedTag = () => {
-                    let matchingTag
-                    tags.forEach(tagAssoc => {
-                        if (tagAssoc.grouping_id === grouping_id &&
-                            tagAssoc.profile_id === profile_id &&
-                            tagAssoc.tag_id === tag_id) {
-                            matchingTag = tagAssoc
-                        }
-                    })
-                    if (matchingTag)
-                        return matchingTag
-                    return console.error('ERROR: No matching tagAssociation')
-                }
-
-                const tag_description = returnedTag().tag.tag_description
-                const userInfo = await userService.findById(completeProfile[0].user_id)
-                const revealInfo = userInfo[tag_description]
+                // TODO: Check if there are multiple matching associations(?)(there shouldn't be)
+                let matchingAssociation = null
+                associations.forEach(tagAssoc => {
+                    if (
+                        tagAssoc.grouping_id === grouping_id &&
+                        tagAssoc.profile_id === profile_id &&
+                        tagAssoc.tag_id === tag_id
+                    ) {
+                        matchingAssociation = tagAssoc
+                    }
+                })
+                const description = matchingAssociation.tag.tag_description
 
                 idsInGroup.forEach(profile_id => {
                     request.server.methods.notify(
                         `${profile_id}.stonk`,
                         {
                             name: 'REVEALED_INFO',
-                            revealed_info: revealInfo,
+                            revealed_info: userInfo[description],
                             profile_id: completeProfile[0].profile_id,
                             grouping_id: grouping_id,
                             tag: tag_id,
-                            description: tag_description,
+                            description,
                             type: 'info',
                         },
                         h,
                     .response({
                         ok: true,
                         handler: pluginConfig.handlerType,
-                        data: { tags },
+                        data: { tags: associations },
                     })
                     .code(200)
             } catch (err) {

backend/lib/routes/profile/queue.js

 
 const validators = {
     params: params.profileId,
-    query: Joi.object({include_profile: Joi.bool(), limit: Joi.number(), offset: Joi.number()}),
+    query: Joi.object({
+        include_profile: Joi.bool(),
+        limit: Joi.number(),
+        offset: Joi.number(),
+    }),
 }
 
 module.exports = {
         cors: true,
         handler: async function (request, h) {
             const { profile_id } = request.params
-            const { include_profile, limit, offset} = request.query
+            const { limit, offset } = request.query
             const { profileService, matchQueueService } =
                 request.server.services()
 
-            const queue = await matchQueueService.getQueue(profile_id, limit, offset)
+            const queue = await matchQueueService.getQueue(
+                profile_id,
+                limit,
+                offset,
+            )
             const queueIds = queue.map(entry => entry.target_id)
-            const res = {
-                ok: true,
-                handler: pluginConfig.handlerType,
-                data: queueIds,
-            }
 
             // HELP: I think there's an issue here
             // queueIds spits out the queue profiles in the correct order
             //     'include_profile results',
             //     await profileService.getProfilesFor(queueIds),
             // )
-            if (include_profile) {
-                res.data = await profileService.getProfilesFor(
-                    queueIds,
-                    'participant',
-                    false,
-                )
-            }
             try {
-                return h.response(res).code(200)
+                return h
+                    .response({
+                        ok: true,
+                        handler: pluginConfig.handlerType,
+                        data: await profileService.getProfilesFor(
+                            queueIds,
+                            'participant',
+                        ),
+                    })
+                    .code(200)
             } catch (err) {
                 return h
                     .response({

backend/lib/services/profile/index.js

         matchingProfile.tags = matchingProfile.tags.map(
             tag => this.tagLookup[tag.tag_id],
         )
-        const complete = new profiler.CompleteProfile(matchingProfile, true)
-        return complete
+        return new profiler.CompleteProfile(matchingProfile)
     }
 
     async getCompleteProfilesFor(userId, type) {
             .whereIn('profile_id', dedupedProfileIds)
             .withGraphFetched('tags')
             .withGraphFetched('responses')
-            // CHECKTHIS: Added this because we added user.user_name to CompleteProfile
-            // so without this, we get undefined user_name
             .withGraphFetched('user')
 
         return profiler.makeCompleteFromProfileEntries(
         )
     }
 
-    async getProfilesFor(profileIdArray, type, includeResponses = true) {
+    async getProfilesFor(profileIdArray, type) {
         const { Profile } = this.server.models()
         await this._setScoreLookup()
         await this._setTagLookup()
             profileIdArray,
             profilesEntries,
             type,
-            includeResponses,
             this.tagLookup,
         )
     }
         await this._setTagLookup()
         let associations = groupingId
             ? await TagAssociation.query()
-                .where('grouping_id', groupingId)
-                .andWhere('profile_id', profileId)
+                  .where('grouping_id', groupingId)
+                  .andWhere('profile_id', profileId)
             : await TagAssociation.query().andWhere('profile_id', profileId)
         return associations
             .map(assoc => ({

backend/lib/services/profile/profiler.js

 const config = require('../../../db/data-generator/config.json')
 
+/**
+ * Unscored preferences used for filtering
+ * Does NOT include blurb, media languages
+ */
+const unscoredProfilePreferences = [
+    'zipcode',
+    'duration',
+    'presence',
+    'urgency',
+    'pronouns',
+    'distance',
+]
+const otherProfileInfo = ['blurb', 'media', 'lang']
+
 /**
  * Class to hold our retrieved profile information
  * in a convenient wrapper
  * !: This needs to match the responseSchema in profiles.js
  */
 class CompleteProfile {
-    constructor(profile, includeResponses = false, type) {
+    constructor(profile, type) {
         this.user_id = profile.user_id // int user_id
         this.profile_id = profile.profile_id // int profile_id
-        this.user_name = 'hidden_name'// string user_name
-        this.user_email = 'hidden@email.com'
-        this.responses = []
+        this.responses = profile.responses
         this.user_type = type
-        // NOTE: just have all the tags in one place
-        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: ---
-        // TODO: Use reveal tags to rebuild profile based on group/membership
-        // TODO: and include for certain profiles
+        this.profile_prefs = this.getPrefsFromResponses(this.responses)
 
+        otherProfileInfo.forEach(prefName => {
+            if (prefName == 'blurb') {
+                this.profile_description = this.responses.find(
+                    r => r.response_key_id === config.blurbKey,
+                ).val
+            } else if (['media', 'lang'].includes(prefName)) {
+                const key =
+                    prefName == 'media'
+                        ? `profile_${prefName}`
+                        : [`profile_${prefName}uages`]
+                this[key] = this.responses
+                    .filter(r => r.response_key_id === config[`${prefName}Key`])
+                    .map(r => r.val)
+            }
+        })
+        // TODO: These should be getters
+        this.user_name = 'bleh'
+        this.user_email = 'bleh@bleh.com'
         this.reveal = profile.tags.filter(t => t.tag_category == 'reveal')
-        // TODO: filter these correctly
-        if (profile?.responses?.length && includeResponses) {
-            // [] of all "profile" responses
-            this.responses = profile.responses
-            // image, language, duration, presence, blurb, urgency, role, pronouns, distance
-            const prefs = [
-                'zipcode',
-                'duration',
-                'presence',
-                'urgency',
-                'pronouns',
-                'distance',
-            ]
-            const prefsKeys = config.prefKeys
-            prefs.forEach((pref, i) => {
-                this.profile_prefs[pref] = this.responses.find(
-                    r => r.response_key_id === prefsKeys[i],
-                )
-            })
-            this.profile_description = this.responses.find(
-                r => r.response_key_id === config.blurbKey,
+        this.tags = profile.tags.filter(t => t.tag_category !== 'reveal')
+    }
+    /** Map pref name to dB key associated with preference */
+    get byPrefName() {
+        return unscoredProfilePreferences.reduce((byPref, prefName) => {
+            byPref[prefName] = this.responses.find(
+                r => config[`${prefName}Key`] == r.response_key_id,
             ).val
-            this.profile_media = this.responses
-                .filter(r => r.response_key_id === config.mediaKey)
-                .map(r => r.val)
-            this.profile_languages = this.responses
-                .filter(r => r.response_key_id === config.langKey)
-                .map(r => r.val)
-        }
+            return byPref
+        }, {})
+    }
+    getPrefsFromResponses(responses) {
+        if (!responses.length) return
+        const prefs = {}
+        unscoredProfilePreferences.forEach(prefName => {
+            prefs[prefName] = this.byPrefName[prefName]
+        })
+        return prefs
     }
 }
-const _makeCompleteProfile = (
-    profileEntry,
-    type,
-    tagLookup,
-    includeResponses,
-) => {
+const _makeCompleteProfile = (profileEntry, type, tagLookup) => {
     profileEntry.tags = profileEntry.tags.map(tag => tagLookup[tag.tag_id])
-    return new CompleteProfile(profileEntry, includeResponses, type)
+    return new CompleteProfile(profileEntry, type)
 }
 
 const makeOrderedCompleteProfiles = (
     orderedProfileIds,
     profilesEntries,
     type,
-    includeResponses,
     tagLookup,
 ) => {
-    const completeProfiles = []
-    orderedProfileIds.forEach(pid => {
-        profilesEntries.forEach(entry => {
-            if (entry.profile_id != pid) return
-            completeProfiles.push(
-                _makeCompleteProfile(entry, type, tagLookup, includeResponses),
-            )
+    return orderedProfileIds.map(pid => {
+        const foundEntry = profilesEntries.find(entry => {
+            pid == entry.profile_id
         })
+        return _makeCompleteProfile(foundEntry, type, tagLookup)
     })
-    return completeProfiles
 }
 const makeCompleteFromProfileEntries = (profilesEntries, type, tagLookup) =>
     profilesEntries.map(entry => _makeCompleteProfile(entry, type, tagLookup))

backend/lib/services/profile/scorer.js

     return scoreLookup
 }
 
-const _isScorableResponse = res_key_id => {
-    let isScorable = false
-    if (config.resKeys.includes(res_key_id)) {
-        isScorable = true
-    }
-    return isScorable
-}
+const _isScorableResponse = res_key_id =>
+    config.scoreKeys.includes(res_key_id) ? true : false
 
 const scoreResponses = (seeker, potentialMatch, prescoreLookup) => {
     if (seeker.responses.length != potentialMatch.responses.length)

frontend/src/services/notification.service.js

         }
     }
     _appendTagsToGrouping(parsed) {
-        const foundGrouping = currentProfile.groupings.find(grouping =>
-            grouping.grouping_id === parsed.grouping_id
+        const foundGrouping = currentProfile.groupings.find(
+            grouping => grouping.grouping_id === parsed.grouping_id,
         )
         if (foundGrouping) {
             const tagFromNotification = {
                 is_active: 1,
-                tag_category: "reveal",
+                tag_category: 'reveal',
                 profile_id: parsed.profile_id,
                 tag_description: parsed.description,
                 tag_id: parsed.tag,
             const target_desc = parsed.description
             tagFromNotification[target_desc] = parsed.revealed_info
             foundGrouping.profile.reveal.push(tagFromNotification)
-            foundGrouping.revealedFromNotification.value.push(tagFromNotification)
+            foundGrouping.revealedFromNotification.value.push(
+                tagFromNotification,
+            )
         }
     }
 }

frontend/src/views/SurveyView.vue

                                 @input='storeResponseLike(step, q.response_key_id, q.response_key_prompt, profile[q.response_key_prompt])'
                                 @keyup.enter='step++'
                                 v-model='profile[q.response_key_prompt]'
-                            ) 
+                            )
                             label >{{ profile[q.response_key_prompt] }}
 
                         //- Aspects
     signupUser,
 } from '@/services'
 
-import { maxDistanceKey } from '../../../backend/db/data-generator/config.json'
+import { distanceKey } from '../../../backend/db/data-generator/config.json'
 
 export default {
     props: {
                 Object.values(this.responseLikes),
             )
             const maxDistanceRes = survey.find(
-                res => res.response_key_id == maxDistanceKey,
+                res => res.response_key_id == distanceKey,
             )
             /**
              * Creating a profile only returns the created