:recycle: auto-filling surveys from the frontend | login route handling after sign-up

backend/db/data-generator/config.json

 {
     "mockOutputPath": "./db/generated",
     "magic": 10000,
-    "total": 50,
+    "total": 5,
     "batchSize": 5,
     "percentageOfSeekers": 90,
     "scoreVals": [107, 414, 721, 1028, 1336, 1648, 2056],
         "91399",
         "91401",
         "97075"
-    ]
+    ],
+    "resKeys": [1, 2, 3, 4, 5, 6],
+    "zipcodeKey": 7,
+    "maxDistanceKey": 16
 }

backend/db/data-generator/index.js

             }
             else {
                 switch (resToEdit.response_key_id) {
-                    case 8:
-                        resToEdit.val = random.media()
-                        break
-                    case 9:
-                        resToEdit.val = random.language()
-                        break
-                    case 10:
-                        resToEdit.val = random.duration()
-                        break
-                    case 11:
-                        resToEdit.val = random.location()
-                        break
-                    case 12:
-                        resToEdit.val = random.blurb()
-                        break
+                case 8:
+                    resToEdit.val = random.media()
+                    break
+                case 9:
+                    resToEdit.val = random.language()
+                    break
+                case 10:
+                    resToEdit.val = random.duration()
+                    break
+                case 11:
+                    resToEdit.val = random.location()
+                    break
+                case 12:
+                    resToEdit.val = random.blurb()
+                    break
                 }
             }
         }
     })
-    generatedResponseCount = generatedResponseCount + responses.length
+    // generatedResponseCount = generatedResponseCount + responses.length
     console.log('COMPLETED: Generated Responses...')
     return responses
 }

backend/db/data-generator/mock.js

     ],
     responses: [],
     memberships: [
-        {
-            membership_id: 1,
-            profile_id: 45,
-            grouping_id: 1,
-            membership_type: 'participant',
-            can_edit: 0,
-            is_active: 1,
-        },
-        {
-            membership_id: 2,
-            profile_id: 2,
-            grouping_id: 1,
-            membership_type: 'participant',
-            can_edit: 0,
-            is_active: 1,
-        },
-        {
-            membership_id: 3,
-            profile_id: 45,
-            grouping_id: 2,
-            membership_type: 'participant',
-            can_edit: 0,
-            is_active: 1,
-        },
-        {
-            membership_id: 4,
-            profile_id: 3,
-            grouping_id: 2,
-            membership_type: 'participant',
-            can_edit: 0,
-            is_active: 0,
-        }
+       
     ],
     groupings: [
-        {
-            grouping_id: 1,
-            grouping_name: '1654664154.291_45_2',
-            grouping_type: 'match',
-        },
-        {
-            grouping_id: 2,
-            grouping_name: '1654664154.291_45_3',
-            grouping_type: 'match',
-        }
+       
     ],
     messages: [],
     match_queues: [
-        {
-            match_queue_id: 1,
-            profile_id: 45,
-            target_id: 1,
-            is_deleted: false,
-        },
-        {
-            match_queue_id: 2,
-            profile_id: 45,
-            target_id: 5,
-            is_deleted: false,
-        },
-        {
-            match_queue_id: 3,
-            profile_id: 45,
-            target_id: 6,
-            is_deleted: false,
-        },
-        {
-            match_queue_id: 4,
-            profile_id: 45,
-            target_id: 7,
-            is_deleted: false,
-        },
-        {
-            match_queue_id: 5,
-            profile_id: 45,
-            target_id: 8,
-            is_deleted: false,
-        },
-        {
-            match_queue_id: 6,
-            profile_id: 45,
-            target_id: 9,
-            is_deleted: false,
-        },
-        {
-            match_queue_id: 7,
-            profile_id: 2,
-            target_id: 4,
-            is_deleted: false,
-        },
-        {
-            match_queue_id: 8,
-            profile_id: 2,
-            target_id: 10,
-            is_deleted: false,
-        },
+        
     ],
 }

backend/db/data-generator/random.js

     return l.generate(randomNumber(50))
 }
 
