:sparkles: new reveal api endpoint | send messages on reveal tag creation | create tags in chat

backend/db/data-generator/mock.js

             tag_description: 'urgency',
             is_active: true,
         },
+        {
+            tag_id: 7,
+            tag_category: 'reveal',
+            tag_description: 'user_name',
+            is_active: true,
+        },
+        {
+            tag_id: 8,
+            tag_category: 'reveal',
+            tag_description: 'user_email',
+            is_active: true,
+        },
     ],
     tag_associations: [
         {
             tag_id: 5,
             is_deleted: false,
         },
+        {
+            tag_association_id: 8,
+            profile_id: 41,
+            grouping_id: 1,
+            tag_id: 4,
+            is_deleted: false,
+        },
+        {
+            tag_association_id: 9,
+            profile_id: 41,
+            grouping_id: 1,
+            tag_id: 5,
+            is_deleted: false,
+        },
     ],
     response_keys: [
         {

backend/lib/plugins/membership.js

 const MembershipJoinRoute = require('../routes/membership/join')
 const MembershipLeaveRoute = require('../routes/membership/leave')
 const MembershipActiveRoute = require('../routes/membership/active')
+const MembershipRevealRoute = require('../routes/membership/reveal')
 
 module.exports = {
     name: 'membership-plugin',
         await server.route(MembershipJoinRoute)
         await server.route(MembershipLeaveRoute)
         await server.route(MembershipActiveRoute)
+        await server.route(MembershipRevealRoute)
     },
 }

backend/lib/routes/membership/active.js

             let memberships = await membershipService.findMemberships(
                 groupings.map(grouping => grouping.grouping_id),
             )
-            // console.log('groupings :>> ', memberships)
 
             /**
              * Heavily process the result by storing just a profile_id

backend/lib/routes/membership/reveal.js

+const Joi = require('joi')
+
+const apiSchema = require('../../schemas/api')
+const errorSchema = require('../../schemas/errors')
+
+const pluginConfig = {
+    handlerType: 'reveal',
+    docs: {
+        description: 'reveal',
+        notes: 'Reveal profile information to a grouping by membership',
+    },
+}
+
+const validators = {
+    params: Joi.object({ grouping_id: Joi.number() }),
+    query: Joi.object({ profile_id: Joi.number(), tag_id: Joi.number() }),
+}
+
+const responseSchemas = {
+    response: Joi.object({
+        tags: Joi.array().items(),
+    }),
+    error: errorSchema.single,
+}
+module.exports = {
+    method: 'POST',
+    path: '/{grouping_id}/reveal',
+    options: {
+        ...pluginConfig.docs,
+        tags: ['api'],
+        auth: false,
+        cors: true,
+        handler: async function (request, h) {
+            const { membershipService, profileService } =
+                request.server.services()
+            const grouping_id = request.params.grouping_id
+            const { profile_id, tag_id } = request.query
+            try {
+                const tags = await profileService.revealProfileInfo({
+                    profile_id,
+                    grouping_id,
+                    tag_id,
+                    is_deleted: false,
+                })
+
+                // Notify both profiles that information has been revealed
+                const memberships = await membershipService.findMemberships([
+                    grouping_id,
+                ])
+                const idsInGroup = memberships.map(
+                    membership => membership.profile_id,
+                )
+                idsInGroup.forEach(profile_id => {
+                    request.server.methods.notify(
+                        `${profile_id}.stonk`,
+                        {
+                            name: 'REVEALED INFO',
+                            tag: tag_id,
+                            type: 'info',
+                        },
+                        h,
+                    )
+                })
+                return h
+                    .response({
+                        ok: true,
+                        handler: pluginConfig.handlerType,
+                        data: { tags },
+                    })
+                    .code(200)
+            } catch (err) {
+                return h
+                    .response({
+                        ok: false,
+                        handler: pluginConfig.handlerType,
+                        data: { error: `${err}` },
+                    })
+                    .code(409)
+            }
+        },
+
+        /** Validate based on validators object */
+        validate: {
+            ...validators,
+            failAction: 'log',
+        },
+
+        /** Validate the server response */
+        response: {
+            status: {
+                200: apiSchema.single
+                    .append({
+                        data: responseSchemas.response,
+                    })
+                    .label('reveal_res'),
+                409: apiSchema.single
+                    .append({
+                        data: responseSchemas.error,
+                    })
+                    .label('error_single_res'),
+            },
+        },
+    },
+}

backend/lib/services/profile/index.js

     async revealProfileInfo(association) {
         const { TagAssociation } = this.server.models()
         await TagAssociation.query().insert(association)
+
         return await this.getTagsFor(association.profile_id)
     }
 }

