:recycle: moving profile creation and list to the user route | custom validation for http errors based on status code

backend/lib/plugins/profile.js

 
 const ProfileService = require('../services/profile')
 
-const ProfileProfilesRoute = require('../routes/profile/profiles')
 const ProfileScoreRoute = require('../routes/profile/score')
-const ProfileCreateRoute = require('../routes/profile/create')
 const ProfileUpdateRoute = require('../routes/profile/update')
 
 module.exports = {
         await server.register(Schmervice)
         server.registerService(ProfileService)
 
-        await server.route(ProfileProfilesRoute)
         await server.route(ProfileScoreRoute)
-        await server.route(ProfileCreateRoute)
         await server.route(ProfileUpdateRoute)
     },
 }

backend/lib/plugins/user.js

 const UserModel = require('../models/user')
 
 const UserCurrentRoute = require('../routes/user/current')
+const UserProfileCreateRoute = require('../routes/user/create-profile')
+const UserProfilesListRoute = require('../routes/user/list-profiles')
 const UserLoginRoute = require('../routes/user/login')
 
-const MembershipService = require('../services/membership')
 const UserService = require('../services/user')
 const DisplayService = require('../services/display')
 
 
         await server.route(UserCurrentRoute)
         await server.route(UserLoginRoute)
+        await server.route(UserProfileCreateRoute)
+        await server.route(UserProfilesListRoute)
     },
 }

backend/lib/routes/profile/create.js

-'use strict'
-
-const Joi = require('joi')
-
-const pluginConfig = {
-    handlerType: 'profile',
-    docs: {
-        description: 'Create profile',
-        notes: 'Create a profile associated with this user',
-    },
-}
-
-const validators = {
-    /** Validate the header (cookie check) */
-    // headers: true,
-
-    /** Validate the route params (/active/{thing}) */
-    params: Joi.object({ user_id: Joi.number() }),
-
-    /** Validate the route query (/active/{thing}?limit=10&offset=10) */
-    // query: true,
-    /** Validate the incoming payload (POST method) */
-    payload: Joi.array().items(
-        Joi.object({
-            response_key_id: Joi.number().required(),
-            val: Joi.string().required(),
-        }),
-    ),
-}
-
-const responseSchemas = {
-    response: Joi.object({
-        profile_id: Joi.number(),
-        user_id: Joi.number(),
-    }),
-}
-
-module.exports = {
-    method: 'POST',
-    path: '/{user_id}/create',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        /** Protect this route with authentication? */
-        auth: false,
-
-        handler: async function (request) {
-            const { profileService } = request.services()
-            const userId = request.params.user_id
-
-            /** Grab payload info */
-            const res = request.payload
-
-            const profile = await profileService.saveResponsesCreateProfileFor(
-                userId,
-                res,
-            )
-            try {
-                return {
-                    ok: true,
-                    handler: pluginConfig.handlerType,
-                    data: profile,
-                }
-            } catch (err) {
-                return {
-                    ok: false,
-                    handler: pluginConfig.handlerType,
-                    data: { error: `${err}` },
-                }
-            }
-        },
-
-        /** Validate based on validators object */
-        validate: {
-            ...validators,
-            failAction: 'log',
-        },
-
-        /** Validate the server response */
-        response: {
-            schema: Joi.object({
-                ok: Joi.bool(),
-                handler: Joi.string(),
-                data: responseSchemas.response,
-            }),
-        },
-    },
-}

