:recycle: moving around some score functions

backend/lib/services/profile.js

         ) * magic,
     )
 }
+const filterByDistance = (profileList, max) => {
+    return profileList.filter(profile => {
+        const profileDistance = Math.floor(parseFloat(profile.distance) * 100)
+        const adjustedMaxDistance = Math.floor(parseFloat(max) * 100)
+        return profileDistance <= adjustedMaxDistance
+    })
+}
+const scoreAll = (profileList, userProfile) => {
+    return profileList.map(profile => {
+        return {
+            // Uncomment to return the whole profile
+            // ...profile,
+            profile_id: profile.profile_id,
+            score: scoreResponses(userProfile, profile),
+            distance: profile.distance
+        }
+    })
+}
+/** 
+     * Grab the zip code string
+    */
+ const 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
+}
 
 /**
  * Class to hold our retrieved profile information
 
         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, maxDistanceMiles, distanceUnit) {
+    async scoreProfilesFor(profileId, maxDistance, distanceUnit) {
         const { Profile } = this.server.models()
         
         // Our User Profile to score for
         .withGraphFetched('user')
         
         // Move unneeded responses
-        const userZip = this._getZipCodeFromProfile(userProfile)
+        const userZip = getZipCodeFromProfile(userProfile)
 
         // Find all Profiles that are NOT of our userProfile.type
         // ie. If userProfile.type == seeker, then find: poster
         profileIdsOfOppositeType = profileIdsOfOppositeType.filter(profile => profile.user.is_poster == isPosterOpposite)
         
         const profilePlusDistance = await Promise.all(profileIdsOfOppositeType.map(async profile => {
-            const targetZip = this._getZipCodeFromProfile(profile)
+            const targetZip = getZipCodeFromProfile(profile)
             const distance = await this._compareDistance(userZip, targetZip, distanceUnit)
             return {
                 ...profile,
             }
         }))
 
-        // 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 distanceFilteredProfiles = filterByDistance(profilePlusDistance, maxDistance)
+
+        const scoredProfilesWithDistance = scoreAll(distanceFilteredProfiles, userProfile)
 
-        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)
+        return scoredProfilesWithDistance.sort((a, b) => a.score - b.score)
     }
     
     /**