:bug: simplifying notifications | fixing up some membership and grouping bugs

backend/db/data-generator/mock.js

         {
             response_key_id: 2,
             response_key_category: 'openness',
-            response_key_prompt: 'are you open with your emotions with everyone',
+            response_key_prompt:
+                'are you open with your emotions with everyone',
             response_key_description: 'first round draft scoring question',
         },
         {
             response_key_id: 3,
             response_key_category: 'bravery',
-            response_key_prompt: 'do you speak-up when you feel something is wrong',
+            response_key_prompt:
+                'do you speak-up when you feel something is wrong',
             response_key_description: 'first round draft scoring question',
         },
         {
         {
             response_key_id: 5,
             response_key_category: 'honesty',
-            response_key_prompt: 'when telling a story do you exaggerate for dramatic effect',
+            response_key_prompt:
+                'when telling a story do you exaggerate for dramatic effect',
             response_key_description: 'first round draft scoring question',
         },
         {
             response_key_id: 6,
             response_key_category: 'respect',
-            response_key_prompt: 'do you treat difficult people as well as you treat your close friends',
+            response_key_prompt:
+                'do you treat difficult people as well as you treat your close friends',
             response_key_description: 'first round draft scoring question',
         },
         {
             response_key_id: 9,
             response_key_category: 'profile',
             response_key_prompt: 'language',
-            response_key_description: 'programming and spoken language preference',
+            response_key_description:
+                'programming and spoken language preference',
         },
         {
             response_key_id: 10,
             response_key_category: 'profile',
             response_key_prompt: 'duration',
-            response_key_description: 'duration preference for hours able to dedicate to work',
+            response_key_description:
+                'duration preference for hours able to dedicate to work',
         },
         {
             response_key_id: 11,
             response_key_category: 'profile',
             response_key_prompt: 'presence',
-            response_key_description: 'location preference for where work happens',
+            response_key_description:
+                'location preference for where work happens',
         },
         {
             response_key_id: 12,
             response_key_id: 16,
             response_key_category: 'profile',
             response_key_prompt: 'distance',
-            response_key_description: 'preference for commuting distance cutoff',
+            response_key_description:
+                'preference for commuting distance cutoff',
         },
     ],
     responses: [],
-    memberships: [
-
-    ],
-    groupings: [
-
-    ],
+    memberships: [],
+    groupings: [],
     messages: [],
     match_queues: [
         { match_queue_id: 1, profile_id: 45, target_id: 62, is_deleted: false },
-        { match_queue_id: 2, profile_id: 62, target_id: 45, is_deleted: false }
+        { match_queue_id: 2, profile_id: 62, target_id: 45, is_deleted: false },
+        { match_queue_id: 3, profile_id: 62, target_id: 46, is_deleted: false },
+        { 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 },
     ],
 }

backend/lib/routes/membership/join.js

     error: errorSchema.single,
 }
 
+const notifyMembers = (profileId, targetId, noticationCb, h) => {
+    noticationCb(
+        `${profileId}.stonk`,
+        {
+            name: `${targetId} Match Fffound`,
+            type: 'info',
+        },
+        h,
+    )
+    noticationCb(
+        `${targetId}.stonk`,
+        {
+            name: `${profileId} Match Fffound`,
+            type: 'info',
+        },
+        h,
+    )
+}
+
 module.exports = {
     method: 'POST',
     path: '/{profile_id}/join',
                     groupingToWrite,
                     role,
                 )
