:bug: fixing membership bugs in the frontend | adding more mock groupings and relationships to test

backend/db/data-generator/mock.js

         { match_queue_id: 4, profile_id: 46, target_id: 62, is_deleted: false },
         { match_queue_id: 5, profile_id: 45, target_id: 46, is_deleted: false },
         { match_queue_id: 6, profile_id: 46, target_id: 45, is_deleted: false },
+        { match_queue_id: 7, profile_id: 46, target_id: 44, is_deleted: false },
+        { match_queue_id: 8, profile_id: 46, target_id: 43, is_deleted: false },
+        { match_queue_id: 9, profile_id: 46, target_id: 42, is_deleted: false },
+        {
+            match_queue_id: 10,
+            profile_id: 46,
+            target_id: 41,
+            is_deleted: false,
+        },
+        {
+            match_queue_id: 11,
+            profile_id: 46,
+            target_id: 40,
+            is_deleted: false,
+        },
+        {
+            match_queue_id: 12,
+            profile_id: 40,
+            target_id: 46,
+            is_deleted: false,
+        },
+        {
+            match_queue_id: 13,
+            profile_id: 41,
+            target_id: 46,
+            is_deleted: false,
+        },
+        {
+            match_queue_id: 14,
+            profile_id: 42,
+            target_id: 46,
+            is_deleted: false,
+        },
+        {
+            match_queue_id: 15,
+            profile_id: 43,
+            target_id: 46,
+            is_deleted: false,
+        },
+        {
+            match_queue_id: 16,
+            profile_id: 44,
+            target_id: 46,
+            is_deleted: false,
+        },
     ],
 }

