:sparkles: Implemented login

backend/lib/plugins/user.js

 const UserVerifyActiveRoute = require('../routes/user/verifyactivesession.js')
 const UserGetAccessRoute = require('../routes/user/getaccess.js')
 const UserValidateSessionRoute = require('../routes/user/validatesession.js')
+const UserRemoveSessionRoute = require('../routes/user/removesession.js')
 const UserPassword = require('../routes/user/authentication')
 
 const UserService = require('../services/user')
         await server.route(UserVerifyActiveRoute)
         await server.route(UserGetAccessRoute)
         await server.route(UserValidateSessionRoute)
+        await server.route(UserRemoveSessionRoute)
         await server.route(UserPassword)
     },
 }

backend/lib/routes/user/login.js

             user_email: Joi.string(),
             password: Joi.string(),
         }),
-        
     },
     user: userSchema.single,
     error: errorSchema.single,
         auth: false,
         handler: async function (request, h) {
             try {
-                const { userService } = request.services()
+                const { userService, profileService } =
+                    request.server.services()
 
                 const res = request.payload
 
 
                 // Bound context from your plugin server declaration
                 const user = await h.context.transaction(login)
-                const token = userService.createToken(user)
+                const rawUser = await userService.findByUserEmail(
+                    res.user_email,
+                )
+                // Uses Same Logic Behind Initial Sign Up,
+                // passing expected credentials to be used for logging in
+                const userCredentials = {
+                    email: rawUser.user_email,
+                    name: rawUser.user_name,
+                    seeking: rawUser.is_poster === 1 ? 'poster' : 'seeker',
+                }
+                const token = userService.createToken({
+                    payload: userCredentials,
+                })
 
                 return {
                     ok: true,
                     handler: pluginConfig.handlerType,
-                    data: { user_email: user.user_email, jwtToken: token },
+                    data: {
+                        user_email: user.user_email,
+                        jwt: token,
+                        answered: {
+                            email: userCredentials.email,
+                            name: userCredentials.name,
+                            seeking: userCredentials.seeking,
+                        },
+                    },
                 }
             } catch (err) {
                 console.error(err)
                     handler: Joi.string(),
                     data: Joi.object({
                         user_email: Joi.string(),
-                        jwtToken: Joi.string(),
+                        jwt: Joi.string(),
+                        answered: Joi.object({
+                            email: Joi.string(),
+                            name: Joi.string(),
+                            seeking: Joi.string(),
+                        }),
                     }),
                 }).label('login_res'),
                 409: Joi.object({

backend/lib/routes/user/verifyactivesession.js

                 if (!hashToMatch) {
                     throw new Error('no record of email in cache')
                 }
+                userService.activeSessions[
+                    hashToMatch
+                ].emailWasRespondedTo = true
                 return {
                     ok: true,
                     handler: pluginConfig.handlerType,

backend/lib/services/user.js

 
 const apiInstance = new SibApiV3Sdk.TransactionalEmailsApi()
 
-const hashToken = async token => {
-    const salt = process.env.APP_SESSION_SALT
-    try {
-        return crypto.createHmac('sha256', salt).update(token).digest('hex')
-    } catch (err) {
-        throw new Error(err.message)
-    }
-}
-
 const hasher = async (pwd, steak) => {
     const hash = await pwd.hash(steak)
     const result = await pwd.verify(steak, hash)
         return user
     }
 
+    async hashToken(token) {
+        const salt = process.env.APP_SESSION_SALT
+        try {
+            return crypto.createHmac('sha256', salt).update(token).digest('hex')
+        } catch (err) {
+            throw new Error(err.message)
+        }
+    }
+
     /**
      * Signup function
      * @param {*} param0
             .throwIfNotFound()
             .first()
             .where({ user_email: email })
-
         const bufferPepper = Buffer.from(process.env.PEPPER + password)
 
         /** Uncomment to run password check using SecurePassword */
                 'hashedSessionToken not in activeSessions registry!',
             )
         }
+        if (!userSession.emailWasRespondedTo) {
+            throw new Error('email was never responded to!')
+        }
         const accessToken = userSession.accessToken
         const accessTokenIsValid = this.validateToken(accessToken)
         return {
             accessToken: this.activeSessions[hashedAccessToken].accessToken,
         }
     }
+    removeSession(hashedAccessToken) {
+        const userSession = this.activeSessions[hashedAccessToken]
+        if (!userSession) {
+            throw new Error(
+                'hashedSessionToken not in activeSessions registry!',
+            )
+        } else {
+            delete this.activeSessions[hashedAccessToken]
+        }
+    }
     /**
      * Use knex to try to change password entry
      * @param {number} id
         const passwordRow = await Auth.query(txn)
             .where('user_email', email)
             .first()
-
         return passwordRow ? passwordRow.token : null
     }
 
      * @ returns {Object}
      */
     async emailSent(userCredentials) {
-        const hashedAccessToken = await hashToken(userCredentials.accessToken)
+        const hashedAccessToken = await this.hashToken(
+            userCredentials.accessToken,
+        )
         if (Object.keys(this.activeSessions).includes(hashedAccessToken)) {
             return new Error('session already in cache!!')
         }
             seeking: userCredentials.seeking,
             accessToken: userCredentials.accessToken,
             expiration: Date.now() + duration,
+            emailWasRespondedTo: false,
             sessionToken: null,
         }
 