backend/lib/services/profile/profiler.js

         this.user_email = profile.user.user_email
         this.responses = []
         this.user_type = type
-        this.tags = profile.tags.filter(t => t.category != 'reveal')
+        this.tags = profile.tags.filter(t => t.tag_category != 'reveal')
 
         // TODO: generalize this for multiple images, and languages
         this.profile_description = ''

frontend/src/entities/card/card.js

 
         this.images = []
         this.tags = []
+        this.reveal = {}
 
         this.summary = new SummaryGroup()
 

frontend/src/entities/grouping/grouping.js

 
 import { _baseRecord } from '../index.js'
 import { groupingSchema } from './grouping.schema.js'
+// import { revealProfileInfo } from '../../services/profile.service.js'
 
 /** Class representing a grouping */
 class Grouping extends _baseRecord {
 
         return this
     }
+    get revealed() {
+        const revealed = {}
+        this.tags
+            .filter(assoc => assoc.tag.tag_category == 'reveal')
+            .forEach(assoc => {
+                if (!revealed[assoc.profile_id]) {
+                    revealed[assoc.profile_id] = []
+                }
+                revealed[assoc.profile_id].push({
+                    description: assoc.tag.tag_description,
+                })
+            })
+        return revealed
+    }
+    get participants() {
+        return [this.profile.profile_id]
+    }
+    async reveal(profileId, tagId) {
+        // return await revealProfileInfo(profileId, tagId)
+    }
     /**
      * validate this record
      * @return {boolean} is it valid or not?

frontend/src/services/grouping.service.js

         memberships = await db.get(`/membership/${profileId}`)
         for (let membership of memberships) {
             const grouping = new Grouping(membership)
-            grouping.tags = await db.get(
-                `/profile/${profileId}/tags/${grouping.grouping_id}`,
-            )
             if (grouping.isValid()) {
                 // Reformat incoming profile data into Profile entity
                 grouping.profile = new Profile(grouping.profile)
+                const targetTags = await db.get(
+                    `/profile/${grouping.profile.profile_id}/tags/${grouping.grouping_id}`,
+                )
+                const profileTags = await db.get(
+                    `/profile/${profileId}/tags/${grouping.grouping_id}`,
+                )
+                grouping.tags = [...targetTags, ...profileTags]
+                console.log('grouping.tags :>> ', grouping.tags)
                 validGroupingInstances.push(grouping)
             }
         }
     )
     return { membershipMatch, groupingName: membership.grouping_name }
 }
-export { fetchMembershipsByProfileId, postMembershipByProfileId }
+
+const revealProfileInfo = async (membershipId, profileId, tagId) => {
+    const revealed = await db.post(
+        `/membership/${membershipId}/reveal?profile=${profileId}&tag=${tagId}`,
+    )
+    return revealed
+}
+
+export {
+    fetchMembershipsByProfileId,
+    postMembershipByProfileId,
+    revealProfileInfo,
+}

frontend/src/services/login.service.js

         this.id = ref(null)
 
         this.groupings = []
-        this.responses = []
-
         this.queue = []
         this.responses = []
         this.tags = []

frontend/src/views/ChatView.vue

 <template lang="pug">
 main.view--chat
-    header.mb6(v-if='profile')
+    header.mb6(v-if='profile && grouping')
         h3 chatting with: {{ target.profile_id }}
-        p subscriptions: {{ profile.chatter.subscriptions }}
+        p {{ grouping.profile.user_name }}
+        p {{ grouping.profile.user_email }}
+        p {{ grouping.profile }}
+        //- p subscriptions: {{ profile.chatter.subscriptions }}
+        .w-flex.column
+            p reveal: {{ grouping.revealed }}
+            .w-flex.row
+                button(@click='reveal(7)') my name
+                button(@click='reveal(8)') my email
 
     article
         template(v-if='isLoading')
         messages: [],
         openDrawer: null,
     }),
+    computed: {
+        grouping() {
+            return this.profile.groupings.find(profileGrouping =>
+                profileGrouping.participants.includes(
+                    parseInt(this.$route.params.pid),
+                ),
+            )
+        },
+    },
     watch: {
         profile() {
             this.loadTargetProfile()
         currentProfile.chatter.setOnMessage(this._onMessage)
     },
     methods: {
+        reveal(tagId) {
+            this.grouping.reveal(currentProfile.profile_id, tagId)
+        },
         /**
          * Pubnub message callback fires when message event
          * is detected. We define is HERE because we need the