backend/lib/routes/membership/join.js

          */
         handler: async function (request, h) {
             try {
+                console.log('---')
                 const { membershipService } = request.server.services()
 
                 /** Grab payload info */
                     groupingToWrite,
                     role,
                 )
-                // console.log(memberships)
                 const hasMatch = memberships.every(
                     membership => membership && membership.is_active == true,
                 )
-                request.server.methods.notify(
-                    `${profileId}.stonk`,
-                    {
-                        name: `${res.target_id} Match Fffound`,
-                        type: 'info',
-                    },
-                    h,
-                )
-                request.server.methods.notify(
-                    `${res.target_id}.stonk`,
-                    {
-                        name: `${profileId} Match Fffound`,
-                        type: 'info',
-                    },
-                    h,
-                )
-                console.log('hasMatch :>> ', hasMatch)
-                console.log('memberships :>> ', memberships)
 
+                if (hasMatch) {
+                    request.server.methods.notify(
+                        `${profileId}.stonk`,
+                        {
+                            name: `${res.target_id} Match Fffound`,
+                            type: 'info',
+                        },
+                        h,
+                    )
+                    request.server.methods.notify(
+                        `${res.target_id}.stonk`,
+                        {
+                            name: `${profileId} Match Fffound`,
+                            type: 'info',
+                        },
+                        h,
+                    )
+                }
                 return h
                     .response({
                         ok: true,

backend/lib/routes/profile/patch-queue.js

 
 const responseSchemas = {
     response: Joi.array().items(
-        Joi.alternatives().try(Joi.number().optional(), profileSchema.single),
+        Joi.alternatives().try(
+            Joi.number().optional(),
+            profileSchema.single.optional(),
+        ),
     ),
     error: errorSchema.single,
 }
                 reinsert,
             )
             const queueIds = updatedQueue.map(entry => entry.target_id)
+
             const res = {
                 ok: true,
                 handler: pluginConfig.handlerType,
-                data: queueIds,
-            }
-            if (include_profile) {
-                res.data = await profileService.getProfilesFor(queueIds)
+                data:
+                    include_profile == true
+                        ? await profileService.getProfilesFor(queueIds)
+                        : queueIds,
             }
 
             try {

backend/lib/schemas/responses.js

     response_key_id: Joi.number(),
     response_id: Joi.number(),
     profile_id: Joi.number(),
-    val: Joi.string(),
+    val: Joi.string().allow(null, ''),
 }).label('response_single')
 
 const singleResponseKey = Joi.object({
 
 module.exports = {
     single: singleResponse,
-    list: Joi.array().items(singleResponse.optional()).label('response_list'),
+    list: Joi.array().items(singleResponse).label('response_list'),
     key: singleResponseKey,
-    keys: Joi.array()
-        .items(singleResponseKey.optional())
-        .label('question_list'),
+    keys: Joi.array().items(singleResponseKey).label('question_list'),
 }

backend/lib/services/membership.js

      * @param {number} profileId
      * @returns {Array} List of all grouping_ids for user
      */
-    async _getGroupingIdsForProfileId(profileId, type, active) {
+    async _getGroupingIdsForProfileId(profileId) {
         const { Membership } = this.server.models()
 
         /** Grab every Membership associated with this id */
-        let allMemberships = []
-
-        if (type && active == 'any') {
-            allMemberships = await Membership.query()
-                .where({ profile_id: profileId })
-                .where({ membership_type: type })
-        } else if (type) {
-            allMemberships = await Membership.query()
-                .where({ profile_id: profileId })
-                .where({ membership_type: type })
-                .where({ is_active: true })
-        } else if (active == 'any') {
-            allMemberships = await Membership.query().where({
-                profile_id: profileId,
-            })
-        } else {
-            allMemberships = await Membership.query()
-                .where({ profile_id: profileId })
-                .where({ is_active: true })
-        }
-
-        /** Copy a list of the just the Groupings */
+        const allMemberships = await Membership.query().where({
+            profile_id: profileId,
+        })
+        /** Copy a list of the just the Grouping ids */
         const groupingIdsToGrab = allMemberships.map(
             membership => membership.grouping_id,
         )
      */
     async findGroupingsByProfileId(profileId, type) {
         const { Grouping } = this.server.models()
-
         const dedupedGroupings = await this._getGroupingIdsForProfileId(
             profileId,
             type,
-            'any',
         )
-
         /** Grab just the Groupings this id has a Membership for */
         return await Grouping.query()
             .whereIn('grouping_id', dedupedGroupings)
     }
 
     async _groupingIdsInCommon(profileId, targetId) {
-        const dedupedUserGroupingIds = await this._getGroupingIdsForProfileId(
-            profileId,
-        )
-        const dedupedTargetGroupingIds = await this._getGroupingIdsForProfileId(
-            targetId,
-        )
+        const uids = await this._getGroupingIdsForProfileId(profileId)
+        const tids = await this._getGroupingIdsForProfileId(targetId)
         const common = []
-        const uids = dedupedUserGroupingIds.toString().split(',').map(Number)
-        const tids = dedupedTargetGroupingIds.toString().split(',').map(Number)
         for (let i in uids) {
             if (tids.indexOf(uids[i]) !== -1) common.push(uids[i])
         }
         return common.sort((x, y) => x - y)
     }
+
     async _patchMembership(memberships, profileId, patch) {
         const { Membership } = this.server.models()
 

frontend/src/App.vue

 <template lang="pug">
 w-app
-    div.nav(v-if="getPid" style="display: flex; justify-content: space-between;")
+    div.nav(v-if="isLoggedIn" style="display: flex; justify-content: space-between;")
         header
             h2 home - profile: {{ getPid }}
         w-drawer(v-model="openDrawer")
         w-button(@click="openDrawer = true" outline="")
             | Active Chats
     RouterView(
-        v-if="getPid"
+        v-if="isLoggedIn"
         :pid="getPid"
         @updatePid="setPid"
         @show-sidebar="showSidebar = !showSidebar"
         openDrawer: false,
     }),
     computed: {
-        getPid: () =>
-            currentProfile.id.value ? currentProfile.id.value : null,
+        getPid: () => {
+            return currentProfile.id.value ? currentProfile.id.value : null
+        },
+        isLoggedIn: () => {
+            return currentProfile.isLoggedIn
+        },
     },
     async created() {
         /** Get questions so we can compare against profile responses */

frontend/src/components/ProfileCardList.vue

                     nav.swipe_icons
                         //- Accept
                         button(@click="chat(profile.pid)") chat
-                        button(@click="accept") Accept
+                        button(@click="accept(profile.pid)") Accept
                         button(@click="view(profile.pid)") view
                         //- Pass
-                        button(@click="pass") Pass
+                        button(@click="pass(profile.pid)") Pass
     
     .match-layout(
         v-else
 import { useRouter } from 'vue-router'
 import {
     updateQueueByProfileId,
-    fetchMembershipsByProfileId,
     postMembershipByProfileId,
     currentProfile,
 } from '../services'
 
 // AHP Button behavior
 
-const accept = async () => {
+const accept = async targetId => {
+    if (targetId == props.pid) return
     // need to pass these arguments (profileId, targetId, status)
     // the url structure is
     // const charmander = await db.get(`/profile/{profile_id}/queue/{target_id}/delete?include_profile=true&reinsert=false`)
     // http://localhost:3001/api/profile/38/queue/9/delete?include_profile=true&reinsert=true
     const profileId = props.pid
-    const targetId = props.profiles[0].pid
     updateQueueByProfileId(profileId, targetId, false)
-    // TODO: next step is grouping/membership
-    const checkMembership = await fetchMembershipsByProfileId(profileId)
-    if (!checkMembership.length) {
-        postMembershipByProfileId({ profileId, targetId })
-    }
+
+    postMembershipByProfileId({ profileId, targetId })
+
     emit('reload')
 }
+
 const view = pid => {
     router.push({ path: `/matches/${pid}` })
 }
-const chat = async pid => {
+
+const chat = async targetId => {
     // create a chatter reference from the current profile
     const chatter = currentProfile.chatter
     // console.log('mock sender:', pid)
-    
+
     /**  publish a new message to the chatter with the channel and the message & title is optional
      */
     const res = await chatter.publish(chatter.subscriptions[1], {
         title: 'New Message',
-        description: 'This is the checking to see if we are subscribed to a channel!',
+        description:
+            'This is the checking to see if we are subscribed to a channel!',
     })
     // PubNub response will be a timecode of when the message was published
     console.log('res:', res)
-
     //router.push({ path: `/chat/${pid}` })
 }
-const pass = () => {
-    const targetId = props.profiles[0].pid
+
+const pass = targetId => {
+    if (targetId == props.pid) return
     updateQueueByProfileId(props.pid, targetId, true)
     emit('reload')
 }

frontend/src/components/SideBar.vue

 <template lang="pug">
 aside.sidebar
     .temp-control-box
-        input(v-model="switchToPID")
+        input(v-model="switchToPID" @keyup.enter="$emit('updatePid', switchToPID)")
         button(@click="$emit('updatePid', switchToPID)") switch profile
     
     Messages(:matches="matches" :pid="pid")

frontend/src/services/grouping.service.js

     targetId,
     groupingType = 'match',
 }) => {
-    const utcDateInSeconds = Date.now()/1000
+    const utcDateInSeconds = Date.now() / 1000
     const membership = {
         target_id: targetId,
         grouping_type: groupingType,
         grouping_name: `${utcDateInSeconds}_${profileId}_${targetId}`,
     }
-    console.warn(`${groupingType} created between ${profileId} and ${targetId}`)
     const createdMembershipRecord = await db.post(
         `/membership/${profileId}/join`,
         membership,
     )
+    console.warn(`${groupingType} created between ${profileId} and ${targetId}`)
     return createdMembershipRecord
 }
 export { fetchMembershipsByProfileId, postMembershipByProfileId }