:gear: more tweaking mock data for onboarding | filtering out profile 45 for testing onboarding | adjusting services to error handle better

backend/db/data-generator/config.json

     "mockOutputPath": "./db/generated",
     "magic": 1000,
     "total": 100,
+    "ignore": [45],
     "batchSize": 10,
     "percentageOfSeekers": 90,
     "scoreVals": [1, 2, 3, 4, 5, 6, 7],

backend/db/data-generator/mock.js

     ],
     messages: [],
     match_queues: [
-        { match_queue_id: 1, profile_id: 45, target_id: 62, is_deleted: false },
-        { match_queue_id: 2, profile_id: 62, target_id: 45, is_deleted: false },
+        { match_queue_id: 1, profile_id: 47, target_id: 62, is_deleted: false },
+        { match_queue_id: 2, profile_id: 62, target_id: 47, is_deleted: false },
         { match_queue_id: 3, profile_id: 62, target_id: 46, is_deleted: false },
         { match_queue_id: 4, profile_id: 46, target_id: 62, is_deleted: false },
-        { match_queue_id: 5, profile_id: 45, target_id: 46, is_deleted: false },
-        { match_queue_id: 6, profile_id: 46, target_id: 45, is_deleted: false },
+        { match_queue_id: 5, profile_id: 47, target_id: 46, is_deleted: false },
+        { match_queue_id: 6, profile_id: 46, target_id: 48, is_deleted: false },
         { match_queue_id: 7, profile_id: 46, target_id: 44, is_deleted: false },
         { match_queue_id: 8, profile_id: 46, target_id: 43, is_deleted: false },
         { match_queue_id: 9, profile_id: 46, target_id: 42, is_deleted: false },

backend/db/dataSort.js

-const dataSort = (table, id) => { return table.sort((a,b) => {return a[`${id}`] < b[`${id}`]})}
+const dataSort = (table, id) => table.sort((a, b) => a[`${id}`] < b[`${id}`])
 
-module.exports = dataSort
+module.exports = dataSort

backend/db/seeds/02-profiles.js

 const mock = require('../data-generator/mock')
 const fs = require('fs')
-const dataSort = require ('../dataSort')
-const { batchSize } = require('../data-generator/config.json')
-
+const dataSort = require('../dataSort')
+const { batchSize, ignore } = require('../data-generator/config.json')
 
 let profiles = []
 const generatedDataPath = './db/generated'
 let fileNames = fs.readdirSync(generatedDataPath)
 for (let name of fileNames) {
     const data = require(`../generated/${name}`)
-    if(name[0] == '_') {
+    if (name[0] == '_') {
         profiles = [...profiles, ...data.profiles]
     }
 }
-// sort data
-profiles = dataSort(profiles, 'profile_id')
 
+profiles = dataSort(profiles, 'profile_id').filter(
+    profile => !ignore.includes(profile.profile_id),
+)
 
 exports.seed = async knex => {
     await knex('profiles').del()

backend/db/seeds/04-responses.js

 const mock = require('../data-generator/mock')
 const fs = require('fs')
-const dataSort = require ('../dataSort')
-const { batchSize } = require('../data-generator/config.json')
+const dataSort = require('../dataSort')
+const { batchSize, ignore } = require('../data-generator/config.json')
 
 let responses = []
 const generatedDataPath = './db/generated'
 let fileNames = fs.readdirSync(generatedDataPath)
 for (let name of fileNames) {
     const data = require(`../generated/${name}`)
-    if(name[0] == '_') {
+    if (name[0] == '_') {
         responses = [...responses, ...data.responses]
     }
 }
 
-// sort data
-responses = dataSort(responses, 'response_id')
+/**
+ * Prevent seeding responses for
+ * profile ids so we can test oboarding
+ */
+responses = dataSort(responses, 'response_id').filter(
+    response => !ignore.includes(response.profile_id),
+)
 
 exports.seed = async knex => {
     await knex('responses').del()
     for (let i = 1; i <= len; i += 1) {
         responsesToPush.push(responses.shift())
         if (i % batchSize === 0 || i > responses.length) {
-            // await knex('responses').insert(responsesToPush)
+            await knex('responses').insert(responsesToPush)
             responsesToPush = []
         }
     }

frontend/src/App.vue

 import { surveyFactory } from './utils'
 
 const DEV_MODE = import.meta.env.VITE_DEV == 'true'
-const DEV_PID = 45
+const DEV_PID = 46
 
 export default {
     components: { TopNav, SideBar },

frontend/src/components/NamePlate.vue

 <template lang="pug">
 .name-plate.xs12.w-flex.justify-center
-    section(v-if="pid" :class="{ box: !isList }")
-        router-link(:to="`/profile/${pid}`" disabled)
+    section(:class='{ box: !isList }' v-if='pid')
+        router-link(:to='`/profile/${pid}`' disabled)
             h1.text-capitalize {{ name }}
                 span O
-            p.text-capitalize {{role}}&nbsp;
-                span.text-capitalize(v-if="isList")
-                    span.text-capitalize Registered Nurse | Los Angeles, CA.
-            p.text-capitalize(v-if="!isList") {{ pronouns }}&nbsp;
-                span.text-capitalize | ethnicity
+            p.text-capitalize {{ role }}&nbsp;
+                span.text-capitalize(v-if='isList')
+                    span.text-capitalize | {{ locale }}
+            p.text-capitalize(v-if='!isList') {{ pronouns }}
 </template>
 
 <script>
             type: String,
             required: true,
         },
+        role: {
+            type: String,
+            required: true,
+        },
+        locale: {
+            type: String,
+            required: true,
+        },
         pronouns: {
             type: String,
             required: true,
             default: true,
         },
     },
-    data: () => ({}),
 }
 </script>
 <style lang="sass">

frontend/src/components/ProfileCard.vue

 w-card.profile-card-list--card.xs12
     header.xs12.w-flex.column.center
         NamePlate(
+            :ethnicity='card.ethnicity'
             :is-list='isList'
             :is-paired='isPaired'
+            :locale='card.locale'
             :name='card.name'
             :pid='card.pid'
             :pronouns='card.pronouns'

frontend/src/components/ProfileCardList.vue

 
 <script setup>
 import { ref } from 'vue'
-import { useRouter } from 'vue-router'
-import {
-    updateQueueByProfileId,
-    postMembershipByProfileId,
-    currentProfile,
-} from '../services'
+import { currentProfile } from '../services'
+import { cardAspects } from '../entities'
 import ProfileCard from './ProfileCard.vue'
 
-class Aspect {
-    constructor({ name, labels, percentage = 50 }) {
-        this.name = name
-        this.labels = labels
-        this.percentage = percentage
-    }
-}
-const aspects = ref([
-    new Aspect({ name: 'creativity', labels: ['creative', 'methodical'] }),
-    new Aspect({ name: 'dynamism', labels: ['dynamic', 'ordered'] }),
-    new Aspect({ name: 'precision', labels: ['precise', 'resourceful'] }),
-    new Aspect({ name: 'vision', labels: ['visionary', 'implementer'] }),
-    new Aspect({ name: 'focus', labels: ['big picture', 'focused'] }),
-    new Aspect({ name: 'attention', labels: ['guided', 'self-managed'] }),
-])
-
-const router = useRouter()
-const emit = defineEmits(['reload'])
+const aspects = ref(cardAspects)
 
 const props = defineProps({
     cards: {
                 name: 'Full Name',
                 avatar: 'https://hips.hearstapps.com/hmg-prod.s3.amazonaws.com/images/newborn-baby-boy-sleeping-peacefully-wearing-knit-royalty-free-image-1589459736.jpg?crop=0.669xw:1.00xh;0.228xw,0&resize=640:*',
                 metadata: { age: '21', rawMetadata: 'Some Text Here!' },
+                role: 'more filler',
+                ethnicity: 'some background',
             },
         ],
     },
-    isGrid: {
-        type: Boolean,
-    },
 })
 
 /**

frontend/src/entities/card/card.js

     'Hello! My name is L.L. and I am a nurse from New York. I have been in the healthcare industry for over 6 years.'
 
 class SummaryGroup {
-    constructor () {
+    constructor() {
         this.about = {
             tab: null,
             matchPerc: null,
 }
 
 class Aspect {
-    constructor ({ name, labels, percentage = 50 }) {
+    constructor({ name, labels, percentage = 50 }) {
         this.name = name
         this.labels = labels
         this.percentage = percentage
     }
 }
+const cardAspects = [
+    new Aspect({
+        name: 'creativity',
+        labels: ['creative', 'methodical'],
+    }),
+    new Aspect({
+        name: 'dynamism',
+        labels: ['dynamic', 'ordered'],
+    }),
+    new Aspect({
+        name: 'precision',
+        labels: ['precise', 'resourceful'],
+    }),
+    new Aspect({
+        name: 'vision',
+        labels: ['visionary', 'implementer'],
+    }),
+    new Aspect({
+        name: 'focus',
+        labels: ['big picture', 'focused'],
+    }),
+    new Aspect({
+        name: 'attention',
+        labels: ['guided', 'self-managed'],
+    }),
+]
 
 /**
  * Class representing a profile card
  * card facade
  */
 class Card {
-    constructor ({ pid, name, role }) {
+    constructor({ pid, name, email, role }) {
         this.pid = pid
 
         /**  Fields */
         this.name = name
 
-        this.role = role ? role : null
+        this.role = role ? role : 'registered nurse'
 
         this.presence = null
         this.urgency = null
         this.pronouns = 'she/her/hers'
-        this.ethinicity = null
-        this.locale = null
-        this.email = null
+        this.ethinicity = 'something'
+        this.locale = 'los angeles ca'
+        this.email = email
 
         this.images = []
         this.tags = []
 
         this.summary = new SummaryGroup()
 
-        this.aspects = [
-            new Aspect({
-                name: 'creativity',
-                labels: ['creative', 'methodical'],
-            }),
-            new Aspect({
-                name: 'dynamism',
-                labels: ['dynamic', 'ordered'],
-            }),
-            new Aspect({
-                name: 'precision',
-                labels: ['precise', 'resourceful'],
-            }),
-            new Aspect({
-                name: 'vision',
-                labels: ['visionary', 'implementer'],
-            }),
-            new Aspect({
-                name: 'focus',
-                labels: ['big picture', 'focused'],
-            }),
-            new Aspect({
-                name: 'attention',
-                labels: ['guided', 'self-managed'],
-            }),
-        ]
+        this.aspects = cardAspects
 
         return this
     }
     const c = new Card({
         pid: profile.profile_id,
         name: profile.user_name,
+        email: profile.user_email,
         role: profile?.profile_prefs?.role?.val,
     })
 
     }
     return c
 }
-export { Card, makeCardFromProfile }
+export { Card, makeCardFromProfile, cardAspects }

frontend/src/entities/profile/profile.js

          * TODO: Send validate.error to logging error handler
          */
         if (validate.error) {
-            console.error(`error: ${validate.error} - ${this.type} validation`)
+            console.error(`[Profile Entitiy error]: ${validate.error}`)
         }
 
         /** validate(this) always returns something so force it to a bool */

frontend/src/router/index.js

         path: `/settings`,
         component: HomeView,
         name: `SettingsView`,
-        meta: { requiresAuth: false, requiresCompleteProfile: false },
+        meta: { requiresAuth: true, requiresCompleteProfile: true },
     },
     {
         path: `/search`,
         component: HomeView,
         name: `SearchView`,
-        meta: { requiresAuth: false, requiresCompleteProfile: false },
+        meta: { requiresAuth: true, requiresCompleteProfile: true },
     },
 ]
 

