:sparkles: addding match endpoint | added stable marriage func | added more mock data

backend/db/mock.js

             is_admin: false,
             is_poster: false,
         },
+        {
+            user_id: 8,
+            user_name: 'oscar',
+            user_email: 'oscar@doggo.com',
+            is_admin: false,
+            is_poster: true,
+        },
+        {
+            user_id: 9,
+            user_name: 'bingo',
+            user_email: 'bb@ismycat.com',
+            is_admin: false,
+            is_poster: false,
+        },
+        {
+            user_id: 10,
+            user_name: 'rufus',
+            user_email: 'rufruf@issomeothercat.com',
+            is_admin: false,
+            is_poster: false,
+        },
+        {
+            user_id: 11,
+            user_name: 'mary',
+            user_email: 'mary@hires.com',
+            is_admin: false,
+            is_poster: true,
+        },
+        {
+            user_id: 12,
+            user_name: 'pingpong',
+            user_email: 'plop@pets.com',
+            is_admin: false,
+            is_poster: false,
+        },
+        {
+            user_id: 13,
+            user_name: 'jennie',
+            user_email: 'jj@cats.com',
+            is_admin: false,
+            is_poster: false,
+        },
+        {
+            user_id: 14,
+            user_name: 'goose',
+            user_email: 'mywingman@allcats.com',
+            is_admin: false,
+            is_poster: false,
+        },
     ],
     profiles: [
         { profile_id: 1, user_id: 1 },
         { profile_id: 5, user_id: 5 },
         { profile_id: 6, user_id: 6 },
         { profile_id: 7, user_id: 7 },
+        { profile_id: 8, user_id: 8 },
+        { profile_id: 9, user_id: 9 },
+        { profile_id: 10, user_id: 10 },
+        { profile_id: 11, user_id: 11 },
+        { profile_id: 12, user_id: 12 },
+        { profile_id: 13, user_id: 13 },
+        { profile_id: 14, user_id: 14 },
+        { profile_id: 15, user_id: 11 },
     ],
     response_keys: [
         {
         { response_id: 89, profile_id: 5, response_key_id: 16, val: '90015' },
         { response_id: 90, profile_id: 6, response_key_id: 16, val: '91203' },
         { response_id: 91, profile_id: 7, response_key_id: 16, val: '90210' },
+        { response_id: 92, profile_id: 8, response_key_id: 16, val: '90065' },
+        { response_id: 93, profile_id: 9, response_key_id: 16, val: '90210' },
+        { response_id: 94, profile_id: 10, response_key_id: 16, val: '90001' },
+        { response_id: 95, profile_id: 11, response_key_id: 16, val: '90023' },
+        { response_id: 96, profile_id: 12, response_key_id: 16, val: '90210' },
+        { response_id: 97, profile_id: 13, response_key_id: 16, val: '96701' },
+        { response_id: 98, profile_id: 14, response_key_id: 16, val: '90452' },
+        { response_id: 99, profile_id: 15, response_key_id: 16, val: '90025' },
     ],
     memberships: [
         {

backend/db/survey-generator.js

         })
     } while (!done)
 }
