:construction: Continued work on email valdiation and saving survey state

backend/lib/routes/user/generatejwt.js

 }
 
 module.exports = {
-    method: 'GET',
-    path: '/generatejwt/{hash}',
+    method: 'POST',
+    path: '/generatejwt',
     options: {
         ...pluginConfig.docs.get,
         tags: ['api'],
         cors: true,
         handler: async function (request, h) {
             const { userService } = request.server.services()
-            const hash = request.params.hash
-            const user = {
-                user_email: hash,
-            }
-            const token = await userService.createToken(user)
+            const res = request.payload
+
+            const token = await userService.createToken(res)
             try {
                 return {
                     ok: true,

backend/lib/routes/user/validatejwt.js

                 return {
                     ok: true,
                     handler: pluginConfig.handlerType,
-                    data: { isValid: jwtIsValid.isValid },
+                    data: {
+                        isValid: jwtIsValid.isValid,
+                        payload: jwtIsValid.payload,
+                    },
                 }
             } catch (err) {
                 return {

backend/lib/services/user.js

         super(...args)
         const pwd = new SecurePassword()
         this.hashedEmail = ''
+        // this.hashedEmails = []
         this.pwd = {
             hash: Util.promisify(pwd.hash.bind(pwd)),
             verify: Util.promisify(pwd.verify.bind(pwd)),
             {
                 aud: 'urn:audience:test',
                 iss: 'urn:issuer:test',
-                email: user.user_email,
+                email: user.email,
+                name: user.name,
+                seeking: user.seeking,
             },
             {
                 key: key,
     validateToken(token) {
         const key = this.server.registrations['main-app-plugin'].options.jwtKey
         const decodedToken = Jwt.token.decode(token)
+        console.log('decodedToken :=>', decodedToken)
         // NOTE: reveals email...perhaps unhashed email belongs here instead...
-        // console.log('decodedToken :=>', decodedToken)
         try {
             Jwt.token.verify(decodedToken, key)
-            return { isValid: true }
+            return { isValid: true, payload: decodedToken.decoded.payload }
         } catch (err) {
             return { isValid: false, error: err.message }
         }
             },
         )
         this.hashedEmail = hashEmail(userEmail)
+        // this.hashedEmails.push(hashEmail(userEmail))
     }
 }

frontend/src/components/onboarding/Auth.vue

             default: () => {},
         },
     },
-    emits: ['update-answers'],
+    emits: ['update-answers', 'set-pid'],
     data: () => ({
         authenticator: {},
     }),
     async created() {
+        // establishes new user and emits it up to onboarding for login purposes
         this.authenticator = new Authenticator()
         if (this.survey.hasMinResponsesToCreateProfile(this.answered)) {
             const newUser = await signupUser(this.answered)
             const newUserId = newUser.user_id
-            try {
-                await createProfileForUserId(newUserId, this.responses)
-            } catch (err) {
-                console.error('ERROR :=>', err)
-            }
-        }
+            const newProfile = await createProfileForUserId(
+                newUserId,
+                this.responses,
+            )
 
-        this.authenticator.sendAuthEmail(this.answered)
-        // TODO: Consider waiting until email hash is verified...(i.e. not in created)
-        signupUser(this.answered)
+            // sets jwt authentication cookie to be used in VerifyView.vue
+            // TODO: Instead of having this.answered here, simply pass profile_id?
+            const jwt = await this.authenticator.generateJwt(this.answered)
+            document.cookie = `siimee_jwt=${jwt}; path=/verify`
+            // this.$emit('set-pid', newProfile.profile_id)
+
+            // sends authentication email
+            this.authenticator.sendAuthEmail(this.answered)
+        }
     },
     methods: {
         // TODO: remove test button above and use a watcher instead to emit this

frontend/src/services/auth.service.js

         const isVerified = await db.get(`/user/verify/${hash}`)
         return isVerified.hashesMatch
     }
-    async generateJwt(hash) {
-        const token = await db.get(`/user/generatejwt/${hash}`)
+    // TODO: this needs to generate the JWT with the RAW email
+    async generateJwt(res) {
+        const token = await db.post('/user/generatejwt', res)
         return token.jwt
     }
     async validateJwt(jwt) {
         const validateJwt = await db.get(`/user/validatejwt/${jwt}`)
-        return validateJwt.isValid
+        return validateJwt
     }
 }
 

frontend/src/views/OnboardingView.vue

                 :responses='responses'
                 :survey='survey'
                 :currentStep='currentStep'
+                :jwt='jwt'
                 :surveyStepsCount='survey.steps.length'
                 @handle-submit='onSubmit'
                 @update-answers='updateAnswers'
+                @set-pid='setPid'
                 v-if='step && currentStep == i'
             ) 
         .invalidResponseMessage(
 <script>
 import { Authenticator } from '../services/auth.service.js'
 import { surveyFactory } from '@/utils'
+import { currentProfile } from '../services/'
 import stepViews from '@/components/onboarding'
 import SurveyCompleteView from './SurveyCompleteView.vue'
 
         authenticator: {},
         jwt: '',
     }),
