Merge branch 'filter-before-scoring' of fyindr/siimee into dev

backend/db/seeds/04-responses.js

     for (let i = 1; i <= len; i += 1) {
         responsesToPush.push(responses.shift())
         if (i % batchSize === 0 || i > responses.length) {
-            await knex('responses').insert(responsesToPush)
+            // await knex('responses').insert(responsesToPush)
             responsesToPush = []
         }
     }

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 certifications = request.query.certifications
 
             const scoredProfiles = await profileService.scoreProfilesFor(
                 profileId,
                 maxDistanceMiles,
                 distanceUnit,
+                duration,
+                presence,
+                certifications,
             )
             try {
                 if (!scoredProfiles) {

backend/lib/services/filter.js

+const zipcoder = require ('./profile/zipcoder')
+
+const byProfileType = (profileList, userProfile) => {
+    const isUserOpposite = userProfile.is_poster == 1 ? 0 : 1
+    return profileList.filter(profile => (profile.user.is_poster == isUserOpposite))
+}
+const byNullZip = (profileList) => {
+    return profileList.filter(profile => {
+        return zipcoder.getZipCodeFromProfile(profile) ? true : false
+    })
+}
+const byMaxDistance = (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 byDuration = (profileList, duration) => {
+    return profileList.filter(profile => {
+        // TODO find duration 
+        return profile.duration == duration
+    })
+}
+
+const byPresence = (profileList, presence) => {
+    return profileList.filter(profile => {
+        // TODO find presence 
+        return profile.presence == presence
+    })
+}
+
+const byCertifications = (profileList, certifications) => {
+    return profileList.filter(profile => {
+        // TODO find certifications 
+        return profile.certifications == certifications
+    })
+}
+
+module.exports = {
+    byProfileType,
+    byNullZip,
+    byMaxDistance,
+    byDuration,
+    byPresence,
+    byCertifications,
+}

backend/lib/services/profile/index.js

 const profiler = require('./profiler')
 const scoring = require('./scorer')
 const zipcoder = require('./zipcoder')
-const { response } = require('@hapi/hapi/lib/validation')
+const filter = require('../filter')
 
 module.exports = class ProfileService extends Schmervice.Service {
     constructor(...args) {
      * @param {number} profileId
      * @returns {Array} Ordered and scored Profiles
      */
-    async scoreProfilesFor(profileId, maxDistance, distanceUnit) {
+    async scoreProfilesFor(
+        profileId,
+        maxDistance,
+        distanceUnit,
+        duration,
+        presence,
+        certifications,
+    ) {
         const { Profile } = this.server.models()
 
         await this._setScoreLookup()
             .withGraphFetched('responses')
             .withGraphFetched('user')
 
-        // Move unneeded responses
         const userZip = zipcoder.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()
+        // preprocess potential match pool with filter service methods
+        let matchPool = 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 => {
-                return profile.user.is_poster == isPosterOpposite
-            })
-            .filter(profile => {
-                // Only include profiles that included zipcode response
-                return zipcoder.getZipCodeFromProfile(profile) ? true : false
-            })
 
-        const profilePlusDistance = await Promise.all(
-            profileIdsOfOppositeType.map(async profile => {
-                const targetZip = zipcoder.getZipCodeFromProfile(profile)
+        matchPool = filter.byProfileType(matchPool, userProfile.user)
+        matchPool = filter.byNullZip(matchPool)
+        // attach distance to pool profiles for max distance filter
+        matchPool = await this.calcProfileDistances(
+            matchPool,
+            distanceUnit,
+            userZip,
+        )
+        matchPool = filter.byMaxDistance(matchPool, maxDistance)
+        matchPool = filter.byDuration(matchPool, duration)
+        matchPool = filter.byPresence(matchPool, presence)
+        matchPool = filter.byCertifications(matchPool, certifications)
 
+        const scoredProfilesWithDistance = scoring.scoreAll(
+            matchPool,
+            userProfile,
+            this.scoreLookup,
+        )
+        // Order by score
+        return scoredProfilesWithDistance.sort(
+            (a, b) => b.score.total - a.score.total,
+        )
+    }
+
+    async calcProfileDistances(matchPool, distanceUnit, userZip) {
+        await Promise.all(
+            matchPool.map(async profile => {
+                const targetZip = zipcoder.getZipCodeFromProfile(profile)
                 if (!userZip || !targetZip)
                     return { ...profile, distance: [9999, distanceUnit] }
 
                 }
             }),
         )
-
-        const distanceFilteredProfiles = zipcoder.filterByDistance(
-            profilePlusDistance,
-            maxDistance,
-        )
-        const scoredProfilesWithDistance = scoring.scoreAll(
-            distanceFilteredProfiles,
-            userProfile,
-            this.scoreLookup,
-        )
-        // Order by score
-        return scoredProfilesWithDistance.sort(
-            (a, b) => b.score.total - a.score.total,
-        )
     }
 
     /**

backend/lib/services/profile/zipcoder.js

     return zipRes.val
 }
 
-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
-    })
-}
-
 module.exports = {
     getZipCodeFromProfile,
-    filterByDistance,
 }

frontend/src/main.js

 import App from './App.vue'
 import MainNav from './components/MainNav.vue'
 
-const DEV = import.meta.env.VITE_DEV == 'true'
+// const DEV = import.meta.env.VITE_DEV == 'true'
+const DEV = false
 
 /**
  * Check between route changes for login/timeout

frontend/src/services/survey.service.js

     })
 }
 
-const scoreSurveyByProfileId = async (profileId, maxDistance = 99) => {
+const scoreSurveyByProfileId = async (
+    profileId,
+    maxDistance = 99,
+    duration,
+    presence,
+    certifications,
+) => {
     const scoreSurvey = await db.get(
-        `/profile/${profileId}/score?max_distance=${maxDistance}`,
+        `/profile/${profileId}/score?max_distance=${maxDistance}&duration=${duration}&presence=${presence}&certifications=${certifications}`,
     )
     return scoreSurvey
 }

frontend/src/utils/lang.js

 // Easily reorder steps of survey here:
 const allSteps = {
     usa: {
-        email: 'email',
+        splash: 'splash',
         name: 'name',
         seeking: 'seeking',
         password: 'password',

frontend/src/views/SurveyView.vue

 
             return userProfileRel
         },
-        async _getProfileWithScore(createdProfileId, maxDistance) {
+        async _getProfileWithScore(
+            createdProfileId,
+            maxDistance,
+            duration,
+            presence,
+            certifications,
+        ) {
             /** A Profile is associated with n:1 user and referenced by profile id */
             const fetchedProfile = await fetchProfileByProfileId(
                 createdProfileId,
             const scored = await scoreSurveyByProfileId(
                 createdProfileId,
                 maxDistance,
+                duration,
+                presence,
+                certifications,
             )
             if (!scored) {
                 console.error(`Could not score Profile ${createdProfileId}.`)
             const maxDistanceRes = survey.find(
                 res => res.response_key_id == distanceKey,
             )
+            const duration = survey.find(
+                res => res.response_key_id == prefKeys[1], // == 10
+            )
+            const presence = survey.find(
+                res => (res.response_key_id = prefKeys[2]), // == 11
+            )
+            // TODO find certifications in responses
+            const certifications = survey.find(
+                res => (res.response_key_id = certifications),
+            )
+
             /**
              * Creating a profile only returns the created
              * user id and profile id
             const fetchedProfile = await this._getProfileWithScore(
                 createdProfileId,
                 maxDistanceRes.val,
+                duration.val,
+                presence.val,
+                certifications.val,
             )
 
             /**