Merge branch 'brian_dev_146' of fyindr/siimee into dev

.gitignore

@@ -6,4 +6,5 @@ dist-ssr
 **/.env
 .nyc_output
 **/generated/_*
-**/.vscode
+**/.vscode
+**/*.vim

backend/db/data-generator/config.json

@@ -30,12 +30,17 @@
         "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

@@ -138,10 +138,10 @@ const generateResponses = profiles => {
                     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

@@ -62,48 +62,72 @@ module.exports = {
         auth: false,
         cors: true,
         handler: async function (request, h) {
-            const { membershipService, profileService } =
+            const { membershipService, profileService, userService } =
                 request.server.services()
             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
-            }, [])
+                return grouping
+            })
 
-            /** Assemble complete profiles to reference and pass */
-            const completedProfiles = await profileService.getProfilesFor(
-                pIds,
-                'participant',
-                false,
+            /** Grabs revealTags */
+            const revealTags = await profileService.getTagsFor(
+                profileIds,
+                groupingIds,
+                '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 user = await userService.findById(
+                completedProfiles.map(p => p.user_id),
             )
-            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/routes/membership/reveal.js

@@ -31,12 +31,12 @@ module.exports = {
         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
             try {
-                const tags = await profileService.revealProfileInfo({
+                const associations = await profileService.revealProfileInfo({
                     profile_id,
                     grouping_id,
                     tag_id,
@@ -50,39 +50,44 @@ module.exports = {
                 const idsInGroup = memberships.map(
                     membership => membership.profile_id,
                 )
-
+                if (idsInGroup.length > 2)
+                    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
-                // TODO: Refactor completeProfile[0]... code smell
-                const revealInfo = completeProfile[0][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,
@@ -92,7 +97,7 @@ module.exports = {
                     .response({
                         ok: true,
                         handler: pluginConfig.handlerType,
-                        data: { tags },
+                        data: { tags: associations },
                     })
                     .code(200)
             } catch (err) {

backend/lib/routes/profile/queue.js

@@ -23,7 +23,11 @@ const responseSchemas = {
 
 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 = {
@@ -37,17 +41,16 @@ 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
@@ -57,15 +60,17 @@ module.exports = {
             //     '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/schemas/profiles.js

@@ -13,6 +13,8 @@ const singleProfile = Joi.object({
     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/index.js

@@ -62,8 +62,7 @@ module.exports = class ProfileService extends Schmervice.Service {
         matchingProfile.tags = matchingProfile.tags.map(
             tag => this.tagLookup[tag.tag_id],
         )
-        const complete = new profiler.CompleteProfile(matchingProfile, true)
-        return this.setDefaults(complete)
+        return new profiler.CompleteProfile(matchingProfile)
     }
 
     async getCompleteProfilesFor(userId, type) {
@@ -76,8 +75,6 @@ module.exports = class ProfileService extends Schmervice.Service {
             .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(
@@ -87,12 +84,12 @@ module.exports = class ProfileService extends Schmervice.Service {
         )
     }
 
-    async getProfilesFor(profileIdArray, type, includeResponses = true) {
+    async getProfilesFor(profileIdArray, type) {
         const { Profile } = this.server.models()
         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')
@@ -106,7 +103,6 @@ module.exports = class ProfileService extends Schmervice.Service {
             profileIdArray,
             profilesEntries,
             type,
-            includeResponses,
             this.tagLookup,
         )
     }
@@ -225,40 +221,6 @@ module.exports = class ProfileService extends Schmervice.Service {
         return allResponses
     }
 
-    /**
-     * Sets default profile attributes
-     * @param {object} complete
-     * @returns {object} updated profile
-     */
-    setDefaults(complete) {
-        let defaultValues = {
-            user_email: 'hidden@email.com',
-            user_name: 'Hidden Name',
-        }
-
-        let defaultProfile = {
-            ...complete,
-            user_email: defaultValues.user_email,
-            user_name: defaultValues.user_name,
-        }
-        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
-        }
-        console.log('complete: ', complete.user_email)
-
-        return complete
-    }
-
     /**
      * Delete a profile
      * @param {number} userId
@@ -422,7 +384,7 @@ module.exports = class ProfileService extends Schmervice.Service {
             await TagAssociation.query().insert(association)
             return await this.getTagsFor(association.profile_id)
         } else {
-            return console.error('tag association already exists')
+            return console.error('ERROR =>: tag association already exists')
         }
     }
 }

backend/lib/services/profile/profiler.js

@@ -1,93 +1,110 @@
 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 = profile.user.user_name // string user_name
-        this.user_email = profile.user.user_email
-        this.responses = []
+        this.responses = profile.responses
         this.user_type = type
-        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 = {}
-
-        // 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)
+    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,
     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 found = profilesEntries.find(entry => entry.profile_id == pid)
+        return _makeCompleteProfile(found, type, tagLookup)
     })
-    return completeProfiles
 }
-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,

backend/lib/services/profile/scorer.js

@@ -18,13 +18,8 @@ const makeScoreLookup = (aspects, labels) => {
     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/components/NamePlate.vue

@@ -3,7 +3,6 @@
     section(:class='{ box: !isList }' v-if='pid')
         router-link(:to='`/profile/${pid}`' disabled)
             h1.text-capitalize {{ name }}
-                span O
             p.text-capitalize {{ role }} 
                 span.text-capitalize(v-if='isList')
                     span.text-capitalize | {{ locale }}

frontend/src/components/ProfileCard.vue

@@ -66,8 +66,9 @@ import TagList from './TagList.vue'
 import PairingButton from './PairingButton.vue'
 
 const router = useRouter()
-const isPaired = ref(true)
-// const isPaired = ref(false)
+// NOTE: toggle to use for testing pairing
+// const isPaired = ref(true)
+const isPaired = ref(false)
 
 const props = defineProps({
     card: {

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

@@ -27,6 +27,8 @@ const profileSchema = {
         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/entities/response/response.schema.js

@@ -8,7 +8,9 @@ const responseSchema = Joi.object({
     profile_id: Joi.number(),
     response_id: Joi.number(),
     response_key_id: Joi.number(),
-    val: Joi.string(),
+    // TODO: troubleshoot later, suppressed validation warning for now
+    // val: Joi.string(),
+    val: Joi.any(),
 })
 
 export { responseSchema }

frontend/src/services/grouping.service.js

@@ -1,6 +1,6 @@
 import { db } from '../utils/db.js'
 import { Grouping, Profile } from '../entities/index.js'
-
+import { ref } from 'vue'
 /**
  * Get Memberships associated with a single Profile from the database and
  * create a class from the data and
@@ -26,6 +26,7 @@ const fetchMembershipsByProfileId = async profileId => {
                     `/profile/${profileId}/tags/${grouping.grouping_id}`,
                 )
                 grouping.tags = [...targetTags, ...profileTags]
+                grouping.revealedFromNotification = ref([])
                 grouping._loading.value = false
                 validGroupingInstances.push(grouping)
             }

frontend/src/services/notification.service.js

@@ -44,19 +44,23 @@ class StonkAlert extends Toaster {
         }
     }
     _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
+                tag_id: parsed.tag,
             }
             const target_desc = parsed.description
             tagFromNotification[target_desc] = parsed.revealed_info
-            foundGrouping.profile.tags.push(tagFromNotification)
+            foundGrouping.profile.reveal.push(tagFromNotification)
+            foundGrouping.revealedFromNotification.value.push(
+                tagFromNotification,
+            )
         }
     }
 }

frontend/src/views/ChatView.vue

@@ -2,8 +2,13 @@
 main.view--chat
     header.mb6(v-if='profile && grouping')
         h3 chatting with:
-        p {{ target.profile_id }} | {{ grouping.profile.user_name }} | {{ grouping.profile.user_email }}
-
+        span {{ target.profile_id }} | 
+        span(v-if="grouping.revealedFromNotification.length")
+            span(v-for="revealed in grouping.revealedFromNotification")
+                span(v-if="revealed.profile_id === target.profile_id")
+                    span {{ revealed[revealed.tag_description] }} | 
+        span(v-else)
+            span  {{ grouping.profile.user_name }} | {{ grouping.profile.user_email }}
         h3 logged in as:
         p {{ profile.id }} | {{ profile._profile.user_name }} | {{ profile._profile.user_email }}
         //- p subscriptions: {{ profile.chatter.subscriptions }}
@@ -15,14 +20,18 @@ main.view--chat
                 button(@click='reveal(8)') reveal my email
                 // TODO: Remove later, only for testing
                 button(@click='checkData()') check data
-            p you revealed:
-                span(v-if="grouping.revealed[profile.id.value]")
-                    ul(v-for="reveal in grouping.revealed[profile.id.value]")
-                        li {{ reveal.description }} : {{ profile._profile[reveal.description] }}
-            p they revealed:
-                span(v-if="theyRevealed")
-                    ul(v-for="reveal in theyRevealed")
-                        li {{ reveal.description }} : {{ grouping.profile[reveal.description] }}
+            span(v-if="grouping.revealed[profile.id.value]")
+                p you revealed:
+                ul(v-for="reveal in [...new Set(grouping.revealed[profile.id.value])]")
+                    li {{ reveal.description }}
+            span(v-if="grouping.revealed[target.profile_id]")
+                p they revealed:
+                ul(v-for="reveal in grouping.revealed[target.profile_id]")
+                    li {{ reveal.description }}: {{ target[reveal.description] }}
+            span(v-if="grouping.revealedFromNotification.length")
+                p recently revealed:
+                ul(v-for="revealed in grouping.revealedFromNotification")
+                    li(v-if="revealed[revealed.tag_description] !== profile._profile[revealed.tag_description]") {{ revealed.tag_description }}: {{ revealed[revealed.tag_description] }}
 
     article
         template(v-if='isLoading')
@@ -66,14 +75,13 @@ export default {
         toSend: '',
         messages: [],
         grouping: {},
+        them: {},
     }),
     // TODO: Make sure grouping.profile.profile_id actually exists
     computed: {
         theyRevealed() {
-            return this.grouping && this.grouping.revealed[this.grouping.profile.profile_id] ?
-                this.grouping.revealed[this.grouping.profile.profile_id] :
-                []
-        }
+            return this.them
+        },
     },
     watch: {
         async profile() {
@@ -88,6 +96,7 @@ export default {
         this.loadTargetProfile()
         currentProfile._loading.value = true
         this.grouping = this.getGrouping()
+        this.them = this.grouping.profile
         this.messages = await currentProfile.chatter.getHistory(this.grouping.grouping_name)
         console.log('this.messages :>> ', this.messages)
         currentProfile.chatter.setOnMessage(this._onMessage)
@@ -100,7 +109,7 @@ export default {
          },
         // TODO: remove, only for testing reveal()
         async checkData() {
-            console.log(currentProfile)
+            console.log('currentProfile :=>', currentProfile)
         },
         /**
          * Pubnub message callback fires when message event
@@ -113,6 +122,9 @@ export default {
         },
         // TODO: test this
         getGrouping() {
+            if (this.$route.params.pid === currentProfile.profile_id) {
+                console.warn('WARNING :=> You cannot chat with yourself!!!')
+            }
             return currentProfile.groupings.find(
                 g => g.profile.profile_id == this.$route.params.pid,
             )

frontend/src/views/SurveyView.vue

@@ -30,7 +30,7 @@ main.view--survey.f-col.start.w-full
                                 @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
@@ -85,7 +85,7 @@ import {
     signupUser,
 } from '@/services'
 
-import { maxDistanceKey } from '../../../backend/db/data-generator/config.json'
+import { distanceKey } from '../../../backend/db/data-generator/config.json'
 
 export default {
     props: {
@@ -248,7 +248,7 @@ export default {
                 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