:sparkles: doing distance filtering on score endpoint

backend/db/mock.js

             response_key_prompt: 'what kind of schedule are you looking for',
             response_key_description: null,
         },
+        {
+            response_key_id: 16,
+            response_key_category: 'locationPref',
+            response_key_prompt: 'what is your zip code',
+            response_key_description: null,
+        },
     ],
     responses: [
         {
             response_key_id: 11,
             val: '180',
         },
+        { response_id: 85, profile_id: 1, response_key_id: 16, val: '90065' },
+        { response_id: 86, profile_id: 2, response_key_id: 16, val: '90012' },
+        { response_id: 87, profile_id: 3, response_key_id: 16, val: '90023' },
+        { response_id: 88, profile_id: 4, response_key_id: 16, val: '90001' },
+        { 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' },
     ],
     memberships: [
         {

backend/lib/models/zip-code.js

+const Schwifty = require('@hapipal/schwifty')
+const Joi = require('joi')
+
+module.exports = class ZipCode extends Schwifty.Model {
+    static get tableName() {
+        return 'zip_codes'
+    }
+    static get joiSchema() {
+        return Joi.object({
+            zip_code_id: Joi.number(),
+            latitude: Joi.string().required(),
+            longitude: Joi.string().required(),
+            city: Joi.string().required(),
+            state: Joi.string().required(),
+            county: Joi.string().required(),
+        })
+    }
+}

backend/lib/plugins/profile.js

 
 const ProfileModel = require('../models/profile')
 const ResponseModel = require('../models/response')
+const ZipCodeModel = require('../models/zip-code')
 
 const ProfileService = require('../services/profile')
 
     register: async (server, options) => {
         await server.registerModel(ProfileModel)
         await server.registerModel(ResponseModel)
+        await server.registerModel(ZipCodeModel)
 
         // Bind to global context
         // So we can use Objection transactions

backend/lib/routes/profile/score.js

     }),
 
     /** Validate the route query (/active/{thing}?limit=10&offset=10) */
-    // query: true,
+    query:Joi.object({
+        max_distance: Joi.number(),
+        unit: Joi.string(),
+    }),
     /** Validate the incoming payload (POST method) */
     // payload: true,
 }
         handler: async function (request, h) {
             const { profileService } = request.services()
             const profileId = request.params.profile_id
-            const profiles = await profileService.scoreProfilesFor(profileId)
-
+            const maxDistanceMiles = request.query.max_distance
+            const distanceUnit = request.query.unit ? request.query.unit : 'mile'
+            const profiles = await profileService.scoreProfilesFor(profileId, maxDistanceMiles, distanceUnit)
             try {
                 if(!profiles){
                     throw new RangeError('Unable to score profiles')

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 magic = 1000
 const scoreResponses = (seeker, potentialMatch) => {
 
         return await Profile.query().delete().where('profile_id', profileId)
     }
-
+    /** 
+     * Grab the zip code string
+    */
+    _getZipCodeFromProfile(profile) {
+        // There should only be one zip code entry per profile
+        let zip = profile.responses.filter(response => response.response_key_id == 16)[0]
+        const responseIndexForZip = profile.responses.indexOf(zip)
+        if(responseIndexForZip >= 0) {
+            profile.responses.splice(responseIndexForZip, 1)
+        }
+        return zip.val
+    }
     /**
      * Score a profile
      * @param {number} profileId
      * @returns {Array} Ordered and scored Profiles
      */
-    async scoreProfilesFor(profileId) {
+    async scoreProfilesFor(profileId, maxDistanceMiles, distanceUnit) {
         const { Profile } = this.server.models()
-
+        
         // Our User Profile to score for
         const userProfile = await Profile.query()
-            .findOne('profile_id', profileId)
-            .withGraphFetched('responses')
-            .withGraphFetched('user')
-
-        const isPosterOpposite = userProfile.user.is_poster == 1 ? 0 : 1
+        .findOne('profile_id', profileId)
+        .withGraphFetched('responses')
+        .withGraphFetched('user')
+        
+        // Move unneeded responses
+        const userZip = this._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
-        profileIdsOfOppositeType = profileIdsOfOppositeType.filter(
-            profile => profile.user.is_poster == isPosterOpposite,
-        )
-
-        const scored = profileIdsOfOppositeType.map(profile => ({
-            profile_id: profile.profile_id,
-            score: scoreResponses(userProfile, profile),
+        const isPosterOpposite = userProfile.user.is_poster == 1 ? 0 : 1
+        profileIdsOfOppositeType = profileIdsOfOppositeType.filter(profile => profile.user.is_poster == isPosterOpposite)
+        
+        const profilePlusDistance = await Promise.all(profileIdsOfOppositeType.map(async profile => {
+            const targetZip = this._getZipCodeFromProfile(profile)
+            const distance = await this._compareDistance(userZip, targetZip, distanceUnit)
+            return {
+                ...profile,
+                distance: [distance.toFixed(2), distanceUnit]
+            }
         }))
+
+        // Filter by distance
+        // TODO: probably do this with a query
+        const distanceFiltered = profilePlusDistance.filter(profile => {
+            const profileDistance = Math.floor(parseFloat(profile.distance) * 100)
+            const adjustedMaxDistance = Math.floor(parseFloat(maxDistanceMiles) * 100)
+            return profileDistance <= adjustedMaxDistance
+        })
+
+        const scored = distanceFiltered.map(profile => {
+            return {
+                // Uncomment to return the whole profile
+                // ...profile,
+                profile_id: profile.profile_id,
+                score: scoreResponses(userProfile, profile),
+                distance: profile.distance
+            }
+        })
+        // Order by score
         return scored.sort((a, b) => a.score - b.score)
     }
+    
+    /**
+     * Use the db for zipcode info
+     * @param {string} zipCode
+     * @param {object}
+     */
+    async _latLonForZip(zipCode) {
+        const { ZipCode } = this.server.models()
+
+        const zipInfo = await ZipCode.query().findOne('zip_code_id', parseInt(zipCode))
+        const latitude = parseFloat(zipInfo.latitude)
+        const longitude =  parseFloat(zipInfo.longitude)
+        
+        return { latitude, longitude }
+    }
+    /**
+     * Get the distance between two zipcodes
+     * using the haversine formula
+     * @param {string} start_zip
+     * @param {string} end_zip
+     * @param {number} distance in miles
+     */
+    async _compareDistance(start_zip, end_zip, distanceUnit) {
+        if(!start_zip || !end_zip) return
+        
+        const start = await this._latLonForZip(start_zip)
+        const end = await this._latLonForZip(end_zip)
+        
+        return haversine(start, end, { unit: distanceUnit })
+    }
 }

backend/package-lock.json

         "type-fest": "^0.8.0"
       }
     },
+    "haversine": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/haversine/-/haversine-1.1.1.tgz",
+      "integrity": "sha512-KW4MS8+krLIeiw8bF5z532CptG0ZyGGFj0UbKMxx25lKnnJ1hMUbuzQl+PXQjNiDLnl1bOyz23U6hSK10r4guw=="
+    },
     "homedir-polyfill": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/homedir-polyfill/-/homedir-polyfill-1.0.3.tgz",

backend/package.json

     "dotenv": "^10.0.0",
     "exiting": "^6.0.1",
     "hapi-swagger": "^14.1.3",
+    "haversine": "^1.1.1",
     "joi": "^17.4.0",
     "knex": "^0.21.19",
     "mysql": "^2.18.1",