:construction: Continued filtering logic for initial survey answers

backend/db/data-generator/mock.js

         // TODO: remove from mock data once bare bones matching logic can show poorly matched matches...
         {
             tag_association_id: 50,
-            profile_id: 136,
+            profile_id: 139,
             grouping_id: 2,
             tag_id: 7,
             is_deleted: false,
             can_edit: false,
             is_active: true,
         },
-        // NOTE: profile_id 147 is chosen based off of GENERATED data,
-        // after running 'npm run generate', replace 147 in mock to next profile_id to be genearted
-        // i.e. last profile_id number + 1
-        // TODO: remove from mock data once bare bones matching logic can show poorly matched matches...
-        {
-            membership_id: 3,
-            profile_id: 147,
-            grouping_id: 2,
-            membership_type: 'participant',
-            can_edit: false,
-            is_active: true,
-        },
         {
             membership_id: 4,
             profile_id: 46,
             target_id: 46,
             is_deleted: false,
         },
-        // NOTE: profile_id 147 is chosen based off of GENERATED data,
-        // after running 'npm run generate', replace 147 in mock to next profile_id to be generated
-        // i.e. last profile_id number + 1
-        // TODO: remove from mock data once bare bones matching logic can show poorly matched matches...
-        {
-            match_queue_id: 17,
-            profile_id: 147,
-            target_id: 46,
-            is_deleted: false,
-        },
-        {
-            match_queue_id: 18,
-            profile_id: 147,
-            target_id: 46,
-            is_deleted: false,
-        },
-        {
-            match_queue_id: 19,
-            profile_id: 147,
-            target_id: 44,
-            is_deleted: false,
-        },
-        {
-            match_queue_id: 20,
-            profile_id: 147,
-            target_id: 43,
-            is_deleted: false,
-        },
-        {
-            match_queue_id: 21,
-            profile_id: 147,
-            target_id: 42,
-            is_deleted: false,
-        },
-        {
-            match_queue_id: 22,
-            profile_id: 147,
-            target_id: 41,
-            is_deleted: false,
-        },
     ],
 }

backend/db/seeds/04-responses.js

         responses = [...responses, ...data.responses]
     }
 }
-
 /**
  * Prevent seeding responses for
  * profile ids so we can test oboarding
  */
-responses = dataSort(responses, 'response_id').filter(
-    response => !ignore.includes(response.profile_id),
-)
+// responses = dataSort(responses, 'response_id').filter(
+// response => !ignore.includes(response.profile_id),
+// )
 
 exports.seed = async knex => {
     await knex('responses').del()
     let responsesToPush = []
-    let len = responses.length
+    const len = responses.length
     for (let i = 1; i <= len; i += 1) {
         responsesToPush.push(responses.shift())
-        if (i % batchSize === 0 || i > responses.length) {
-            // await knex('responses').insert(responsesToPush)
-            responsesToPush = []
-        }
+        // if (i % batchSize === 0 || i > responses.length) {
+        // await knex('responses').insert(responsesToPush)
+        // responsesToPush = []
+        // }
     }
+    await knex('responses').insert(responsesToPush)
 }

backend/lib/routes/filter/get.js

 'use strict'
 
