:recycle: more refactoring match queue | saving queue from scoring

backend/lib/index.js

 const MembershipPlugin = require('./plugins/membership')
 const SurveyPlugin = require('./plugins/survey')
 const ProfilePlugin = require('./plugins/profile')
-const MatchQueuePlugin = require('./plugins/matchqueue')
 
 /**
  * A Hapi server instance
             routes: { prefix: '/user' },
         })
 
-        await server.register(MatchQueuePlugin, {
-            routes: { prefix: '/matchqueue' },
-        })
-
         await server.register(MembershipPlugin, {
             routes: { prefix: '/membership' },
         })

backend/lib/plugins/matchqueue.js

-const Objection = require('objection')
-const Schmervice = require('@hapipal/schmervice')
-const Schwifty = require('@hapipal/schwifty')
-
-const MatchQueueService = require('../services/matchqueue')
-
-const MatchQueueModel = require('../models/matchqueue')
-const MatchQueueChooseRoute = require('../routes/matchqueue/choosematch')
-
-module.exports = {
-    name: 'matchqueue-plugin',
-    version: '1.0.0',
-    register: async (server, options) => {
-        await server.register(Schwifty)
-
-        await server.registerModel(MatchQueueModel)
-
-        server.bind({
-            transaction: fn => Objection.transaction(server.knex(), fn),
-        })
-
-        await server.register(Schmervice)
-
-        server.registerService(MatchQueueService)
-
-        await server.route(MatchQueueChooseRoute)
-    },
-}

backend/lib/plugins/profile.js

 const ProfileModel = require('../models/profile')
 const ResponseModel = require('../models/response')
 const ZipCodeModel = require('../models/zip-code')
+const MatchQueueModel = require('../models/matchqueue')
 
 const ProfileService = require('../services/profile')
+const MatchQueueService = require('../services/matchqueue')
 
 const ProfileScoreRoute = require('../routes/profile/score')
 const ProfileUpdateRoute = require('../routes/profile/update')
 const ProfileRespondRoute = require('../routes/profile/respond')
 const ProfileMatchRoute = require('../routes/profile/match')
 const ProfileQueueRoute = require('../routes/profile/queue')
+const ProfilePatchQueueRoute = require('../routes/profile/patch-queue')
 
 module.exports = {
     name: 'profile-plugin',
         await server.registerModel(ProfileModel)
         await server.registerModel(ResponseModel)
         await server.registerModel(ZipCodeModel)
+        await server.registerModel(MatchQueueModel)
 
         // Bind to global context
         // So we can use Objection transactions
         })
 
         await server.register(Schmervice)
-        server.registerService(ProfileService)
+        await server.registerService(ProfileService)
+        await server.registerService(MatchQueueService)
 
         await server.route(ProfileScoreRoute)
         await server.route(ProfileRespondRoute)
         await server.route(ProfileUpdateRoute)
         await server.route(ProfileMatchRoute)
         await server.route(ProfileQueueRoute)
+        await server.route(ProfilePatchQueueRoute)
     },
 }

backend/lib/routes/matchqueue/choosematch.js

-'use strict'
-
-const Joi = require('joi')
-
-const pluginConfig = {
-    handlerType: 'matchque',
-    docs: {
-        description: 'updates matchque',
-        notes: 'Updates MatchQue Table if User chooses to match with another or chooses to delete match',
-    },
-}
-
-const validators = {
-    //     /** Validate the header (cookie check) */
-    //     // headers: true,
-
-    //     /** Validate the route params (/active/{thing}) */
-    params: Joi.object({ profile_id: Joi.number() }),
-
-    //     /** Validate the route query (/active/{thing}?limit=10&offset=10) */
-    //     // query: true,
-
-    //     /** Validate the incoming payload (POST method) */
-
-    payload: Joi.object({
-        profile_id_2: Joi.number(),
-        reinsert: Joi.boolean(),
-    }),
-}
-
-module.exports = {
-    method: 'POST',
-    path: '/{profile_id}/choose',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        /** Protect this route with authentication? */
-        auth: false,
-        handler: async function (request, h) {
-            const { profile_id } = request.params
-            const { profile_id_2, reinsert } = request.payload
-            const { matchQueService } = request.server.services()
-
-            return await matchQueService.markAsDeleted(
-                profile_id,
-                profile_id_2,
-                reinsert,
-            )
-        },
-        /** Validate based on validators object */
-        validate: {
-            ...validators,
-            failAction: 'log',
-        },
-
-        // couldn't get validate server response working...
-
-        /** Validate the server response */
-        // response: {
-        //     schema: Joi.object({
-        //         ok: Joi.bool(),
-        //         handler: Joi.string(),
-        //         data: Joi.object(),
-        //     }),
-        // },
-    },
-}

backend/lib/routes/profile/patch-queue.js