-                // console.log(memberships)
+
                 const hasMatch = memberships.every(
                     membership => membership.is_active == true,
                 )
                 if (hasMatch) {
-                    request.server.methods.notify(
-                        `${profileId}.match`,
-                        {
-                            name: 'Match Fffound',
-                            target: res.target_id,
-                            type: 'info',
-                        },
+                    notifyMembers(
+                        profileId,
+                        res.target_id,
+                        request.server.notify,
                         h,
                     )
                 }
-
                 return h
                     .response({
                         ok: true,

backend/lib/services/matchqueue.js

      */
     async markAsDeleted(profileId, targetId, reinsert) {
         const { MatchQueue } = this.server.models()
+        /** Always set row to deleted */
         await MatchQueue.query()
+            .where('profile_id', profileId)
+            .andWhere('target_id', targetId)
             .patch({
                 is_deleted: true,
             })
-            .where('profile_id', profileId)
-            .andWhere('target_id', targetId)
             .first()
 
         if (reinsert) {

backend/lib/services/membership.js

         const dedupedTargetGroupingIds = await this._getGroupingIdsForProfileId(
             targetId,
         )
-
-        /** Return true if both people have a group in common */
-        return dedupedUserGroupingIds.filter(groupingId =>
-            dedupedTargetGroupingIds.includes(groupingId),
-        )
+        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()
         for (let membershipInfo of memberships) {
             await Membership.query()
                 .where('membership_id', membershipInfo.membership_id)
-                .where('user_id', profileId)
+                .where('profile_id', profileId)
                 .patch(patch)
         }
     }

frontend/src/App.vue

 <template lang="pug">
 w-app
-    div.nav(style="display: flex; justify-content: space-between;")
+    div.nav(v-if="getPid" 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"
         :pid="getPid"
         @updatePid="setPid"
         @show-sidebar="showSidebar = !showSidebar"
         openDrawer: false,
     }),
     computed: {
-        getPid: () => (currentProfile.id.value ? currentProfile.id.value : 999),
+        getPid: () =>
+            currentProfile.id.value ? currentProfile.id.value : null,
     },
     async created() {
         /** Get questions so we can compare against profile responses */
             if (currentProfile.isLoggedIn) {
                 currentProfile.logout()
             }
-            await currentProfile.login(profileId)
-
-            if (currentProfile.isLoggedIn) {
-                console.warn(
-                    `setting up Chatter and Toaster for ${this.getPid}...`,
-                )
-                currentProfile.setupChatter()
-                currentProfile.setupToaster(this.$waveui.notify)
-            }
+            await currentProfile.login(profileId, this.$waveui.notify)
             console.log('---')
             //  step 3: subscribe to the this.subscriptions array
             // view current subscriptions on the currentProfile.chatter.subscriptions

frontend/src/services/chat.service.js

 import PubNub from 'pubnub'
 
-// custom services 
-import {fetchMembershipsByProfileId} from '../services/grouping.service'
+// custom services
+import { fetchMembershipsByProfileId } from '../services/grouping.service'
 
 /**
  * Provider method holder
     async setup(uuid) {
         this.uuid = `${uuid}`
         this.provider = await setupPubnub(this.uuid)
-            
+
         //  step 1: build the this.groupings object from the backend
         // ? .then() to wait for the groupings to be fetched before subscribing to channels
         this.getGroupingsByProfileId(this.uuid).then(() => {
             this._listenFor({ listeners: this.listeners })
             this._subscribe(this.subscriptions)
         })
-        
+
         console.log('this.subscriptions', this.subscriptions)
-       
     }
     /**
      * Send a message to a channel
     _listenFor({ listeners }) {
         providerMethods['listen'](listeners)
     }
-    
     //  step 2: build the this.subscriptions array from the this.groupings object
     // fetch all groupings for this profile and then store them in the chatter groupings object for reference
     async getGroupingsByProfileId(profileId) {
     createChannelNamesByGroupings(groupings) {
         groupings.forEach(item => {
             this.subscriptions.push(item.grouping_name)
-        });
-        
-        
+        })
+    }
+    stop() {
+        console.warn('chatter stop no implemented')
     }
 }
 

frontend/src/services/login.service.js

 import { ref } from 'vue'
-import {
-    fetchResponsesByProfileId,
-    Chatter,
-    StonkAlert,
-    MatchAlert,
-} from '../services'
+import { fetchResponsesByProfileId, Chatter, StonkAlert } from '../services'
 import { surveyFactory } from '../utils'
 
 
         this.tags = []
 
         this.toaster = null
-        this.matcher = null
         this.chatter = null
     }
     get isLoading() {
      * @param {number} profileId
      * @returns {number} stored reactive id
      */
-    async login(profileId) {
+    async login(profileId, cb) {
         console.warn('logging in:', profileId)
         this.id.value = parseInt(profileId)
+
+        this.setupChatter()
+        this.setupToaster(cb)
+
         return this.id.value
     }
     logout() {
+        console.warn('logging out:', this.id.value)
         this.id.value = null
         if (this.toaster) {
             this.toaster.stop()
         }
         if (this.chatter) {
-            this.toaster.stop()
+            this.chatter.stop()
         }
     }
 
      */
     setupToaster(waveCb) {
         this.toaster = new StonkAlert(this.id.value, waveCb)
-        this.matcher = new MatchAlert(this.id.value, waveCb)
     }
     setupChatter() {
         this.chatter = new Chatter()

frontend/src/services/notification.service.js

         return `${parsed.name}: ${parsed.profile_id} ${parsed.order} at ${parsed.price}`
     }
 }
-class MatchAlert extends Toaster {
-    constructor(profileId, waveCb) {
-        super(profileId)
-        this.event = 'match'
-        this.matches = {}
-        this.listenFor(`${profileId}.${this.event}`, message => {
-            const parsed = JSON.parse(message.data)
-            this.matches[parsed.target] = parsed
-            waveCb(this._formatToast(parsed), parsed.type)
-        })
-    }
-    _formatToast(parsed) {
-        return `${parsed.name}: ${parsed.target}`
-    }
-}
 
-export { Toaster, StonkAlert, MatchAlert }
+export { Toaster, StonkAlert }

frontend/src/services/queue.service.js

  */
 const fetchQueueByProfileId = async profileId => {
     let queue
-    
+
     try {
-        queue = await db.get(
-            `/profile/${profileId}/queue?include_profile=true`,
-        )
-        if(!queue?.length) {
+        queue = await db.get(`/profile/${profileId}/queue?include_profile=true`)
+        if (!queue?.length) {
             throw 'Could not retrieve match queue. Please take the survey and rescore.'
         }
     } catch (err) {
         console.error(err)
     }
 
-    return queue ? queue.map(profileData => {
-        return new Profile({ email: 'fixme@gmail.com', ...profileData })
-    }) : []
+    return queue
+        ? queue.map(profileData => {
+              return new Profile({ email: 'fixme@gmail.com', ...profileData })
+          })
+        : []
 }
 
 /**
 const updateQueueByProfileId = async (profileId, targetId, reinsert) => {
     const updateQueue = await db.patch(
         `/profile/${profileId}/queue/${targetId}/delete?include_profile=true&reinsert=${reinsert}`,
-        [ targetId ],
     )
-    return updateQueue ? updateQueue.map(profileData => {
-        return new Profile({ email: 'fixme@gmail.com', ...profileData })
-    }) : []
+    return updateQueue
+        ? updateQueue.map(profileData => {
+              return new Profile({ email: 'fixme@gmail.com', ...profileData })
+          })
+        : []
 }
 
 export { fetchQueueByProfileId, updateQueueByProfileId }