+// NOTE: Current Implementation does not require this route
+// (see Auth.vue in components/onboarding and queue route with filter.js)
 const Joi = require('joi')
 const apiSchema = require('../../schemas/api')
 const errorSchema = require('../../schemas/errors')
     handlerType: 'filter',
     docs: {
         description: 'Filter match pool',
-        notes: 'Returns filtered subset of match pool'
-    }
+        notes: 'Returns filtered subset of match pool',
+    },
 }
 
 const validators = {
     query: Joi.object({
         match_pool: Joi.array().items(profileSchema.single),
         distance: Joi.string(),
-        presence: Joi.string()
-    })
+        presence: Joi.string(),
+    }),
 }
 
 const responseSchemas = {
     filteredMatchPool: filterSchema.matchPool, // array of profiles
-    error: errorSchema.single
+    error: errorSchema.single,
 }
 
 module.exports = {
     method: 'GET',
     path: '/',
-    options:{
+    options: {
         ...pluginConfig.docs,
         tags: ['api'],
         auth: false,
         handler: async function (request, h) {
             const { filterService } = request.server.services()
             let matchPool = request.query.match_pool
-            matchPool = filterService.byDistance(matchPool, request.query.distance)
-            matchPool = filterService.byPresence(matchPool, request.query.presence)
-      
+            matchPool = filterService.byDistance(
+                matchPool,
+                request.query.distance,
+            )
+            matchPool = filterService.byPresence(
+                matchPool,
+                request.query.presence,
+            )
             try {
-                return h.response(({
-                    ok:true,
-                    handler: pluginConfig.handlerType,
-                    data: matchPool
-                })).code(200)
+                return h
+                    .response({
+                        ok: true,
+                        handler: pluginConfig.handlerType,
+                        data: matchPool,
+                    })
+                    .code(200)
             } catch (err) {
                 return h
                     .response({
                         ok: false,
                         handler: pluginConfig.handlerType,
-                        data: {error: `${err}`}
+                        data: { error: `${err}` },
                     })
                     .code(409)
             }
         },
         validate: {
             ...validators,
-            failAction: 'log'
+            failAction: 'log',
         },
 
         response: {
             },
         },
     },
-}
+}

backend/lib/routes/profile/score.js

             const distanceUnit = request.query.unit
                 ? request.query.unit
                 : 'mile'
-            const duration = request.query.duration
-            const presence = request.query.presence
+            const duration = request.query.duration.includes('-')
+                ? request.query.duration.split('-')[0]
+                : request.query.duration
+            const presence =
+                request.query.presence === 'in_person'
+                    ? 'onsite'
+                    : request.query.presence
             const certifications = request.query.certifications
-
             const scoredProfiles = await profileService.scoreProfilesFor(
                 profileId,
                 maxDistanceMiles,

backend/lib/services/filter.js

         })
     }
 
-    byDuration(profileList, duration) {
-        return profileList.filter(profile => {
-            // TODO find duration
-            return profile.duration === duration
-        })
-    }
-
     byPresence(profileList, presence) {
-        return profileList.filter(profile => {
-            // TODO find presence
-            return profile.presence === presence
-        })
+        const matchingProfiles = []
+        for (const profile of profileList) {
+            for (const response of profile.responses) {
+                if (
+                    response.response_key_id === 15 &&
+                    response.val === presence
+                ) {
+                    matchingProfiles.push(profile)
+                }
+            }
+        }
+        return matchingProfiles
     }
 
-    byCertifications(profileList, certifications) {
-        return profileList.filter(profile => {
-            // TODO find certifications
-            return profile.certifications === certifications
-        })
+    byDuration(profileList, duration) {
+        const matchingProfiles = []
+        for (const profile of profileList) {
+            for (const response of profile.responses) {
+                if (
+                    response.response_key_id === 14 &&
+                    response.val === duration
+                ) {
+                    matchingProfiles.push(profile)
+                }
+            }
+        }
+        return matchingProfiles
     }
+
+    // TODO: Implement filtering by matching certification
+    // byCertifications(profileList, certifications) {
+    // return profileList.filter(profile => {
+    // return profile.certifications === certifications
+    // })
+    // }
 }

backend/lib/services/profile/index.js

 const profiler = require('./profiler')
 const scoring = require('./scorer')
 const zipcoder = require('./zipcoder')