+'use strict'
+
+const Joi = require('joi')
+
+const pluginConfig = {
+    handlerType: 'profile',
+    docs: {
+        description: 'Updates match queue in place',
+        notes: 'Updates in place and does not delete from table',
+    },
+}
+
+const validators = {
+    params: Joi.object({ profile_id: Joi.number(), target_id: Joi.number() }),
+    query: Joi.object({ reinsert: Joi.boolean() }),
+}
+
+module.exports = {
+    method: 'PATCH',
+    path: '/{profile_id}/queue/{target_id}/delete',
+    options: {
+        ...pluginConfig.docs,
+        tags: ['api'],
+        /** Protect this route with authentication? */
+        auth: false,
+        handler: async function (request, h) {
+            const { profile_id, target_id } = request.params
+            const { reinsert } = request.query
+            const { matchQueueService } = request.server.services()
+
+            return await matchQueueService.markAsDeleted(
+                profile_id,
+                target_id,
+                reinsert,
+            )
+        },
+        /** Validate based on validators object */
+        validate: {
+            ...validators,
+            failAction: 'log',
+        },
+
+        // couldn't get validate server response working...
+
+        /** Validate the server response */
+        // response: {
+        //     schema: Joi.object({
+        //         ok: Joi.bool(),
+        //         handler: Joi.string(),
+        //         data: Joi.object(),
+        //     }),
+        // },
+    },
+}

backend/lib/routes/profile/queue.js

 
 const validators = {
     params: Joi.object({ profile_id: Joi.number() }),
+    query: Joi.object({ include_profile: Joi.bool() }),
 }
 
 module.exports = {
         auth: false,
         handler: async function (request, h) {
             const { profile_id } = request.params
-            const { matchQueueService } = request.server.services()
+            const { include_profile } = request.query
+            const { profileService, matchQueueService } =
+                request.server.services()
 
-            return await matchQueueService.getPotentials(profile_id)
+            const queue = await matchQueueService.getQueue(profile_id)
+            const queueIds = queue.map(entry => entry.target_id)
+            return include_profile
+                ? profileService.getProfilesFor(queueIds)
+                : queueIds
         },
         /** Validate based on validators object */
         validate: {

backend/lib/routes/profile/score.js

             const distanceUnit = request.query.unit
                 ? request.query.unit
                 : 'mile'
-            const profiles = await profileService.scoreProfilesFor(
+            const scoredProfiles = await profileService.scoreProfilesFor(
                 profileId,
                 maxDistanceMiles,
                 distanceUnit,
             )
-            await matchQueueService.insertScoredProfilesIntoMatchQueue(
+            await matchQueueService.saveMatchQueue(
                 profileId,
-                profiles.map(profile => profile.profile_id),
+                scoredProfiles.map(profile => profile.profile_id),
             )
             try {
-                if (!profiles) {
+                if (!scoredProfiles) {
                     throw new RangeError('Unable to score profiles')
                 }
 
                     .response({
                         ok: true,
                         handler: pluginConfig.handlerType,
-                        data: profiles,
+                        data: scoredProfiles,
                     })
                     .code(200)
             } catch (err) {

backend/lib/services/matchqueue.js

         super(...args)
     }
 
-    async getPotentials(profileId) {
+    async getQueue(profileId) {
         const { MatchQueue } = this.server.models()
-        const allPotentials = await MatchQueue.query()
+        return await MatchQueue.query()
             .where('profile_id', profileId)
             .andWhere('is_deleted', false)
-        return allPotentials
     }
     /**
      * Saves Scored Profile Ids to MatchQue IN ORDER
      * @param {number} profileId
-     * @param {array} potentialProfileIds
+     * @param {array} targetIds
      */
-    async insertScoredProfilesIntoMatchQueue(profileId, potentialProfileIds) {
+    async saveMatchQueue(profileId, targetIds) {
         const { MatchQueue } = this.server.models()
 
-        // returns an array of all matches for the profileId where the profile_id_2 already exists in the potentialProfileIds array
+        // returns an array of all matches for the profileId where the target_id already exists in the targetIds array
         await MatchQueue.query()
             .patch({
                 is_deleted: true,
             })
             .where('profile_id', profileId)
 
-        for (let potentialProfileId of potentialProfileIds) {
+        for (let id of targetIds) {
             await MatchQueue.query().insert({
                 profile_id: profileId,
-                target_id: potentialProfileId,
+                target_id: id,
                 is_deleted: false,
             })
         }
 
-        return await this.getPotentials(profileId)
+        return await this.getQueue(profileId)
     }
     /**
      * Set the rows deleted as true, does NOT DELETE from database
         const { MatchQueue } = this.server.models()
         await MatchQueue.query()
             .patch({
-                deleted: true,
+                is_deleted: true,
             })
             .where('profile_id', profileId)
             .andWhere('target_id', targetId)
             await MatchQueue.query().insert({
                 profile_id: profileId,
                 target_id: targetId,
-                deleted: false,
+                is_deleted: false,
             })
         }
 
-        return await this.getPotentials(profileId)
+        return await this.getQueue(profileId)
     }
 }

backend/lib/services/profile.js

         })
     }
 
+    async getProfilesFor(profileIdArray, type) {
+        const { Profile } = this.server.models()
+
+        const profilesEntries = await Profile.query()
+            .whereIn('profile_id', profileIdArray)
+            .withGraphFetched('responses')
+
+        return profilesEntries.map(profile => {
+            return new CompleteProfile(profile, type)
+        })
+    }
+
     /**
      * Save responses in a profile
      * @param {number} userId