:recycle: passing group.is_paired from api | making pending list and pairs list | storing grouping.is_paired in currentProfile upon login

backend/lib/routes/membership/active.js

     error: errorSchema.single,
 }
 
+const _activeGroupingIds = allMemberships => {
+    const active = {}
+    allMemberships.forEach(membership => {
+        if (!membership.is_active) return
+        if (!active[membership.grouping_id]) {
+            active[membership.grouping_id] = []
+        }
+        active[membership.grouping_id].push(membership)
+    })
+    const ids = []
+    Object.values(active).forEach(profileListInGrouping => {
+        if (profileListInGrouping.length == 2) {
+            ids.push(profileListInGrouping[0].grouping_id)
+        }
+    })
+    return ids
+}
+
 module.exports = {
     method: 'GET',
     path: '/{profile_id}',
                 profileId,
                 membershipType,
             )
-            // console.log('groupings :>> ', groupings)
+            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
                 completedProfiles.forEach(p => {
                     g.profile = g.profile == p.profile_id ? p : g.profile
                 })
+                g.is_paired = _activeGroupingIds(memberships).includes(
+                    g.grouping_id,
+                )
                 return g
             })
 

backend/lib/schemas/groupings.js

     grouping_id: Joi.number(),
     grouping_name: Joi.string(),
     grouping_type: Joi.string(),
+    is_paired: Joi.boolean(),
 }).label('grouping_single')
 
 const singleWithProfile = Joi.object({
     grouping_id: Joi.number(),
     grouping_name: Joi.string(),
     grouping_type: Joi.string(),
-    profile: surveyProfileSchema.single
+    is_paired: Joi.boolean(),
+    profile: surveyProfileSchema.single,
 }).label('grouping_single_with_profile')
 
 module.exports = {
     single: singleGrouping,
     singleWithProfile,
     list: Joi.array().items(singleGrouping).label('grouping_list'),
-    listWithProfiles: Joi.array().items(singleWithProfile).label('grouping_list_with_profiles')
+    listWithProfiles: Joi.array()
+        .items(singleWithProfile)
+        .label('grouping_list_with_profiles'),
 }

backend/lib/services/membership.js

                 .patch(patch)
         }
     }
-
+    async findMemberships(groupingIds) {
+        const { Membership } = this.server.models()
+        /** Grab all memberships associated with groupingIds */
+        return await Membership.query().whereIn('grouping_id', groupingIds)
+    }
     /**
      * Check for grouping membership then add membership record and set to active
      * or create a new grouping and add membership record for user and membership record for target
         )
         if (matchingGroupingIds.length) {
             /** Grab all memberships associated with groupingIds */
-            let memberships = await Membership.query().whereIn(
-                'grouping_id',
-                matchingGroupingIds,
-            )
+            let memberships = await findMemberships(matchingGroupingIds)
 
             /** Set membership as active only if the user initiates it */
             await this._patchMembership(memberships, profileId, {
             })
 
             /** Make a new query to get updated information */
-            memberships = await Membership.query().whereIn(
-                'grouping_id',
-                matchingGroupingIds,
-            )
+            memberships = await findMemberships(matchingGroupingIds)
             const groupings = await this._getGroupings(matchingGroupingIds, txn)
             return { memberships, groupings }
         } else {

frontend/src/components/PairsList.vue

 <template lang="pug">
 section.pairs-list
-    article(v-if="pairs.length")
-        .pair.w-flex.align-center.justify-space-around(
-            v-for="p in pairs"
-        )
+    article(v-if='pairs.length')
+        .pair.w-flex.align-center.justify-space-around(v-for='pair in pairs')
             .dot--icon
             .avatar
             .idCard
-                p S.R.
-                p Registered Nurse  
-    p(v-else) No results.    
+                p {{ pair.profile.name }}
+                p {{ pair.profile.pid }}
+                p since: {{ pair.grouping.createdAt }}
+                p updated: {{ pair.grouping.lastUpdatedAt }}
+                p paired: {{ pair.grouping.is_paired }}
+    p(v-else) No {{ tabName }} profiles.
 </template>
 
 <script setup>
         type: [Object, Array],
         default: () => [{}],
     },
+    tabName: {
+        type: String,
+        default: 'paired',
+    },
 })
 </script>
+
 <style lang="sass">
 .pairs-list
     article
             width:10vw
             height:10vw
             background-color:#D5D5D5
-</style>
+</style>

frontend/src/components/ProfileCard.vue

     },
 })
 
+/**
+ * Attempt to pair with target profile
+ * Creates a grouping, and a membership
+ * for both profileId and targetId
+ */
 const onPair = async () => {
     const group = await postMembershipByProfileId({
         profileId: currentProfile.id.value,
         targetId: props.card.pid,
     })
     updateQueueByProfileId(currentProfile.id.value, props.card.pid, false)
+    currentProfile.getGroupings()
     console.warn('created grouping:', group)
     console.log('is grouping a match?:', group.membershipMatch.hasMatch)
-    router.push({ name: 'HomeView' })
+
+    let goToRoute = { name: 'HomeView' }
+    if (group.membershipMatch.hasMatch) {
+        goToRoute = { name: 'PairsView' }
+    }
+    router.push(goToRoute)
 }
+
+/**
+ * Send to the back of the matchQueue
+ * and forward back home
+ */
 const onPass = async () => {
     updateQueueByProfileId(currentProfile.id.value, props.card.pid, true)
     router.push({ name: 'HomeView' })

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

         grouping_id: Joi.number().required(),
         grouping_name: Joi.string(),
         grouping_type: Joi.string(),
-        profile: Joi.object()
+        is_paired: Joi.boolean(),
+        profile: Joi.object(),
     }),
     /** fields required before saving */
     required: ['grouping_id'],