backend/lib/routes/profile/score.js

 
     /** Validate the route params (/active/{thing}) */
     params: Joi.object({
-        user_id: Joi.number(),
+        profile_id: Joi.number(),
     }),
 
     /** Validate the route query (/active/{thing}?limit=10&offset=10) */
 
 module.exports = {
     method: 'GET',
-    path: '/score/{user_id}',
+    path: '/{profile_id}/score',
     options: {
         ...pluginConfig.docs,
         tags: ['api'],
 
         handler: async function (request, h) {
             const { profileService } = request.services()
-            const userId = request.params.user_id
-            const profiles = await profileService.scoreProfilesFor(userId)
+            const profileId = request.params.profile_id
+            const profiles = await profileService.scoreProfilesFor(profileId)
+
             try {
                 return {
                     ok: true,

backend/lib/routes/user/create-profile.js

+'use strict'
+
+const Joi = require('joi')
+
+const pluginConfig = {
+    handlerType: 'user',
+    docs: {
+        description: 'Create profile for user',
+        notes: 'Create a profile associated with this user',
+    },
+}
+
+const validators = {
+    /** Validate the header (cookie check) */
+    // headers: true,
+
+    /** Validate the route params (/active/{thing}) */
+    params: Joi.object({ user_id: Joi.number() }),
+
+    /** Validate the route query (/active/{thing}?limit=10&offset=10) */
+    // query: true,
+    /** Validate the incoming payload (POST method) */
+    payload: Joi.array().items(
+        Joi.object({
+            response_key_id: Joi.number().required(),
+            val: Joi.string().required(),
+        }),
+    ),
+}
+
+const responseSchemas = {
+    response: Joi.object({
+        profile_id: Joi.number(),
+        user_id: Joi.number(),
+    }),
+    error: Joi.object({
+        error: Joi.string(),
+    }),
+}
+
+module.exports = {
+    method: 'POST',
+    path: '/{user_id}/profile',
+    options: {
+        ...pluginConfig.docs,
+        tags: ['api'],
+        /** Protect this route with authentication? */
+        auth: false,
+
+        handler: async function (request, h) {
+            const { userService, profileService } = request.server.services()
+            const userId = request.params.user_id
+            const user = await userService.findById(userId)
+            const type = user.is_poster == 1 ? 'poster' : 'seeker'
+
+            const profiles = await profileService.getCompleteProfilesFor(
+                userId,
+                type,
+            )
+
+            try {
+                if (type === 'seeker' && profiles.length > 0) {
+                    throw new RangeError(
+                        'Job seekers may only have ONE profile',
+                    )
+                }
+                /** Grab payload info */
+                const res = request.payload
+                const profile =
+                    await profileService.saveResponsesCreateProfileFor(
+                        userId,
+                        res,
+                    )
+                return h
+                    .response({
+                        ok: true,
+                        handler: pluginConfig.handlerType,
+                        data: profile,
+                    })
+                    .code(201)
+            } catch (err) {
+                return h
+                    .response({
+                        ok: false,
+                        handler: pluginConfig.handlerType,
+                        data: { error: `${err}` },
+                    })
+                    .code(500)
+            }
+        },
+
+        /** Validate based on validators object */
+        validate: {
+            ...validators,
+            failAction: 'log',
+        },
+
+        /** Validate the server response */
+        response: {
+            status: {
+                201: Joi.object({
+                    ok: Joi.bool(),
+                    handler: Joi.string(),
+                    data: responseSchemas.response,
+                }),
+                500: Joi.object({
+                    ok: Joi.bool(),
+                    handler: Joi.string(),
+                    data: responseSchemas.error,
+                }),
+            },
+        },
+    },
+}

backend/lib/routes/profile/profiles.js → backend/lib/routes/user/list-profiles.js

 const Joi = require('joi')
 
 const pluginConfig = {
-    handlerType: 'profile',
+    handlerType: 'user',
     docs: {
         description: 'profiles',
         notes: 'A list of profiles associated with this user',
 
     /** Validate the route params (/active/{thing}) */
     params: Joi.object({
-        user_type: Joi.string(),
         user_id: Joi.number(),
     }),
 
         ),
         user_type: Joi.string().required(),
     }),
+    error: Joi.object({
+        error: Joi.string(),
+    }),
 }
 
 module.exports = {
     method: 'GET',
-    path: '/{user_type}/{user_id}',
+    path: '/{user_id}/profiles',
     options: {
         ...pluginConfig.docs,
         tags: ['api'],
         auth: false,
 
         handler: async function (request, h) {
-            const { profileService } = request.services()
+            const { userService, profileService } = request.server.services()
             const userId = request.params.user_id
-            const type = request.params.user_type
+            const user = await userService.findById(userId)
+            const type = user.is_poster == 1 ? 'poster' : 'seeker'
             const profiles = await profileService.getCompleteProfilesFor(
                 userId,
                 type,
 
         /** Validate the server response */
         response: {
-            schema: Joi.object({
-                ok: Joi.bool(),
-                handler: Joi.string(),
-                data: Joi.array().items(responseSchemas.profilesList),
-            }),
+            status: {
+                200: Joi.object({
+                    ok: Joi.bool(),
+                    handler: Joi.string(),
+                    data: Joi.array().items(responseSchemas.profilesList),
+                }),
+                500: Joi.object({
+                    ok: Joi.bool(),
+                    handler: Joi.string(),
+                    data: responseSchemas.error,
+                }),
+            },
         },
     },
 }

backend/lib/services/match-maker.js

         const seekerResponseValues = seeker.profileResponses.map(res =>
             parseInt(Object.values(res)),
         )
+        console.log(seeker)
         const potentialMatchResponseValues =
             potentialMatch.profileResponses.map(res =>
                 parseInt(Object.values(res)),
     }
     scoreProfiles(profiles) {
         const matchScores = []
-        for (const profile in this.profiles) {
+        for (const profile in profiles) {
             const scored = this.keeper.score(profile)
             matchScores.push(scored)
         }

backend/lib/services/profile.js

         }
 
     const checkValCb = res => {
-        const val = parseInt(Object.values(res))
+        const val = parseInt(res.val)
         return isNaN(val) ? 0 : val
     }
+
     return Math.floor(
         cosineSimilarity(
             seeker.responses.map(checkValCb),
 
     /**
      * Score a profile
-     * @param {number} userId
+     * @param {number} profileId
      * @returns {Array} Ordered and scored Profiles
      */
-    async scoreProfilesFor(userId) {
+    async scoreProfilesFor(profileId) {
         const { Profile } = this.server.models()
 
         // Our User Profile to score for
         const userProfile = await Profile.query()
-            .findOne('user_id', userId)
+            .findOne('profile_id', profileId)
             .withGraphFetched('responses')
             .withGraphFetched('user')
 

backend/lib/services/user.js

      */
     async findById(id, txn) {
         const { User } = this.server.models()
-        return await User.query(txn).throwIfNotFound().findById(id)
+        return await User.query(txn)
+            .throwIfNotFound()
+            .first()
+            .where({ user_id: id })
     }
 
     /**
         return await User.query(txn)
             .throwIfNotFound()
             .first()
-            .where({ username })
+            .where({ user_name: username })
     }
 
     /**