:bug: fixed zipcode scoring | limited to profiles with zipcode response | including user in profile for queue

backend/lib/routes/profile/queue.js

                 profile_id: Joi.number(),
                 user_id: Joi.number(),
                 responses: Joi.array().items(),
+                profile_image: Joi.string(),
                 user_type: Joi.any(),
+                user: Joi.object()
             }),
         )
     ),
             if(include_profile) {
                 res.data = await profileService.getProfilesFor(queueIds)
             }
-            console.log(res.data)
+            // console.log(res.data)
             try {
                 return h.response(res).code(200)
             } catch (err) {

backend/lib/routes/user/current.js

         tags: ['api'],
         auth: 'default_jwt',
         handler: async function (request, h) {
-            console.log('current')
-            console.log(request)
+            // console.log('current')
+            // console.log(request)
             try {
                 const auth = {
                     credentials: request.auth.credentials,

backend/lib/services/profile.js

 const Schmervice = require('@hapipal/schmervice')
 const cosineSimilarity = require('compute-cosine-similarity')
 const haversine = require('haversine')
-
+const zipcodeKey = 7
 const magic = 1000
 const scoreResponses = (seeker, potentialMatch) => {
     if (seeker.responses.length != potentialMatch.responses.length)
  */
 const getZipCodeFromProfile = profile => {
     // There should only be one zip code entry per profile
-    let zip = profile.responses.filter(
-        response => response.response_key_id == 16,
+    let zipRes = profile.responses.filter(
+        // Whatever the zipcode questions
+        response => response.response_key_id == zipcodeKey,
     )[0]
-    const responseIndexForZip = profile.responses.indexOf(zip)
+    const responseIndexForZip = profile.responses.indexOf(zipRes)
     if (responseIndexForZip >= 0) {
         profile.responses.splice(responseIndexForZip, 1)
     }
-    return zip.val
+    // console.log(zipRes)
+    return zipRes.val
 }
 
 /**
     constructor(profile, type) {
         this.user_id = profile.user_id // int user_id
         this.profile_id = profile.profile_id // int profile_id
+        this.profile_image = profile.user_media // int profile_id
         this.responses = profile.responses // [] of all responses
         this.user_type = type
+        
+        this.user = profile.user
     }
 }
 
         const profilesEntries = await Profile.query()
             .whereIn('profile_id', profileIdArray)
             .withGraphFetched('responses')
+            .withGraphFetched('user')
 
         return profilesEntries.map(profile => {
             return new CompleteProfile(profile, type)
         let profileIdsOfOppositeType = await Profile.query()
             .withGraphFetched('responses')
             .withGraphFetched('user')
-
+        
         // TODO: Let Objection optimize this
         const isPosterOpposite = userProfile.user.is_poster == 1 ? 0 : 1
         profileIdsOfOppositeType = profileIdsOfOppositeType.filter(
             profile => profile.user.is_poster == isPosterOpposite,
         )
 
+        // Only include profiles that included zipcode response
+        profileIdsOfOppositeType = profileIdsOfOppositeType.filter(profile => {
+            const zipcodeResponses = profile.responses.filter(response => response.response_key_id == zipcodeKey)
+            return zipcodeResponses.length > 0
+        })
+
         const profilePlusDistance = await Promise.all(
             profileIdsOfOppositeType.map(async profile => {
                 const targetZip = getZipCodeFromProfile(profile)
+                
+                if(!userZip || !targetZip) return { ...profile, distance: [9999, distanceUnit] }
+
                 const distance = await this._compareDistance(
                     userZip,
                     targetZip,
             parseInt(zipCode),
         )
         if (!zipInfo) {
-            console.log(zipCode)
+            console.log('zip:', zipCode)
         }
 
         return {
      * @param {number} distance in miles
      */
     async _compareDistance(start_zip, end_zip, distanceUnit) {
-        if (!start_zip || !end_zip) return
+        if (!start_zip || !end_zip || isNaN(start_zip) || isNaN(end_zip)) return
 
         const start = await this._latLonForZip(start_zip)
         const end = await this._latLonForZip(end_zip)