:recycle: uisng grouping_id for tag_associations and storing on group

backend/db/data-generator/mock.js

         {
             tag_association_id: 1,
             profile_id: 1,
-            membership_id: null,
+            grouping_id: null,
             tag_id: 1,
             is_deleted: false,
         },
         {
             tag_association_id: 2,
             profile_id: 2,
-            membership_id: null,
+            grouping_id: null,
             tag_id: 1,
             is_deleted: false,
         },
         {
             tag_association_id: 3,
             profile_id: 3,
-            membership_id: null,
+            grouping_id: null,
             tag_id: 1,
             is_deleted: false,
         },
         {
             tag_association_id: 4,
             profile_id: 45,
-            membership_id: null,
+            grouping_id: null,
             tag_id: 1,
             is_deleted: false,
         },
         {
             tag_association_id: 5,
             profile_id: 45,
-            membership_id: 1,
+            grouping_id: 2,
             tag_id: 4,
             is_deleted: false,
         },
         {
             tag_association_id: 6,
             profile_id: 45,
-            membership_id: 1,
+            grouping_id: 2,
             tag_id: 5,
             is_deleted: false,
         },
         {
             tag_association_id: 7,
             profile_id: 2,
-            membership_id: 1,
+            grouping_id: 2,
             tag_id: 5,
             is_deleted: false,
         },
         {
             response_key_id: 1,
             response_key_category: 'visionary_vs_implementer',
-            response_key_prompt: 'While managing your team, do you find success in your employees being more Visionary or Implementer?',
+            response_key_prompt:
+                'While managing your team, do you find success in your employees being more Visionary or Implementer?',
             response_key_description: 'first round draft scoring question',
         },
         {

backend/db/migrations/20220403111037_create_tag_associations_table.js

     return knex.schema.createTable('tag_associations', function (table) {
         table.increments('tag_association_id').primary()
         table.integer('profile_id').notNullable()
-        table.integer('membership_id')
+        table.integer('grouping_id')
         table.integer('tag_id').notNullable()
         table.boolean('is_deleted').notNullable()
     })

backend/lib/plugins/profile.js

 const ProfileGetRoute = require('../routes/profile/get')
 const ProfilePatchQueueRoute = require('../routes/profile/patch-queue')
 const TagRevealRoute = require('../routes/tag/reveal')
+const TagGetRoute = require('../routes/tag/get')
 
 module.exports = {
     name: 'profile-plugin',
         await server.route(ProfileGetRoute)
         await server.route(ProfilePatchQueueRoute)
         await server.route(TagRevealRoute)
+        await server.route(TagGetRoute)
     },
 }

backend/lib/routes/tag/get.js

+'use strict'
+
+const apiSchema = require('../../schemas/api')
+const errorSchema = require('../../schemas/errors')
+const params = require('../../schemas/params')
+const Joi = require('joi')
+
+const pluginConfig = {
+    handlerType: 'get',
+    docs: {
+        description: 'Get tags based on membership id',
+        notes: 'returns from the Tag Associations Table',
+    },
+}
+
+const responseSchemas = {
+    tags: Joi.array().items(Joi.object()),
+    error: errorSchema.single,
+}
+
+const validators = {
+    params: Joi.object({
+        profile_id: params.profileId,
+        grouping_id: params.groupingId,
+    }),
+    query: Joi.object({ category: Joi.string() }),
+}
+
+module.exports = {
+    method: 'GET',
+    path: '/{profile_id}/tags/{grouping_id}',
+    options: {
+        ...pluginConfig.docs,
+        tags: ['api'],
+        /** Protect this route with authentication? */
+        auth: false,
+        cors: true,
+        handler: async function (request, h) {
+            const { grouping_id, profile_id } = request.params
+            const { profileService } = request.server.services()
+            const { category } = request.query
+            const revealedTags = await profileService.getTagsFor(
+                profile_id,
+                grouping_id,
+                category,
+            )
+            try {
+                return h
+                    .response({
+                        ok: true,
+                        handler: pluginConfig.handlerType,
+                        data: revealedTags,
+                    })
+                    .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.tags,
+                    })
+                    .label('tags_res'),
+                409: apiSchema.single
+                    .append({
+                        data: responseSchemas.error,
+                    })
+                    .label('error_single_res'),
+            },
+        },
+    },
+}

