:recycle: breakig out matching to separate service

backend/lib/models/matchqueue.js

 const Schwifty = require('@hapipal/schwifty')
 const Joi = require('joi')
+const User = require('./user')
 
 module.exports = class MatchQueue extends Schwifty.Model {
     static get tableName() {
         return 'match_queues'
     }
-
+    static get relationMappings() {
+        return {
+            user: {
+                relation: Schwifty.Model.HasOneThroughRelation,
+                modelClass: User,
+                join: {
+                    from: 'match_queues.target_id',
+                    through: {
+                        from: 'profiles.profile_id',
+                        to: 'profiles.user_id',
+                    },
+                    to: 'users.user_id',
+                },
+            },
+        }
+    }
     static get joiSchema() {
         return Joi.object({
             match_queue_id: Joi.number(),

backend/lib/plugins/profile.js

 
 const ProfileService = require('../services/profile')
 const MatchQueueService = require('../services/matchqueue')
+const MatchService = require('../services/match')
 
 const ProfileScoreRoute = require('../routes/profile/score')
 const ProfileUpdateRoute = require('../routes/profile/update')
         await server.register(Schmervice)
         await server.registerService(ProfileService)
         await server.registerService(MatchQueueService)
+        await server.registerService(MatchService)
 
         await server.route(ProfileScoreRoute)
         await server.route(ProfileRespondRoute)

backend/lib/routes/profile/match.js

 const validators = {}
 
 const responseSchemas = {
-    response: Joi.array().items(),
+    response: Joi.object(),
     error: Joi.object({
         error: Joi.string(),
     }),
         auth: false,
 
         handler: async function (request, h) {
-            const { profileService } = request.services()
-            const postMatchYins = await profileService.calcMatches()
+            const { matchService, matchQueueService } =
+                request.server.services()
+            const allQueues = await matchQueueService.getAllQueues()
+            matchService.calcMatches(allQueues)
             try {
-                if (!postMatchYins) {
+                if (!allQueues) {
                     throw new RangeError('Unable to match profiles')
                 }
 
                     .response({
                         ok: true,
                         handler: pluginConfig.handlerType,
-                        data: postMatchYins,
+                        data: allQueues,
                     })
                     .code(200)
             } catch (err) {

backend/lib/services/match-maker.js

-const similarity = require('compute-cosine-similarity')
-const magic = 1000
-
-const ScoreKeeper = {
-    score: (seeker, potentialMatch) => {
-        const seekerResponseValues = seeker.profileResponses.map(res =>
-            parseInt(Object.values(res)),
-        )
-        console.log(seeker)
-        const potentialMatchResponseValues =
-            potentialMatch.profileResponses.map(res =>
-                parseInt(Object.values(res)),
-            )
-        return Math.floor(
-            similarity(seekerResponseValues, potentialMatchResponseValues) *
-                magic,
-        )
-    },
-}
-
-module.exports = class MatchMaker {
-    constructor(settings) {
-        this.proposer = settings.proposer
-
-        // Score main profile
-        this.keeper = ScoreKeeper
-    }
-    runPrematch(settings) {
-        // grab all profiles form the db
-
-        // grab all responses
-        // grab all response keys
-        // create a full response object
-        // create a full profile of responses
-
-        const unscreenedProfiles = []
-        const screenedProfiles = []
-
-        for (const profile in unscreenedProfiles) {
-            // Do something here
-            if (!settings) {
-                return
-            }
-            screenedProfiles.push(profile)
-        }
-
-        return screenedProfiles
-    }
-    matchFor(proposer, profiles, settings) {
-        // Do something here
-        return this.runPrematch(profiles, settings)
-    }
-    scoreProfiles(profiles) {
-        const matchScores = []
-        for (const profile in profiles) {
-            const scored = this.keeper.score(profile)
-            matchScores.push(scored)
-        }
-        return matchScores
-    }
-}

backend/lib/services/match.js

+const Schmervice = require('@hapipal/schmervice')
+
+const engageEveryone = allYins => {
+    let done
+    do {
+        console.log('rerunning...')
+        done = true
+        allYins.forEach(yin => {
+            // Keep matching if no true pairing is found
+            console.log(yin.realId, yin.otp?.realId)
+            if (!yin.otp) {
+                done = false
+                const yang = yin.getNextCandidate()
+                if (!yang.otp || yang.prefers(yin)) {
+                    yin.engageTo(yang)
+                }
+            } else {
+                console.log(yin.otp.realId)
+            }
+        })
+    } while (!done)
+}
+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(id) {
+        const idQueue = this.matchQueue.map(
+            profileFacade => profileFacade.realId,
+        )
+        return idQueue.includes(id)
+            ? idQueue.indexOf(id)
+            : this.matchQueue.length + 1
+    }
+    prefers(p) {
+        return this.rank(p.realId) < this.rank(this.otp.realId)
+    }
+    getNextCandidate() {
+        if (this.matchCandidateIndex >= this.matchQueue.length) return null
+        this.matchCandidateIndex = this.matchCandidateIndex + 1
+        return this.matchQueue[this.matchCandidateIndex - 1]
+    }
+    engageTo(p) {
+        if (p.otp) {
+            p.otp.otp = null
+        }
+        if (this.otp) {
+            this.otp.otp = null
+        }
+
+        p.otp = this
+        p.fOrder.unshift(this)
+
+        this.otp = p
+        this.fOrder.unshift(p)
+        console.log(
+            'partners pref: ',
+            this.otp.matchQueue.map(f => f.realId).indexOf(this.realId) + 1,
+            'choice',
+        )
+    }
+}
+
+module.exports = class MatchService extends Schmervice.Service {
+    constructor(...args) {
+        super(...args)
+    }
+    async calcMatches(allQueuesByType) {
+        const seekerIds = Object.keys(allQueuesByType['seeker']).map(id => ({
+            profile_id: parseInt(id),
+            queue: allQueuesByType['seeker'][id],
+        }))
+        const posterIds = Object.keys(allQueuesByType['poster']).map(id => ({
+            profile_id: parseInt(id),
+            queue: allQueuesByType['poster'][id],
+        }))
+
+        const diff = Math.abs(posterIds.length - seekerIds.length)
+        const smallerList =
+            posterIds.length < seekerIds.length ? posterIds : seekerIds
+        // ADD DUMMY IDS TO THE SMALLER LIST
+        for (let d = 0; d < diff; d++) {
+            smallerList.push({ profile_id: 'dummy', queue: [] })
+        }
+        console.log(seekerIds)
+        console.log(posterIds)
+        // const yins = seekerIds.map(id => allProfileFacadesWithQueue[id])
+        // const yangs = posterIds.map(id => allProfileFacadesWithQueue[id])
+
+        // You only need to engage from one side
+        // engageEveryone(yins)
+        return []
+    }
+}

backend/lib/services/matchqueue.js

     constructor(...args) {
         super(...args)
     }
-
+    /**
+     * Gets a list of queue entries for profileId
+     * @param {number} profileId
+     * @returns {array} MatchQueue
+     */
     async getQueue(profileId) {
         const { MatchQueue } = this.server.models()
         return await MatchQueue.query()
             .where('profile_id', profileId)
             .andWhere('is_deleted', false)
     }
+    /**
+     * Returns queues by profile id by user type
+     * @returns {object}
+     */
+    async getAllQueues() {
+        const { MatchQueue } = this.server.models()
+        const queueEntries = await MatchQueue.query()
+            .andWhere('is_deleted', false)
+            .withGraphFetched('user')
+
+        const queueByProfileId = {
+            poster: {},
+            seeker: {},
+        }
+        queueEntries.forEach(entry => {
+            const type = entry.user.is_poster == 0 ? 'poster' : 'seeker'
+            if (!queueByProfileId[type][entry.profile_id]) {
+                queueByProfileId[type][entry.profile_id] = []
+            }
+            queueByProfileId[type][entry.profile_id].push(entry.target_id)
+        })
+        return queueByProfileId
+    }
     /**
      * Saves Scored Profile Ids to MatchQue IN ORDER
      * @param {number} profileId

backend/lib/services/profile.js

 const cosineSimilarity = require('compute-cosine-similarity')
 const haversine = require('haversine')
 
-const runMatch = (allYins, allYangs) => {
-    console.log(allYins.length, ':', allYangs.length)
-    // You only need to engage from one side
-    engageEveryone(allYins)
-
-    console.log('---')
-}
-const engageEveryone = allYins => {
-    let done
-    do {
-        console.log('rerunning...')
-        done = true
-        allYins.forEach(yin => {
-            // Keep matching if no true pairing is found
-            console.log(yin.realId, yin.otp?.realId)
-            if (!yin.otp) {
-                done = false
-                const yang = yin.getNextCandidate()
-                if (!yang.otp || yang.prefers(yin)) {
-                    yin.engageTo(yang)
-                }
-            } else {
-                console.log(yin.otp.realId)
-            }
-        })
-    } while (!done)
-}
-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(id) {
-        const idQueue = this.matchQueue.map(
-            profileFacade => profileFacade.realId,
-        )
-        return idQueue.includes(id)
-            ? idQueue.indexOf(id)
-            : this.matchQueue.length + 1
-    }
-    prefers(p) {
-        return this.rank(p.realId) < this.rank(this.otp.realId)
-    }
-    getNextCandidate() {
-        if (this.matchCandidateIndex >= this.matchQueue.length) return null
-        this.matchCandidateIndex = this.matchCandidateIndex + 1
-        return this.matchQueue[this.matchCandidateIndex - 1]
-    }
-    engageTo(p) {
-        if (p.otp) {
-            p.otp.otp = null
-        }
-        if (this.otp) {
-            this.otp.otp = null
-        }
-
-        p.otp = this
-        p.fOrder.unshift(this)
-
-        this.otp = p
-        this.fOrder.unshift(p)
-        console.log(
-            'partners pref: ',
-            this.otp.matchQueue.map(f => f.realId).indexOf(this.realId) + 1,
-            'choice',
-        )
-    }
-}
-
 const magic = 1000
 const scoreResponses = (seeker, potentialMatch) => {
     if (seeker.responses.length != potentialMatch.responses.length)
         // 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')
-        const seekerIds = allProfiles
-            .filter(profile => profile.user.is_poster == 0)
-            .map(profile => profile.profile_id)
-        const posterIds = allProfiles
-            .filter(profile => profile.user.is_poster == 1)
-            .map(profile => profile.profile_id)
-        let diff = Math.abs(posterIds.length - seekerIds.length)
-        let smallerList =
-            posterIds.length < seekerIds.length ? posterIds : seekerIds
-        // ADD DUMMY IDS TO THE SMALLER LIST
-        for (let d = 0; d < diff; d++) {
-            smallerList.push(allProfiles.length + d)
-        }
-        // !:FAKE Score everyone
-        const scoredProfileQueuesById = {}
-        for (let profile of allProfiles) {
-            const profileQueue = await this.scoreProfilesFor(
-                profile.profile_id,
-                10000,
-                'mile',
-            )
-            scoredProfileQueuesById[profile.profile_id] = profileQueue.map(
-                profile => profile.profile_id,
-            )
-        }
-        const allProfileFacadesWithQueue = allProfiles.map(profile => {
-            const profileFacadeQueue = scoredProfileQueuesById[
-                profile.profile_id
-            ].map(id => {
-                const subQueue = scoredProfileQueuesById[id].map(
-                    id => new ProfileFacade(id),
-                )
-                return new ProfileFacade(id, subQueue)
-            })
-            return new ProfileFacade(profile.profile_id, profileFacadeQueue)
-        })
-        // // ! FAKE -- END
-        const yins = seekerIds.map(id => allProfileFacadesWithQueue[id])
-        const yangs = posterIds.map(id => allProfileFacadesWithQueue[id])
-
-        runMatch(yins, yangs)
-        return yins
-    }
     /**
      * Use the db for zipcode info
      * @param {string} zipCode