+    computed: {
+        // NOTE: perhaps start this off as returning nothing
+        // and then add currentProfile in created()?
+        profile: () => currentProfile,
+    },
     async created() {
+        // console.log('this.profile.id :=>', this.profile.id)
         if (document.cookie.length) {
-            const siimeeToken = this.grabToken(document.cookie)
+            // TODO: Remove this this.answered section when:
+            // SurveyCompleteView calls all responses from db
+            const siimeeAnswers = JSON.parse(
+                this.grabCookie(document.cookie, 'siimee_answered'),
+            )
+            this.answered = {
+                name: siimeeAnswers.name,
+                email: siimeeAnswers.email,
+                seeking: siimeeAnswers.seeking,
+            }
+            // TODO: Instead, login using siimee_profile_id from cookie
+            const siimeeToken = this.grabCookie(document.cookie, 'siimee_jwt')
             this.jwt = siimeeToken ? siimeeToken : ''
         }
+
         this.survey = await surveyFactory.createSurvey()
         this.authenticator = new Authenticator()
         if (this.jwt.length) {
-            const jwtStillValid = await this.authenticator.validateJwt(this.jwt)
-            if (jwtStillValid) {
+            // TODO: remove once currentProfile is established and user is logged in...
+            const jwt = await this.authenticator.validateJwt(this.jwt)
+            if (jwt.isValid) {
+                // grab profileId from jwt payload and login here
+                // use this profile to grab all responses in
+                // SurveyCompleteView.vue
                 this.goToStep(6)
             } else {
                 this.goToStep(0)
         goToStep(num) {
             this.currentStep = num
         },
-        grabToken(cookieString) {
+        grabCookie(cookieString, cookieKey) {
             const cookies = cookieString.split('; ').reduce((prev, current) => {
                 const [name, ...value] = current.split('=')
                 prev[name] = value.join('=')
                 return prev
             }, {})
-            return 'siimee_jwt' in cookies ? cookies['siimee_jwt'] : undefined
+            return cookieKey in cookies ? cookies[`${cookieKey}`] : undefined
         },
         async updateAnswers(payload) {
             // null payload is passed on splash page
                     this.invalidResponse = true
                     return
                 }
-                //
+
                 // once validated, don't log password in answered object
                 // this.answered[k] = k === 'password' ? undefined : payload.input
 
                 this.goToStep(this.currentStep + 1)
             }
         },
+        // NOTE: Brought in from App.vue, might not be necessary...
+        // Allows for login after initial email sign up is set
+        async setPid(profileId) {
+            if (currentProfile.isLoggedIn) {
+                currentProfile.logout()
+            }
+            // ERROR: this._profile is undefinedin login service
+            this.profile.id = await currentProfile.login(
+                profileId,
+                this.$waveui.notify,
+            )
+            console.log('---')
+
+            // Change if survey isn't complete...
+            // const toRoute = { name: 'HomeView' }
+            // this.$router.push(toRoute)
+        },
     },
 }
 </script>

frontend/src/views/VerifyView.vue

 <template lang="pug">
 .wait-message
-    p.verify-message Thanks for authenticating your email {{ name }}!
+    p.verify-message Thanks for authenticating your email!
     p.verify-message Please give us a moment to redirect you back to the survey
 </template>
 
         this.authenticator = new Authenticator()
         const hashEmail = this.$route.params.email
         const hashesMatch = await this.authenticator.verifyAuthEmail(hashEmail)
-        if (hashesMatch) {
-            const jwt = await this.authenticator.generateJwt(hashEmail)
-            document.cookie = `siimee_jwt=${jwt}; path=/onboarding`
+        const siimeeToken = this.grabToken(document.cookie)
+
+        // TODO: remove once currentProfile is established and user is logged in...
+        // NOTE: another siimee_jwt cookie for onboarding path instead of verify
+        document.cookie = `siimee_jwt=${siimeeToken}; path=/onboarding`
+
+        const jwt = await this.authenticator.validateJwt(siimeeToken)
+
+        if (jwt.isValid && hashesMatch) {
+            // TODO: set jwt.payload.profile_id as siimee_profile_id
+            // remove answers, will query db at SurveyCompleteView.vue
+            const siimeeAnswers = JSON.stringify(jwt.payload)
+            document.cookie = `siimee_answered=${siimeeAnswers} ; path=/onboarding`
             this.$router.push('/onboarding')
         }
         // else {
         // render ERROR message above or redirect to 404 (or both?)
-        // }
+    },
+    methods: {
+        grabToken(cookieString) {
+            const cookies = cookieString.split('; ').reduce((prev, current) => {
+                const [name, ...value] = current.split('=')
+                prev[name] = value.join('=')
+                return prev
+            }, {})
+            return 'siimee_jwt' in cookies ? cookies['siimee_jwt'] : undefined
+        },
     },
 }
 </script>