:recycle: added test reveal profile 45 to mock | adjusted mock tags | refactored CompleteProfile creation

backend/db/data-generator/config.json

     "mockOutputPath": "./db/generated",
     "magic": 1000,
     "total": 100,
-    "ignore": [45],
+    "ignore": [],
     "batchSize": 10,
     "percentageOfSeekers": 90,
     "scoreVals": [1, 2, 3, 4, 5, 6, 7],

backend/db/data-generator/mock.js

             tag_association_id: 5,
             profile_id: 45,
             grouping_id: 2,
-            tag_id: 4,
+            tag_id: 8,
             is_deleted: false,
         },
         {

backend/lib/services/profile/index.js

 const profiler = require('./profiler')
 const scoring = require('./scorer')
 const zipcoder = require('./zipcoder')
-const tagger = require('./tagger')
 
 module.exports = class ProfileService extends Schmervice.Service {
     constructor(...args) {
         }
     }
     async _setTagLookup() {
-        if (!Object.keys(this.tagLookup).length) {
-            const { Tag } = this.server.models()
-            const allTagDescriptions = await Tag.query()
-            allTagDescriptions.forEach(desc => {
-                if (desc.is_active) {
-                    this.tagLookup[desc.tag_id] = desc
-                }
-            })
-        }
+        /** Grab tag descriptions if they do NOT exist: Needed once per app load */
+        if (Object.keys(this.tagLookup).length) return
+        const { Tag } = this.server.models()
+        const allTagDescriptions = await Tag.query()
+        allTagDescriptions.forEach(desc => {
+            if (!desc.is_active) return
+            this.tagLookup[desc.tag_id] = desc
+        })
     }
     /**
      * Internal method to get list of profile_ids for this user
     async getProfile(profileId) {
         const { Profile } = this.server.models()
         await this._setTagLookup()
-
         const matchingProfile = await Profile.query()
             .where('profile_id', profileId)
             .first()
             .withGraphFetched('tags')
             .withGraphFetched('responses')
             .withGraphFetched('user')
-        tagger.setProfileTags(matchingProfile, matchingProfile, this.tagLookup)
+        matchingProfile.tags = matchingProfile.tags.map(
+            tag => this.tagLookup[tag.tag_id],
+        )
         const complete = new profiler.CompleteProfile(matchingProfile, true)
         return this.setDefaults(complete)
     }
             // so without this, we get undefined user_name
             .withGraphFetched('user')
 
-        return profiler.makeCompleteProfilesFromProfile(
+        return profiler.makeCompleteFromProfileEntries(
             profilesEntries,
             type,
             this.tagLookup,
         // taking the info from profilesEntries
         // to repack into completeProfiles
         // in same order as profileIdArray
-        return profiler.makeCompleteProfiles(
+        return profiler.makeOrderedCompleteProfiles(
             profileIdArray,
             profilesEntries,
             type,
      * @param {object} complete
      * @returns {object} updated profile
      */
-    setDefaults(complete){
+    setDefaults(complete) {
         let defaultValues = {
             user_email: 'hidden@email.com',
-            user_name: 'Hidden Name'
+            user_name: 'Hidden Name',
         }
 
         let defaultProfile = {
             user_email: defaultValues.user_email,
             user_name: defaultValues.user_name,
         }
-        console.log('defaultProfile: ', defaultProfile)
-        if(!complete.reveal.length) return defaultProfile // nothing to reveal 
+        console.log('---')
+        console.log('defaultProfile: ', defaultProfile.user_email)
+        if (!complete.reveal.length) return defaultProfile // nothing to reveal
 
         // swap out values of keys that are not found as complete.reveal.tag.tag_description values
-        for(let [attribute, defaultVal] of Object.entries(defaultValues)){
-            if(typeof complete.reveal.find(tag => tag.tag_description == attribute) == 'undefined') complete[attribute] = defaultVal 
+        for (let [attribute, defaultVal] of Object.entries(defaultValues)) {
+            if (
+                typeof complete.reveal.find(
+                    tag => tag.tag_description == attribute,
+                ) == 'undefined'
+            )
+                complete[attribute] = defaultVal
         }
-        console.log('complete: ', complete)
+        console.log('complete: ', complete.user_email)
 
         return complete
     }
         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')
-const tagger = require('./tagger')
 
 /**
  * Class to hold our retrieved profile information
         // TODO: Use reveal tags to rebuild profile based on group/membership
         // TODO: and include for certain profiles
 
-        this.reveal = profile.tags.filter(t => t.category == 'reveal')
+        this.reveal = profile.tags.filter(t => t.tag_category == 'reveal')
         // TODO: filter these correctly
         if (profile?.responses?.length && includeResponses) {
             // [] of all "profile" responses
             ]
             const prefsKeys = config.prefKeys
             prefs.forEach((pref, i) => {
-                this.profile_prefs[pref] = this.responses.filter(
+                this.profile_prefs[pref] = this.responses.find(
                     r => r.response_key_id === prefsKeys[i],
-                )[0]
+                )
             })
-            this.profile_description = this.responses
-                .filter(r => r.response_key_id === config.blurbKey)
-                .map(r => r.val)[0]
+            this.profile_description = this.responses.find(
+                r => r.response_key_id === config.blurbKey,
+            ).val
             this.profile_media = this.responses
                 .filter(r => r.response_key_id === config.mediaKey)
                 .map(r => r.val)
         }
     }
 }
+const _makeCompleteProfile = (
+    profileEntry,
+    type,
+    tagLookup,
+    includeResponses,
+) => {
+    profileEntry.tags = profileEntry.tags.map(tag => tagLookup[tag.tag_id])
+    return new CompleteProfile(profileEntry, includeResponses, type)
+}
 
-const makeCompleteProfiles = (
-    profileIdArray,
+const makeOrderedCompleteProfiles = (
+    orderedProfileIds,
     profilesEntries,
     type,
     includeResponses,
     tagLookup,
 ) => {
     const completeProfiles = []
-    profileIdArray.forEach(pid => {
+    orderedProfileIds.forEach(pid => {
         profilesEntries.forEach(entry => {
-            if (entry.profile_id == pid) {
-                const complete = new CompleteProfile(
-                    entry,
-                    type,
-                    includeResponses,
-                )
-                tagger.setProfileTags(entry, complete, tagLookup)
-                completeProfiles.push(complete)
-            }
+            if (entry.profile_id != pid) return
+            completeProfiles.push(
+                _makeCompleteProfile(entry, type, tagLookup, includeResponses),
+            )
         })
     })
     return completeProfiles
 }
-const makeCompleteProfilesFromProfile = (profilesEntries, type, tagLookup) => {
-    profilesEntries.forEach(profile => {
-        tagger.setProfileTags(profile, profile, tagLookup)
-    })
-
-    //** Get responses asociated with each profile_id */
-    return profilesEntries.map(profile => {
-        return new CompleteProfile(profile, type)
-    })
-}
+const makeCompleteFromProfileEntries = (profilesEntries, type, tagLookup) =>
+    profilesEntries.map(entry => _makeCompleteProfile(entry, type, tagLookup))
 
 module.exports = {
     CompleteProfile,
-    makeCompleteProfiles,
-    makeCompleteProfilesFromProfile,
+    makeOrderedCompleteProfiles,
+    makeCompleteFromProfileEntries,
 }

backend/lib/services/profile/tagger.js

-const setProfileTags = (inProfile, outProfile, tagLookup) => {
-    outProfile.tags = inProfile.tags.map(tag => tagLookup[tag.tag_id])
-}
-
-module.exports = {
-    setProfileTags,
-}