+
 module.exports = {
+    randomNumber,
+    randomValFrom,
+    randomEmail,
+    randomName,
+    randomMedia,
+    randomLang,
+    randomDuration,
+    randomLocation,
+    randomBlurb,
     number: randomNumber,
     valFrom: randomValFrom,
     email: randomEmail,

backend/lib/routes/user/create-profile.js

         tags: ['api'],
         /** Protect this route with authentication? */
         auth: false,
-
+        cors: true,
         handler: async function (request, h) {
             const { userService, profileService } = request.server.services()
             const userId = request.params.user_id

backend/lib/routes/user/signup.js

 
 const validators = {
     post: {
-        payload: Joi.object({
-            user: userSchema.userSignup,
-            error: errorSchema.single,
-        }).append().label('signup_payload')
+        payload: userSchema.userSignup
     }
 }
 
         tags: ['api'],
         /** Protect this route with authentication? */
         auth: false,
-
+        cors: true,
         handler: async function (request, h) {
             const { userService } = request.server.services()
             const res = request.payload
-            const userName = res.user.user_name
-            const userEmail = res.user.user_email
-            const userType = res.user.user_type == 'poster' ? 1 : 0
-            const userPw = res.user.user_pass ? res.user.user_pass : 'changeme'
+            const userName = res.user_name
+            const userEmail = res.user_email
+            const userType = res.is_poster
+            const userPw = res.user_pass ? res.user_pass : 'changeme'
             try {
                 const user = await userService.signup({
                     password: userPw,

backend/lib/services/profile.js

 const haversine = require('haversine')
 const config = require('../../db/data-generator/config.json')
 
-// Keys that are profile data responses
-const _TEMP_RES_KEYS = [1, 2, 3, 4, 5, 6]
-const _ZIPCODEKEY = 7
+const _isScorableResponse = res_key_id => {
+    let isScorable = false
+    if(config.resKeys.includes(res_key_id)) {
+        isScorable = true
+    }
+    return isScorable
+}
+
 const scoreResponses = (seeker, potentialMatch, prescoreLookup) => {
     if (seeker.responses.length != potentialMatch.responses.length)
         return {
         }
 
     const aRes = seeker.responses.filter(
-        res => _TEMP_RES_KEYS.includes(res.response_key_id)
+        res =>  _isScorableResponse(res.response_key_id)
     )
     const bRes = potentialMatch.responses.filter(
-        res => _TEMP_RES_KEYS.includes(res.response_key_id)
+        res =>  _isScorableResponse(res.response_key_id)
     )
 
     const composite = []
  */
 const getZipCodeFromProfile = profile => {
     // There should only be one zip code entry per profile
-    let zipRes = profile.responses.filter(
-        // Whatever the zipcode questions is
-        response => response.response_key_id == _ZIPCODEKEY,
-    )[0]
-
-    const responseIndexForZip = profile.responses.indexOf(zipRes)
-    if (responseIndexForZip >= 0) {
-        profile.responses.splice(responseIndexForZip, 1)
-    }
+    let zipRes = profile.responses.find(
+        res => res.response_key_id == 7
+    )
     return zipRes.val
 }
 
         this.profile_languages = []
         this.profile_prefs = {}
         if (profile?.responses?.length) {
-            this.responses = profile.responses.filter(
-                res => !_TEMP_RES_KEYS.includes(res.response_key_id),
-            ) // [] of all responses
-            const [image, language, duration, location, description] =
-                profile.responses.filter(res =>
-                    _TEMP_RES_KEYS.includes(res.response_key_id),
-                )
-            this.profile_prefs.location = location.val
-            this.profile_prefs.duration = duration.val
-            this.profile_prefs.zip = profile.responses.filter(
-                res => res.response_key_id == 7,
-            )[0].val // [] of all responses
-            this.profile_description = description.val
-            this.profile_media.push(image.val)
-            this.profile_languages.push(language.val)
+            // [] of all "profile" responses
+            this.responses = profile.responses
+            // image, language, duration, presence, blurb, urgency, role, pronouns, distance
+            const prefs = ['presence', 'duration', 'zipcode']
+            prefs.forEach(pref => {
+                this.profile_prefs[pref] = this.responses.filter(
+                    r => r.response_key_prompt === pref
+                )[0]
+            })
+            this.profile_description = this.responses.filter(r=> r.response_key_prompt === 'blurb')[0]
+            this.profile_media = this.responses.filter(r => r.response_key_prompt === 'image')
+            this.profile_languages = this.responses.filter(r => r.response_key_prompt === 'language')
         }
     }
 }
             user_id: userId,
         })
         for (const responseToSave of responses) {
+            /**
+             * Convert indexes to actual score values
+             * Using using the input and converting to index
+             * of the generated possible prescore array in config
+             * DUPLICATE:See saveResponseForProfile() line 343
+             */ 
+            let convertedResponse = responseToSave
+            if(_isScorableResponse(responseToSave.response_key_id)) {
+                // Convert -3 to 0, 0 to 3, 3 to 6
+                const offset = (config.scoreVals.length - 1) / 2
+                const indexFromInput = parseInt(responseToSave.val) + offset
+                convertedResponse.val = config.scoreVals[indexFromInput].toString()
+            }
+
             const responseInfo = {
                 profile_id: profile.id,
-                response_key_id: responseToSave.response_key_id,
-                val: responseToSave.val,
+                response_key_id: convertedResponse.response_key_id,
+                val: convertedResponse.val,
             }
             await Response.query(txn).insert(responseInfo)
         }
          * of the generated possible prescore array in config
          */ 
         let convertedResponse = responseToSave
-        if(_TEMP_RES_KEYS.includes(responseToSave.response_key_id)) {
+        if(_isScorableResponse(responseToSave.response_key_id)) {
             // Convert -3 to 0, 0 to 3, 3 to 6
             const offset = (config.scoreVals.length - 1) / 2
             const indexFromInput = parseInt(responseToSave.val) + offset
-            convertedResponse.val = config.scoreVals[indexFromInput]
+            convertedResponse.val = config.scoreVals[indexFromInput].toString()
         }
 
         await Response.query().insert(convertedResponse)
             .findOne('profile_id', profileId)
             .withGraphFetched('responses')
             .withGraphFetched('user')
-
+        
         // Move unneeded responses
         const userZip = getZipCodeFromProfile(userProfile)
 
 
         // 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(
-                res => res.response_key_id == _ZIPCODEKEY,
-            )
-            return zipcodeResponses.length > 0
+            return profile.user.is_poster == isPosterOpposite
+        }).filter(profile => {
+            // Only include profiles that included zipcode response
+            return getZipCodeFromProfile(profile) ? true : false
         })
-
+        
         const profilePlusDistance = await Promise.all(
             profileIdsOfOppositeType.map(async profile => {
                 const targetZip = getZipCodeFromProfile(profile)
                 }
             }),
         )
-
         const distanceFilteredProfiles = filterByDistance(
             profilePlusDistance,
             maxDistance,
         )
-
         const scoredProfilesWithDistance = scoreAll(
             distanceFilteredProfiles,
             userProfile,