frontend/src/App.vue

 import SideBar from './components/SideBar.vue'
 import TopNav from './components/TopNav.vue'
 
-import { currentProfile } from './services'
+import { currentProfile, authenticator } from './services'
 import { surveyFactory } from './utils'
 
 const DEV_MODE = import.meta.env.VITE_DEV == 'true'

frontend/src/services/auth.service.js

     async validateSession(hashedAccessToken) {
         return await db.post('/user/validatesession', hashedAccessToken, true)
     }
+    async authenticateLoginCredentials(credentials) {
+        return await db.post('/user/login', credentials)
+    }
+    async removeSession(hashedAccessToken) {
+        return await db.post('/user/removesession', hashedAccessToken, true)
+    }
 }
 const authenticator = new Authenticator()
 

frontend/src/views/HomeView.vue

 
 import { Card } from '../entities'
 
-import { currentProfile, fetchQueueByProfileId } from '../services'
+import {
+    currentProfile,
+    authenticator,
+    fetchQueueByProfileId,
+} from '../services'
 import { mixins } from '../utils'
 
 const notificationOpts = {
             )
             this.fetchedCards.push(...newQueue) // update fetchedCards => recalculate cards
         },
+        grabStoredCookie(cookieKey) {
+            const cookies = document.cookie
+                .split('; ')
+                .reduce((prev, current) => {
+                    const [name, ...value] = current.split('=')
+                    prev[name] = value.join('=')
+                    return prev
+                }, {})
+            const cookieVal =
+                cookieKey in cookies ? cookies[`${cookieKey}`] : undefined
+            return cookieVal
+        },
         async logout() {
             if (currentProfile.isLoggedIn) {
                 currentProfile.logout()
             }
-            document.cookie = `siimee_access=''; max-age=600; path=/; secure`
+            const hashedAccessToken = this.grabStoredCookie('siimee_access')
+            const removedSession = await authenticator.removeSession(
+                hashedAccessToken,
+            )
+            if (removedSession.error)
+                console.error('ERROR :=>', removedSession.error)
+            document.cookie = `siimee_access=''; max-age=0; path=/; secure`
             this.$router.push('/onboarding')
         },
         // this can be placed in utils/notification.js

frontend/src/views/LoginView.vue

 <template lang="pug">
 main.view--login
-
     article.pa12
-        form
-            w-input.mb4(label="User E-mail" tile outline v-model="form.profileId" inner-icon-left='icon-envelope')
-            w-input(label="Password" type="password" tile outline inner-icon-left='icon-eye')
-
-            //- Emit up an event so we can sync App pid with currentProfile.id
-            w-button.xs12.mt12(@click="$emit('updatePid', form.profileId)" type="submit") submit
+        div(v-if='emailSentSuccessfully === null')
+            form
+                w-input.mb4(label="User E-mail" tile outline v-model="form.email" inner-icon-left='icon-envelope')
+                w-input(label="Password" v-model="form.password" type="password" tile outline inner-icon-left='icon-eye')
+                w-button.xs12.mt12(@click="login") submit
+        div(v-else-if='emailSentSuccessfully === false')
+            p.verify-message Email Was Not Sent Successfully, please contact your Email Service Provider or Systems Administrator.
+        div(v-else)
+            p.verify-message Thanks for logging in!
+            p.verify-message We'll just need you to verify your email address to continue. Please check your email!
 </template>
 
 <script>
+import { authenticator } from '../services'
 export default {
     data: () => ({
         form: {
             profileId: null,
+            email: null,
+            password: null,
         },
+        emailSentSuccessfully: null,
     }),
+    methods: {
+        async login() {
+            const loginCredentials = {
+                user_email: this.form.email,
+                password: this.form.password,
+            }
+            const credentials =
+                await authenticator.authenticateLoginCredentials(
+                    loginCredentials,
+                )
+            // emailSentSuccessfully: emailSent.wasSuccessfull,
+            const sessionInfo = await authenticator.sendAuthEmail({
+                ...credentials.answered,
+                accessToken: credentials.jwt,
+            })
+            if (sessionInfo.emailSentSuccessfully) {
+                this.emailSentSuccessfully = true
+            }
+            document.cookie = `siimee_access=${sessionInfo.hashedAccessToken}; max-age=600; path=/; secure`
+        },
+    },
 }
 </script>
+
+<style>
+.verify-message {
+    display: flex;
+    justify-content: center;
+    text-align: center;
+    margin: 0 auto;
+    font-weight: 700;
+    font-size: 160%;
+}
+</style>