backend/lib/routes/tag/reveal.js

 
 const apiSchema = require('../../schemas/api')
 const errorSchema = require('../../schemas/errors')
-const profileSchema = require('../../schemas/profiles')
 const params = require('../../schemas/params')
 const Joi = require('joi')
 
                 tag_id,
                 is_deleted: false,
             })
-            console.log('revealed :', revealedTags)
-
             try {
                 const tag = profileService.tagLookup[tag_id]
                 if (!tag || tag.tag_category != 'reveal') {

backend/lib/schemas/params.js

 const Joi = require('joi')
 
 module.exports = {
-    profileId: Joi.object({ profile_id: Joi.number() }).label('profile_id_param'),
+    profileId: Joi.object({ profile_id: Joi.number() }).label(
+        'profile_id_param',
+    ),
+    groupingId: Joi.object({ grouping_id: Joi.number() }).label(
+        'grouping_id_param',
+    ),
     profileInclude: Joi.object({ include_profile: Joi.bool() }),
     userId: Joi.object({ user_id: Joi.number() }).label('user_id_param'),
     userName: Joi.object({
         name: Joi.string().min(3).max(11),
         all: Joi.array(),
     }).label('user_name_param'),
-    userEmail: Joi.object({ user_email: Joi.string() }).label('user_email_param')
-}
+    userEmail: Joi.object({ user_email: Joi.string() }).label(
+        'user_email_param',
+    ),
+}

backend/lib/schemas/tags.js

 const singleTagAssociation = Joi.object({
     tag_association_id: Joi.number(),
     profile_id: Joi.number().required(),
-    membership_id: Joi.number(),
+    grouping_id: Joi.number(),
     tag_id: Joi.number().required(),
     is_deleted: Joi.boolean().required(),
 }).label('tag_association_single')

backend/lib/services/profile/index.js

      * @param {number} profileId
      * @param {object}
      */
-    async _getTagsForProfile(profileId) {
+    async getTagsFor(profileId, groupingId, category) {
         const { TagAssociation } = this.server.models()
         await this._setTagLookup()
-        const associations = await TagAssociation.query().where(
-            'profile_id',
-            profileId,
-        )
-        return associations.map(assoc => {
-            const tagInfo = this.tagLookup[assoc.tag_id]
-            return { ...assoc, tag: tagInfo }
-        })
+        let associations = groupingId
+            ? await TagAssociation.query()
+                  .where('grouping_id', groupingId)
+                  .andWhere('profile_id', profileId)
+            : await TagAssociation.query().andWhere('profile_id', profileId)
+        return associations
+            .map(assoc => ({
+                ...assoc,
+                tag: this.tagLookup[assoc.tag_id],
+            }))
+            .filter(tagWithAssoc => {
+                return category
+                    ? tagWithAssoc.tag.tag_category == category
+                    : true
+            })
     }
     async revealProfileInfo(association) {
         const { TagAssociation } = this.server.models()
         await TagAssociation.query().insert(association)
-        return await this._getTagsForProfile(association.profile_id)
+        return await this.getTagsFor(association.profile_id)
     }
 }

frontend/src/components/PairsList.vue

                     p since: {{ pair.grouping.createdAt }}
                     p updated: {{ pair.grouping.lastUpdatedAt }}
                     p paired: {{ pair.grouping.is_paired }}
+                    p revealed tags: {{ pair.grouping.tags }}
     p(v-else) No {{ tabName }} profiles.
 </template>
 

frontend/src/components/ProfileCard.vue

 import PairingButton from './PairingButton.vue'
 
 const router = useRouter()
-const isPaired = ref(true)
-// const isPaired = ref(false)
+// const isPaired = ref(true)
+const isPaired = ref(false)
 
 const props = defineProps({
     card: {

frontend/src/entities/grouping/grouping.js

         super()
 
         this.type = this.constructor.name.toLowerCase()
+        this.tags = []
 
         /** Pass destructured data to the module system */
         Object.assign(this, membership)

frontend/src/entities/grouping/grouping.schema.js

         _id: Joi.string(),
         lastUpdatedAt: Joi.string(),
         type: Joi.string(),
+        tags: Joi.array(),
 
         /** our fields */
         grouping_id: Joi.number().required(),

frontend/src/services/grouping.service.js

     const validGroupingInstances = []
     for (let membership of membershipsForProfileId) {
         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)