frontend/src/services/chat.service.js

     }
     stop() {
         this.subscriptions = [MAIN_CHANNEL]
-        console.warn('chatter stop no implemented')
+        console.warn('chatter stop not implemented')
     }
 }
 

frontend/src/services/login.service.js

     get hasResponses() {
         return this.responses.length && this.responses.length > 0
     }
-
+    /**
+     * Groupings pending pair
+     */
+    get pendingGroupings() {
+        return this.groupings.filter(grouping => grouping.is_paired == false)
+    }
+    get pairedGroupings() {
+        return this.groupings.filter(grouping => grouping.is_paired == true)
+    }
     /**
      * Login a profile by id number
      * @param {number} profileId

frontend/src/views/PairsView.vue

 <template lang="pug">
-main.view--matches
-    article(v-if="!loading")
-
-        w-tabs(:items="tabs" fill-bar)
-            template(#item-title="{ item }")
-               span.green {{ item.title }}
+main.view--pairs
+    article(v-if='isLoggedIn')
+        w-tabs(:items='tabs' fill-bar)
+            template(#item-title='{ item }')
+                span.green {{ item.title }}
             //- pending tab
-            template(#item-content.1="{ item }")
-                PairsList(:pairs="pending")
+            template(#item-content.1='{ item }')
+                PairsList(:pairs='pending' tab-name='pending')
             //- paired tab 
-            template(#item-content.2="{ item }")
-                PairsList(:pairs="paired")
+            template(#item-content.2='{ item }')
+                PairsList(:pairs='paired' tab-name='paired')
 
-    w-spinner(v-else bounce)
+    w-spinner(bounce v-else)
     MainNav
 </template>
 
 <script>
-// import ProfileCardList from '../components/ProfileCardList.vue'
+import { Card } from '../entities'
 import PairsList from '../components/PairsList.vue'
 
-import { fetchMembershipsByProfileId, fetchQueueByProfileId } from '../services'
+import { currentProfile } from '../services'
 import { mixins } from '../utils'
 
-const convertToCard = profile => {
-    if (profile.type !== 'profile') {
-        console.error(`Cannot convert ${profile} to Card. Invalid entity.`)
-    }
-    if (!profile.isValid()) {
-        console.warn(`Profile ${profile.profile_id} is not a valid profile.`)
-    }
-    return new Card({
-        pid: profile.profile_id,
-        name: profile.user_name,
-        avatar: profile.profile_media[0],
-    })
-}
-
-const converGroupingToCard = grouping => {
+const convertGroupingToCard = grouping => {
     if (grouping.type !== 'grouping') {
         console.error(`Cannot convert ${grouping} to Card. Invalid entity.`)
     }
     if (!grouping.profile.isValid()) {
         console.warn(`Profile in ${grouping} is not a valid profile.`)
     }
-    return new Card({
-        pid: grouping.profile.profile_id,
-        name: grouping.profile.user_name,
-        avatar: grouping.profile.profile_media[0],
-    })
+    return {
+        profile: new Card({
+            pid: grouping.profile.profile_id,
+            name: grouping.profile.user_name,
+            avatar: grouping.profile.profile_media[0],
+        }),
+        grouping,
+    }
 }
 
 export default {
     name: 'PairsView',
     components: { PairsList },
-    mixins: [mixins.pidMixin, mixins.cardMixin],
     data: () => ({
-        tabs: [
-          { title: 'Pending',},
-          { title: 'Paired',},
-        ],
-        paired: ['x'],
-        pending: ['f'],
+        tabs: [{ title: 'Pending' }, { title: 'Paired' }],
     }),
+    computed: {
+        isLoggedIn() {
+            return currentProfile.isLoggedIn
+        },
+        pending() {
+            if (!this.isLoggedIn || !currentProfile.pendingGroupings) return []
+            return this._reformat(
+                currentProfile.pendingGroupings,
+                convertGroupingToCard,
+            )
+        },
+        paired() {
+            if (!this.isLoggedIn || !currentProfile.pairedGroupings) return []
+            return this._reformat(
+                currentProfile.pairedGroupings,
+                convertGroupingToCard,
+            )
+        },
+    },
     methods: {
-        /** Gets called from cardMixin */
-        async getCards() {
-            this.loading = true
-            try {
-                const pending = await fetchQueueByProfileId(this.pid)
-                this.pending = this._reformat(pending,converGroupingToCard)
-                const paired = await fetchMembershipsByProfileId(this.pid)
-                this.paired = this._reformat(paired,convertToCard)
-            } catch (err) {
-                console.error(err)
-            }
-            this.loading = false
+        _reformat(data, mapCb) {
+            return data.map(mapCb)
         },
     },
 }
 </script>
+
 <style>
-.select--matches{
+.select--matches {
     display: flex;
     justify-content: space-between;
     margin: 0 25px;
 }
-.select--matches > div{
+.select--matches > div {
     width: 100%;
     text-align: center;
     font-size: 16px;
     line-height: 40px;
 }
-.active{
-    border-bottom: 3px solid #F2CD5C;
-    color: #F2CD5C;
+.active {
+    border-bottom: 3px solid #f2cd5c;
+    color: #f2cd5c;
 }
-.idle{
-    color: #BCC5D3;
+.idle {
+    color: #bcc5d3;
 }
-
 </style>
+s