frontend/src/services/login.service.js

     updateQueueByProfileId,
     fetchMembershipsByProfileId,
     fetchResponsesByProfileId,
+    fetchProfileByProfileId,
     Chatter,
     StonkAlert,
 } from '../services/index.js'
     constructor() {
         this._loading = ref(true)
 
+        // Profile entity instance for self
+        this._profile = null
         // Make reactive with vue observer
         this.id = ref(null)
 
      */
     async login(profileId, cb) {
         this._loading.value = true
-
+        // First check if profile exists
         console.warn('[Login Service warn]: Logging in:', profileId)
-        this.id.value = parseInt(profileId)
 
+        // TODO: You can probably use this call to get responses, groupings and tags
+        this._profile = await fetchProfileByProfileId(profileId)
+        this.id.value = this._profile.profile_id
+
+        if (!this.id.value) {
+            console.error(
+                `[Login Service error]: No profile found for profile_id: ${profileId}`,
+            )
+        }
+
+        // Then grab groupings and queue for display
         await this.getGroupings()
         await this.getQueue()
 
-        await this.setupChatter()
+        // Then hook into chat services
+        try {
+            await this.setupChatter()
+            console.warn(
+                `[Login Service warn]: ${profileId} subscribed to:`,
+                this.chatter.subscriptions,
+            )
+        } catch (err) {
+            console.error(err)
+        }
+        // Finally setup notifications and sse handling
         this.setupToaster(cb)
-
-        this._loading.value = false
         console.warn('[Login Service warn]: Login SUCCESSFUL')
-        console.warn(
-            `[Login Service warn]: ${profileId} subscribed to:`,
-            this.chatter.subscriptions,
-        )
+        this._loading.value = false
         return this.id.value
     }
     logout() {

frontend/src/services/profile.service.js

 }
 
 const fetchProfileByProfileId = async profileId => {
-    const profile = await db.get(`/profile/${profileId}`)
+    let profile
+    try {
+        const profileData = await db.get(`/profile/${profileId}`)
+        profile = new Profile(profileData)
+        if (!profile.isValid()) {
+            throw '[Profile Service error]: Invalid or incomplete profile returned.'
+        }
+    } catch (err) {
+        console.error(err)
+    }
     return profile
 }