:bug: fixed merge conflicts

backend/lib/index.js

 const SurveyPlugin = require('./plugins/survey')
 const ProfilePlugin = require('./plugins/profile')
 const NotificationPlugin = require('./plugins/notification')
+const HealthPlugin = require('./plugins/health')
 
 /**
  * A Hapi server instance
         await server.register(NotificationPlugin, {
             routes: { prefix: '/notification' },
         })
+
+        await server.register(HealthPlugin, {
+            routes: { prefix: '/health' },
+        })
     },
 }

backend/lib/plugins/health.js

+const HealthRoute = require('../routes/health/get')
+
+module.exports = {
+    name: 'health-plugin',
+    version: '1.0.0',
+    register: async (server, options) => {
+        await server.route(HealthRoute)
+    },
+}

backend/lib/plugins/user.js

 
 const UserService = require('../services/user')
 const DisplayService = require('../services/display')
+const HealthService = require('../services/health')
 
 module.exports = {
     name: 'user-plugin',
         await server.register(Schmervice)
         server.registerService(UserService)
         server.registerService(DisplayService)
+        server.registerService(HealthService)
 
         await server.route(UserCurrentRoute)
         await server.route(UserLoginRoute)

backend/lib/routes/health/get.js

+'use strict'
+
+const apiSchema = require('../../schemas/api')
+const errorSchema = require('../../schemas/errors')
+const healthSchema = require('../../schemas/health')
+
+const pluginConfig = {
+    handlerType: 'health',
+    docs: {
+        description: 'Get server stats',
+        notes: 'Returns stats on server status'
+    }
+}
+
+const validators = {}
+
+const responseSchemas = {
+    health: healthSchema.stats,
+    error: errorSchema.single
+}
+
+module.exports = {
+    method: 'GET',
+    path: '/',
+    options:{
+        ...pluginConfig.docs,
+        tags: ['api'],
+        auth: false,
+        cors: true,
+        handler: async function (request, h) {
+            const { healthService } = request.server.services()
+            const stats = await healthService.getStats()
+            try {
+                return h.response(({
+                    ok:true,
+                    handler: pluginConfig.handlerType,
+                    data: stats
+                })).code(200)
+            } catch (err) {
+                return h
+                    .response({
+                        ok: false,
+                        handler: pluginConfig.handlerType,
+                        data: {error: `${err}`}
+                    })
+                    .code(409)
+            }
+        },
+        validate: {
+            ...validators,
+            failAction: 'log'
+        },
+
+        response: {
+            status: {
+                200: apiSchema.single
+                    .append({
+                        data: responseSchemas.health,
+                    })
+                    .label('api_single_res'),
+                409: apiSchema.single
+                    .append({
+                        data: responseSchemas.error,
+                    })
+                    .label('error_single_res'),
+            },
+        },
+    },
+}

backend/lib/routes/notification/index.js

                 name: 'BDGRS',
                 price: (500 + Math.floor(Math.random() * 100)).toString(),
                 order: null,
+                type: 'info',
             }
 
             // Write to the input stream

backend/lib/schemas/health.js

+'use strict'
+
+const Joi = require('Joi')
+
+const stats = Joi.object({
+    date: Joi.string().required(),
+    users: Joi.number().required(),
+}).label('stats')
+
+module.exports = { stats }

backend/lib/services/health.js

+const Schmervice = require('@hapipal/schmervice')
+
+module.exports = class HealthService extends Schmervice.Service {
+    constructor(...args){
+        super(...args)
+    }
+
+    /**
+     * Returns date and number of users
+     * @returns {object}
+     */
+    async getStats(){
+        const { User } = this.server.models()
+        const users = await User.query()
+        const date = new Date()
+        return { date: date.toString(), users: users.length }
+    }
+}

backend/server/manifest.js

 const Dotenv = require('dotenv').config({path: './server/.env'})
-// const Dotenv = require('dotenv')
 const Confidence = require('@hapipal/confidence')
 const Inert = require('@hapi/inert')
 const Vision = require('@hapi/vision')
 const Schwifty = require('@hapipal/schwifty')
 const HapiSwagger = require('hapi-swagger')
 
