:sparkles: joining group checks for matches

backend/lib/models/membership.js

             grouping_id: Joi.number().allow(null),
             membership_type: Joi.string().required(),
             can_edit: Joi.boolean().required(),
+            is_active: Joi.boolean().required(),
         })
     }
 }

backend/lib/routes/membership/join.js

     join: {
         payload: Joi.object({
             user_id: Joi.number().required(),
+            target_id: Joi.number().allow(null),
             grouping_id: Joi.number().allow(null),
             grouping_name: Joi.string().allow(null),
             grouping_type: Joi.string().allow(null),
                     grouping_name: res.grouping_name,
                     grouping_type: res.grouping_type
                 }
-                /** Check if the grouping exists and if NOT creat it */
-                const groupingId = await membershipService.findOrCreateGrouping(groupingToWrite)
-
+               
                 /** Default to participant role */
                 const role = res.role ? res.role : 'participant'
 
                 /** User membership service method to create membership */
-                const membership = await membershipService.joinGrouping(res.user_id, groupingId, role)
+                const memberships = await membershipService.joinGrouping(res.user_id, res.target_id, groupingToWrite, role)
 
                 return {
                     ok: true,
                     handler: pluginConfig.handlerType,
-                    data: { membership }
+                    data: { memberships, hasMatch: memberships.every(membership => membership.is_active == true) }
                 }
             }
             catch(err) {

backend/lib/services/membership.js

             .whereIn('grouping_id', dedupedGroupings)
     }
 
+    async _groupingIdsInCommon(userId, targetId) {
+        const dedupedUserGroupingIds = await this._getGroupIdsForUserId(userId)
+        const dedupedTargetGroupingIds = await this._getGroupIdsForUserId(targetId)
+
+        /** Return true if both people have a group in common */
+        return dedupedUserGroupingIds.filter(groupingId => dedupedTargetGroupingIds.includes(groupingId))
+    }
+    async _patchMembership(memberships, userId, patch) {
+        const { Membership } = this.server.models()
+
+        /** Set membership as active only if the user initiates it */
+        for(let membershipInfo of memberships) {
+            await Membership.query()
+                .where('membership_id', membershipInfo.membership_id)
+                .where('user_id', userId)
+                .patch(patch)
+        }
+    }
+
+    async attemptMatch(userId, targetId, txn) {
+        const { Membership } = this.server.models()
+
+        /** If both people have groups in common */
+        const matchingGroupingIds = await this._groupingIdsInCommon(userId, targetId)
+
+        if(matchingGroupingIds.length) {
+
+            /** Grab all memberships associated with groupingIds */
+            const memberships = await Membership.query().whereIn('grouping_id', matchingGroupingIds)
+    
+            /** Set membership as active only if the user initiates it */
+            await this._patchMembership(memberships, userId, { is_active: true })
+
+            /** Make a new query to get updated information */
+            return await Membership.query().whereIn('grouping_id', matchingGroupingIds)
+        }
+    }
+    
     /**
-     * Check for grouping membership then add membership record
+     * 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
      * @param {number} userId
-     * @param {number} groupingId
+     * @param {number} targetId
+     * @param {object} groupingToWrite
      * @param {string} role
      * @returns
      */
-    async joinGrouping(userId, groupingId, role, txn) {
+    async joinGrouping(userId, targetId, groupingToWrite, role, txn) {
         const { Membership } = this.server.models()
 
-        const dedupedGroupings = await this._getGroupIdsForUserId(userId)
+        /** If both people have groups in common */
+        const matchingGroupingIds = await this._groupingIdsInCommon(userId, targetId)
 
-        /** Do NOTHING if already in Grouping */
-        if(dedupedGroupings.includes(groupingId)) return
+        if(matchingGroupingIds.length) {
 
-        console.log(dedupedGroupings)
-        const membershipInfo = {
-            user_id: userId,
-            grouping_id: groupingId,
-            membership_type: role,
-            can_edit: false
+            /** Grab all memberships associated with groupingIds */
+            const memberships = await Membership.query().whereIn('grouping_id', matchingGroupingIds)
+    
+            /** Set membership as active only if the user initiates it */
+            await this._patchMembership(memberships, userId, { is_active: true })
+
+            /** Make a new query to get updated information */
+            return await Membership.query().whereIn('grouping_id', matchingGroupingIds)
+        }
+        
+        /** 
+         * If both have NO grouping in common create a membership
+         * for both to new group but set membership as inactive for target
+         * */
+        else {
+            /** Check if the grouping exists and if NOT creat it */
+            const groupingId = await this.findOrCreateGrouping(groupingToWrite)
+
+            const userMembership = await Membership.query(txn).insert({
+                user_id: userId,
+                grouping_id: groupingId,
+                membership_type: role,
+                can_edit: false,
+                is_active: true
+            })
+    
+            const targetMembership = await Membership.query(txn).insert({
+                user_id: targetId,
+                grouping_id: groupingId,
+                membership_type: role,
+                can_edit: false,
+                is_active: false
+            })
+            
+            return [userMembership, targetMembership]
         }
-        console.log(membershipInfo)
-        return await Membership.query(txn)
-            .insert(membershipInfo)
     }
 
     /**