:construction: Continuing work on integrating email transac

backend/lib/plugins/user.js

 const UserLoginRoute = require('../routes/user/login')
 const UserSignupRoute = require('../routes/user/signup')
 const UserEmailRoute = require('../routes/user/email.js')
+const UserVerifyEmailRoute = require('../routes/user/verifyemail.js')
 const UserPassword = require('../routes/user/authentication')
 
 const UserService = require('../services/user')
         await server.route(UserProfileCreateRoute)
         await server.route(UserProfilesListRoute)
         await server.route(UserEmailRoute)
+        await server.route(UserVerifyEmailRoute)
         await server.route(UserPassword)
     },
 }

backend/lib/routes/user/email.js

         handler: async function (request, h) {
             const { userService } = request.server.services()
             const userEmail = request.payload.email
-            const userPw = request.payload.password
-            console.log('this.answered :=>', request.payload)
             try {
                 const emailSent = userService.emailSent(userEmail)
                 return {

backend/lib/routes/user/verifyemail.js

+'use strict'
+
+const Joi = require('joi')
+
+const pluginConfig = {
+    handlerType: 'email',
+    docs: {
+        get: {
+            description: 'verifies confirmation email',
+            notes: 'Verifies the email from the stored hash',
+        },
+    },
+}
+
+module.exports = {
+    method: 'GET',
+    path: '/verify/{hash}',
+    options: {
+        ...pluginConfig.docs.get,
+        tags: ['api'],
+        auth: false,
+        cors: true,
+        handler: async function (request, h) {
+            const { userService } = request.server.services()
+            const hashToMatch = await userService.hashedEmail
+            const hash = request.params.hash
+            const hashesMatch = hashToMatch === hash ? true : false
+            try {
+                if (hashesMatch) {
+                    return {
+                        ok: true,
+                        handler: pluginConfig.handlerType,
+                        data: { hashesMatch: hashesMatch },
+                    }
+                }
+            } catch (err) {
+                return {
+                    ok: false,
+                    handler: pluginConfig.handlerType,
+                    data: {
+                        error: err,
+                    },
+                }
+            }
+        },
+        validate: {
+            failAction: 'log',
+        },
+        response: {
+            schema: Joi.object({
+                ok: Joi.bool(),
+                handler: Joi.string(),
+                data: Joi.object(),
+            }).label('verify_email_res'),
+            failAction: 'log',
+        },
+    },
+}

backend/lib/services/user.js

 'use strict'
 require('dotenv').config()
+const crypto = require('crypto')
 const Util = require('util')
 const Jwt = require('@hapi/jwt')
 const Schmervice = require('@hapipal/schmervice')
 
 const apiInstance = new SibApiV3Sdk.TransactionalEmailsApi()
 
+const hashEmail = async email => {
+    try {
+        return crypto.createHmac('sha256', '').update(email).digest('hex')
+    } catch (err) {
+        console.error('ERROR :=>', err)
+        return undefined
+    }
+}
+
 const hasher = async (pwd, steak) => {
     const hash = await pwd.hash(steak)
     const result = await pwd.verify(steak, hash)
     constructor(...args) {
         super(...args)
         const pwd = new SecurePassword()
+        this.hashedEmail = ''
         this.pwd = {
             hash: Util.promisify(pwd.hash.bind(pwd)),
             verify: Util.promisify(pwd.verify.bind(pwd)),
             ],
             templateId: 1,
             params: {
-                // TODO: create basic hashing email above and cache hash...
-                email: 'tobehashedemail',
+                // TODO: Change this in production...
+                link: `localhost:3000/verify/${await hashEmail(userEmail)}`,
             },
         }
 
         await apiInstance.sendTransacEmail(sendSmtpEmail).then(
             data => {
-                console.log('data from sendTransacEmail :=>', data)
                 return {
                     wasSuccessfull: true,
                     data: data,
                 }
             },
             error => {
-                console.error('ERROR :=>', error)
                 return {
                     wasSuccessfull: false,
                     error: error,
                 }
             },
         )
+        this.hashedEmail = hashEmail(userEmail)
     }
 }

frontend/src/components/onboarding/Auth.vue

 
 <script>
 import { Authenticator } from '../../services/auth.service.js'
+import { signupUser } from '../../services/user.service.js'
 
 export default {
     name: 'Auth',
     },
     emits: ['update-answers'],
     data: () => ({
-        authenticator: false,
+        authenticator: {},
     }),
     created() {
         this.authenticator = new Authenticator()
         console.log('this.answered :=>', this.answered)
         this.authenticator.sendAuthEmail(this.answered)
+        // TODO: Consider waiting until email hash is verified...(i.e. not in created)
+        signupUser(this.answered)
     },
     methods: {
         // TODO: remove test button above and use a watcher instead to emit this

frontend/src/router/index.js

 import LoginView from '../views/LoginView.vue'
 import SurveyView from '../views/SurveyView.vue'
 import OnboardingView from '../views/OnboardingView.vue'
+import VerifyView from '../views/VerifyView.vue'
 import MessagesView from '../views/MessagesView.vue'
 
 const routes = [
         name: `SurveyView`,
         meta: { requiresAuth: true, requiresCompleteProfile: false },
     },
+    // TODO: remove after better implementation is found for verifying email
+    // hash
     {
-        path: `/onboarding`,
+        path: `/onboarding/:hash?`,
         component: OnboardingView,
         name: `OnboardingView`,
         meta: { requiresAuth: true, requiresCompleteProfile: false },
     },
+    {
+        path: `/verify/:email?`,
+        component: VerifyView,
+        name: `VerifyView`,
+        meta: { requiresAuth: true, requiresCompleteProfile: false },
+    },
     {
         path: `/login`,
         component: LoginView,

frontend/src/services/auth.service.js

 class Authenticator {
     constructor() {
         this.curentUser = null
-        this.authenticated = false
     }
     async sendAuthEmail(answered) {
         const emailWasSent = await db.post(`/user/sendemail/`, answered)
         console.log('emailwasSent :=>', emailWasSent)
     }
+    async verifyAuthEmail(hash) {
+        const isVerified = await db.get(`/user/verify/${hash}`)
+        return isVerified.hashesMatch
+    }
 }
 
 export { Authenticator }

frontend/src/utils/lang.js

 const allSteps = {
     usa: {
         email: 'email',
-        password: 'password',
         name: 'name',
+        password: 'password',
         seeking: 'seeking',
         aspect01: 'aspect-1',
         aspect02: 'aspect-2',

frontend/src/views/OnboardingView.vue

     )
         .answers(v-for='(value, key) in answered')
             span(v-if='key == "name" && value && currentStep == 2') Hi {{ value }}!
-        //- h3(v-if='currentStep == 1') Welcome to Siimee Onboarding! Let's get started!
         br
         .step(v-for='(step, i) in survey.steps')
             component(
                 :is='step.component'
                 :question='step'
+                :answered='answered'
                 :currentStep='currentStep'
                 :surveyStepsCount='survey.steps.length'
                 @handle-submit='onSubmit'
                 @update-answers='updateAnswers'
+                @resume-survey='resumeSurvey'
                 v-if='step && currentStep == i'
             ) 
         .invalidResponseMessage(
 </template>
 
 <script>
+import { Authenticator } from '../services/auth.service.js'
 import { surveyFactory } from '@/utils'
 import stepViews from '@/components/onboarding'
+import VerifyView from './VerifyView.vue'
 import SurveyCompleteView from './SurveyCompleteView.vue'
 
 // import savesurveybyprofileid - call it on submit
         survey: null,
         currentProfileId: null,
         invalidResponse: false,
+        // TODO: CURRENTLY WORKING ON**
+        isAuthenticated: false,
+        authenticator: {},
     }),
     async created() {
         this.survey = await surveyFactory.createSurvey()
-        console.log('this.survey :=>', this.survey)
+        this.authenticator = new Authenticator()
+        // TODO: Replace with better implementation, hacky workaround for now...
+        if (this.$route.params.hash) {
+            const hashEmail = this.$route.params.hash
+            const hashesMatch = this.authenticator.verifyAuthEmail(hashEmail)
+            if (hashesMatch) {
+                this.currentStep = 4
+            } else {
+                console.log('nope, not at all :=>')
+            }
+        }
     },
     methods: {
         onSubmit() {
         goToStep(num) {
             this.currentStep = num
         },
+        resumeSurvey() {
+            this.goToStep(4)
+        },
         async updateAnswers(payload) {
             // null payload is passed on splash page
             if (payload) {
-                // authentication achieved if payload.resume = true
-                if (payload.resume) this.currentStep = 3
-                this.invalidResponse = false
+                // this.invalidResponse = false
                 const k = payload.question.survey_stage
                 this.answered[k] = payload.input
 

frontend/src/views/VerifyView.vue

+<template lang="pug">
+.wait-message
+    p.verify-message Thanks for authenticating your email {{ name }}!
+    p.verify-message Please give us a moment to redirect you back to the survey
+</template>
+
+<script>
+import { Authenticator } from '../services/auth.service.js'
+export default {
+    name: 'VerifyView',
+    emits: ['resume-survey'],
+    data: () => ({
+        authenticator: {},
+    }),
+    created() {
+        this.authenticator = new Authenticator()
+        const hashEmail = this.$route.params.email
+        const hashesMatch = this.authenticator.verifyAuthEmail(hashEmail)
+        if (hashesMatch) {
+            // this.$router.push(`/onboarding/${hashEmail}`)
+            this.$emit('resume-survey')
+        }
+        // else {
+        // render ERROR message above or redirect to 404 (or both?)
+        // }
+    },
+}
+</script>
+
+<style>
+.wait-message {
+    margin: 5rem auto;
+    text-align: center;
+    width: 90%;
+    max-width: 35rem;
+    font-size: 150%;
+    font-weight: bold;
+}
+</style>