-const filter = require('../filter')
+const Filter = require('../filter')
+const filter = new Filter()
 
 module.exports = class ProfileService extends Schmervice.Service {
     constructor(...args) {
         certifications,
     ) {
         const { Profile } = this.server.models()
-
         await this._setScoreLookup()
 
         // Our User Profile to score for
             distanceUnit,
             userZip,
         )
+
         matchPool = filter.byDistance(matchPool, maxDistance)
         matchPool = filter.byDuration(matchPool, duration)
         matchPool = filter.byPresence(matchPool, presence)
-        matchPool = filter.byCertifications(matchPool, certifications)
+        // TODO: Incorporate filtering by certifications (see filter.js)
+        // matchPool = filter.byCertifications(matchPool, certifications)
 
         const scoredProfilesWithDistance = scoring.scoreAll(
             matchPool,
     }
 
     async calcProfileDistances(matchPool, distanceUnit, userZip) {
-        await Promise.all(
+        const returnVal = await Promise.all(
             matchPool.map(async profile => {
                 const targetZip = zipcoder.getZipCodeFromProfile(profile)
                 if (!userZip || !targetZip)
                     return { ...profile, distance: [9999, distanceUnit] }
-
                 const distance = await this._compareDistance(
                     userZip,
                     targetZip,
                 }
             }),
         )
+        return returnVal
     }
 
     /**
             parseInt(zipCode),
         )
         if (!zipInfo) {
-            console.error('zip:', zipCode)
-        }
-        return {
-            latitude: parseFloat(zipInfo.latitude),
-            longitude: parseFloat(zipInfo.longitude),
+            throw new Error(
+                `ERROR :=> no zipInfo found for zipCode: ${zipCode}`,
+            )
+        } else {
+            return {
+                latitude: parseFloat(zipInfo.latitude),
+                longitude: parseFloat(zipInfo.longitude),
+            }
         }
     }
     /**
      * @param {number} distance in miles
      */
     async _compareDistance(start_zip, end_zip, distanceUnit) {
-        if (!start_zip || !end_zip || isNaN(start_zip) || isNaN(end_zip)) return
+        if (
+            !start_zip ||
+            !end_zip ||
+            Number.isNaN(start_zip) ||
+            Number.isNaN(end_zip)
+        )
+            return
         const start = await this._latLonForZip(start_zip)
         const end = await this._latLonForZip(end_zip)
         return haversine(start, end, { unit: distanceUnit })
         await this._setTagLookup()
         let associations = groupingId
             ? await TagAssociation.query()
-                .where('grouping_id', groupingId)
-                .andWhere('profile_id', profileId)
+                  .where('grouping_id', groupingId)
+                  .andWhere('profile_id', profileId)
             : await TagAssociation.query().andWhere('profile_id', profileId)
         return associations
             .map(assoc => ({

frontend/src/components/onboarding/Auth.vue

 import { authenticator } from '../../services/auth.service.js'
 import { createProfileForUserId } from '../../services/profile.service'
 import { signupUser } from '../../services/user.service.js'
+import { scoreSurveyByProfileId } from '@/services'
 
 export default {
     name: 'Auth',
         },
         async createProfileForNewUser(userId, responses) {
             try {
-                await createProfileForUserId(userId, responses)
+                const newProfileForNewUser = await createProfileForUserId(
+                    userId,
+                    responses,
+                )
+                if (!newProfileForNewUser)
+                    throw Error(
+                        `ERROR: Unable to create newProfile for userId: ${userId}`,
+                    )
+
+                // NOTE: Populates matchQueue table with bare bone
+                // minimum filtered results of possible matches
+                // Based off of initial survey answers
+                const createdProfileId = newProfileForNewUser.profile_id
+                const maxDistance = this.responses
+                    .find(response => {
+                        return response.response_key_id === 19
+                    })
+                    .val.split(' ')[0]
+                const presence = this.responses.find(response => {
+                    return response.response_key_id === 15
+                }).val
+
+                // NOTE: duration hard coded for now as bare bones
+                // survey doesn't have duration as one of its steps...
+                const duration = 'full-time'
+                await scoreSurveyByProfileId(
+                    createdProfileId,
+                    maxDistance,
+                    duration,
+                    presence,
+                )
             } catch (err) {
                 throw new Error(err)
             }

frontend/src/services/auth.service.js

 import { db } from '../utils/db.js'
 
 class Authenticator {
-    constructor() {
-        this.currentUser = null
-    }
     async sendEmail(answered) {
         return await db.post('/user/send-email/', answered)
     }

frontend/src/views/SurveyCompleteView.vue

         },
         // changeAnswers() {},
     },
+    /* 
+    NOTE: Incomplete logic for adjusting matchQueue results based 
+    off of further completion of survey, commented out for now as 
+    to not overwrite methods
     methods: {
         changeAnswers() {
             console.log('change answers')
                 survey,
             )
             if (!userProfile) return
-
-            /**
-             * Login only after there is a user and
-             * that user has a profile and all responses
-             */
             this._setLoginForProfile(userProfile)
 
             this.$router.push({ name: 'HomeView' })
             }
         },
     },
+    */
 }
 </script>
 <style>