-/** Pull .env into process.env */
-// Dotenv.config({ path: `${__dirname}/../.env` })
-// Dotenv.config({ path: `${__dirname}/../.env` })
 
 /** Glue manifest as a confidence store */
 module.exports = new Confidence.Store({

frontend/src/App.vue

 import 'wave-ui/dist/wave-ui.css'
 import SideBar from './components/SideBar.vue'
 
-import { Chatter, currentProfile, StonkAlert } from './services'
+import { currentProfile } from './services'
 import { surveyFactory } from './utils'
 
 const DEV_MODE = import.meta.env.VITE_DEV == 'true'
         if (DEV_MODE) {
             this.setPid(DEV_PID)
         }
-
-        if (currentProfile.isLoggedIn) {
-            console.warn(`setting up Chatter and Toaster for ${this.getPid}...`)
-            this.setupChatter()
-            this.setupToaster()
-        }
-        console.log('---')
     },
     methods: {
         /**
          * Sync up this components state with
          * the currentProfile handler
          */
-        setPid(profileId) {
-            currentProfile.login(profileId)
-        },
+        async setPid(profileId) {
+            if (currentProfile.isLoggedIn) {
+                currentProfile.logout()
+            }
+            await currentProfile.login(profileId)
 
-        /**
-         * For push notifications and chat
-         */
-        setupToaster() {
-            const t = new StonkAlert(this.getPid)
-        },
-        setupChatter() {
-            const c = new Chatter()
-            const testAccountUUID = import.meta.env.VITE_TEST_ACCOUNT_UUID
-            c.setup(testAccountUUID)
+            if (currentProfile.isLoggedIn) {
+                console.warn(
+                    `setting up Chatter and Toaster for ${this.getPid}...`,
+                )
+                currentProfile.setupChatter()
+                currentProfile.setupToaster(this.$waveui.notify)
+            }
+            console.log('---')
         },
     },
 }

frontend/src/services/login.service.js

 import { ref } from 'vue'
-import { fetchResponsesByProfileId } from '../services'
+import { fetchResponsesByProfileId, Chatter, StonkAlert } from '../services'
 import { surveyFactory } from '../utils'
 
 /**
 class Login {
     constructor() {
         this._loading = false
-        
+
         // Make reactive with vue observer
         this.id = ref(null)
 
         this.responses = []
         this.tags = []
+
+        this.toaster = null
+        this.chatter = null
     }
     get isLoading() {
         return this._loading
     }
     /**
      * Combine questions retrieved from the database and
-     * questions defined in out lang file and 
+     * questions defined in out lang file and
      * copare to responses stored
      * @returns {boolean}
      */
     get isComplete() {
-        return this.responses.length == surveyFactory.questionsFromDb.length && surveyFactory.questionsFromDb.length > 0
+        return (
+            this.responses.length == surveyFactory.questionsFromDb.length &&
+            surveyFactory.questionsFromDb.length > 0
+        )
     }
     /**
      * Check that some responses are set
      */
     get hasResponses() {
         return this.responses.length && this.responses.length > 0
-    } 
+    }
 
     /**
      * Login a profile by id number
      * @param {number} profileId
      * @returns {number} stored reactive id
      */
-     async login(profileId) {
+    async login(profileId) {
         console.warn('logging in:', profileId)
         this.id.value = parseInt(profileId)
         return this.id.value
     }
-    logout() { this.id.value = null }
-    
+    logout() {
+        this.id.value = null
+        if (this.toaster) {
+            this.toaster.stop()
+        }
+        if (this.chatter) {
+            this.toaster.stop()
+        }
+    }
+
     async getTags() {
         try {
             const tags = []
             console.error(err)
         }
     }
-    setTags(tags) { this.tags = tags }
+    setTags(tags) {
+        this.tags = tags
+    }
 
     async getResponses() {
         try {
             console.error(err)
         }
     }
-    setResponses(responses) { this.responses = responses }
+    setResponses(responses) {
+        this.responses = responses
+    }
+    /**
+     * For push notifications and chat
+     */
+    setupToaster(waveCb) {
+        this.toaster = new StonkAlert(this.id.value, waveCb)
+    }
+    setupChatter() {
+        this.chatter = new Chatter()
+        const testAccountUUID = import.meta.env.VITE_TEST_ACCOUNT_UUID
+        this.chatter.setup(testAccountUUID)
+    }
 }
 
 const currentProfile = new Login()

frontend/src/services/notification.service.js

     listenFor(event, callback) {
         this.source.addEventListener(event, callback)
     }
+    stop() {
+        this.source.close()
+    }
 }
 
 /**
  * Example extension that listens for 'stonk' events
  */
 class StonkAlert extends Toaster {
-    constructor(profileId) {
+    constructor(profileId, waveCb) {
         super(profileId)
-
+        this.event = 'stonk'
         this.stonks = {}
-        this.listenFor(`${profileId}.stonk`, message => {
+        this.listenFor(`${profileId}.${this.event}`, message => {
             const parsed = JSON.parse(message.data)
             this.stonks[parsed.name] = parsed
-            console.log('updated:', this.stonks)
+            waveCb(this._formatToast(parsed), parsed.type)
         })
     }
+    _formatToast(parsed) {
+        return `${parsed.name}: ${parsed.profile_id} ${parsed.order} at ${parsed.price}`
+    }
 }
 
-export { Toaster, StonkAlert }
+export { Toaster, StonkAlert }