-
 const generateDummyProfiles = (count, startFrom) => {
     const profiles = []
     for (let i = 0; i < count; i++) {

backend/lib/plugins/profile.js

 const ProfileScoreRoute = require('../routes/profile/score')
 const ProfileUpdateRoute = require('../routes/profile/update')
 const ProfileRespondRoute = require('../routes/profile/respond')
+const ProfileMatchRoute = require('../routes/profile/match')
 
 module.exports = {
     name: 'profile-plugin',
         await server.route(ProfileScoreRoute)
         await server.route(ProfileRespondRoute)
         await server.route(ProfileUpdateRoute)
+        await server.route(ProfileMatchRoute)
     },
 }

backend/lib/routes/profile/match.js

+'use strict'
+
+const Joi = require('joi')
+
+const pluginConfig = {
+    handlerType: 'match',
+    docs: {
+        description: 'matches',
+        notes: 'Match everyone',
+    },
+}
+
+const validators = {}
+
+const responseSchemas = {
+    response: Joi.array().items(),
+    error: Joi.object({
+        error: Joi.string(),
+    }),
+}
+
+module.exports = {
+    method: 'GET',
+    path: '/match',
+    options: {
+        ...pluginConfig.docs,
+        tags: ['api'],
+        /** Protect this route with authentication? */
+        auth: false,
+
+        handler: async function (request, h) {
+            const { profileService } = request.services()
+            const postMatchYins = await profileService.calcMatches()
+            console.log(postMatchYins)
+            try {
+                if(!postMatchYins){
+                    throw new RangeError('Unable to match profiles')
+                }
+                
+                return h.response({
+                    ok: true,
+                    handler: pluginConfig.handlerType,
+                    data: postMatchYins,
+                }).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: Joi.object({
+                    ok: Joi.bool(),
+                    handler: Joi.string(),
+                    data: responseSchemas.response,
+                }),
+                409: Joi.object({
+                    ok: Joi.bool(),
+                    handler: Joi.string(),
+                    data: responseSchemas.error,
+                }),
+            }
+        },
+    },
+}

backend/lib/services/profile.js

 const Schmervice = require('@hapipal/schmervice')
 const cosineSimilarity = require('compute-cosine-similarity')
 const haversine = require('haversine')
-const profile = require('../plugins/profile')
+const { profiles } = require('../../db/mock')
+
+const rand = max => {
+    return Math.floor(Math.random() * max) < 1
+        ? 1
+        : Math.floor(Math.random() * max)
+}
+
+const runMatch = (allYins, allYangs) => {
+    balanceSides(allYins, allYangs)
+    
+    // You only need to engage from one side
+    engageEveryone(allYins)
+
+    allYins.forEach(yin => yin.clearPlaceholderMatches())
+    allYangs.forEach(yang => yang.clearPlaceholderMatches())
+
+    console.log('---')
+}
+const engageEveryone = allYinsOrYangs => {
+    let done
+    do {
+        done = true
+        allYinsOrYangs.forEach(yinOrYang => {
+            if (!yinOrYang.otp) {
+                done = false
+                const yangOrYin = yinOrYang.getNextCandidate()
+                if (!yangOrYin.otp || yangOrYin.prefers(yinOrYang)) {
+                    yinOrYang.engageTo(yangOrYin)
+                }
+            }
+        })
+    } while (!done)
+}
+const balanceSides = (yins, yangs) => {
+    let diff = Math.abs(yangs.length - yins.length)
+    let smallerList = yangs.length < yins.length ? yangs : yins
+    const totalProfiles = yangs.length + yins.length + 1
+    for (let i = 0; i < diff; i++) {
+        smallerList.push(new ProfileFacade(totalProfiles + i))
+    }
+}
+class ProfileFacade {
+    constructor(id, matchQueue) {
+        this.realId = id ? id : undefined
+
+        this.matchCandidateIndex = 0
+        this.otp = null
+        this.matchQueue = matchQueue?.length ? matchQueue : []
+        this.fOrder = []
+    }
+    clearPlaceholderMatches(){
+        this.matchQueue = this.matchQueue.filter(
+            match => match.realId == false,
+        )
+        this.fOrder = this.fOrder.filter(
+            potentialFiance => potentialFiance.realId == false,
+        )
+        if (this.otp && this.otp.realId) {
+            this.otp = null
+        }
+    }
+    rank(p) {
+        for (let i = 0; i < this.matchQueue.length; i++) {
+            if (this.matchQueue[i] === p) {
+                return i
+            }
+        }
+        return this.matchQueue.length + 1
+    }
+    prefers(p) {
+        return this.rank(p) < this.rank(this.otp)
+    }
+    getNextCandidate() {
+        if (this.matchCandidateIndex >= this.matchQueue.length) return null
+        return this.matchQueue[this.matchCandidateIndex++]
+    }
+    engageTo(p) {
+        if (p.otp) { p.otp.otp = null }
+        p.otp = this
+        p.fOrder.unshift(this)
+        if (this.otp) { this.otp.otp = null }
+        this.otp = p
+        this.fOrder.unshift(p)
+    }
+}
 
 const magic = 1000
 const scoreResponses = (seeker, potentialMatch) => {
         
         // Our User Profile to score for
         const userProfile = await Profile.query()
-        .findOne('profile_id', profileId)
-        .withGraphFetched('responses')
-        .withGraphFetched('user')
-        
+            .findOne('profile_id', profileId)
+            .withGraphFetched('responses')
+            .withGraphFetched('user')
+            
         // Move unneeded responses
         const userZip = getZipCodeFromProfile(userProfile)
 
         // Find all Profiles that are NOT of our userProfile.type
         // ie. If userProfile.type == seeker, then find: poster
         let profileIdsOfOppositeType = await Profile.query()
-        .withGraphFetched('responses')
-        .withGraphFetched('user')
+            .withGraphFetched('responses')
+            .withGraphFetched('user')
         
         // TODO: Let Objection optimize this
         const isPosterOpposite = userProfile.user.is_poster == 1 ? 0 : 1
         // Order by score
         return scoredProfilesWithDistance.sort((a, b) => a.score - b.score)
     }
-    
+    async calcMatches() {
+        const { Profile } = this.server.models()
+        
+        // Grab all profiles with matchQueues
+        let allProfiles = await Profile.query()
+            .withGraphFetched('user')
+        
+        // !:FAKE Score everyone
+        allProfiles = allProfiles.map(profile => {
+            // Copy the profile and add a queue
+            const profilePlusFakeScore = {
+                ...profile,
+                queue: []
+            }
+            // Generate a random order of profile_ids 1:7
+            while (profilePlusFakeScore.queue.length < 4) {
+                profilePlusFakeScore.queue.push(rand(4))
+                profilePlusFakeScore.queue = [...new Set(profilePlusFakeScore.queue)]
+            }
+            //Instantiate a profile facade for each id for matching
+            profilePlusFakeScore.queue = profilePlusFakeScore.queue.map(randId => new ProfileFacade(randId))
+            
+            return profilePlusFakeScore
+        })
+        // ! FAKE -- END
+
+        const seekers = allProfiles.filter(profile => profile.user.is_poster == 0)
+        const posters = allProfiles.filter(profile => profile.user.is_poster == 1)
+        const yins = seekers.map(profile => new ProfileFacade(profile.profile_id, profile.queue))
+        const yangs = posters.map(profile => new ProfileFacade(profile.profile_id, profile.queue))
+        runMatch(yins, yangs)
+        return yins
+    }
     /**
      * Use the db for zipcode info
      * @param {string} zipCode