:sparkles: starting to create scoring service

backend/db/survey-generator.js

@@ -245,6 +245,7 @@ if (generatedSeekers.length == generatedProviders.length) {
     console.log(generatedProviders[0].matchPref.map(m => m.id))
 
     console.log('---')
+
     console.log('user:', generatedSeekers[0].id, '| seeker')
     console.log(
         'otp',

backend/lib/models/profile.js

@@ -1,10 +1,23 @@
 const Schwifty = require('@hapipal/schwifty')
 const Joi = require('joi')
+const Response = require('./response')
 
 module.exports = class Profile extends Schwifty.Model {
     static get tableName() {
         return 'profiles'
     }
+    static get relationMappings() {
+        return {
+            responses: {
+                relation: Schwifty.Model.HasManyRelation,
+                modelClass: Response,
+                join: {
+                    from: 'responses.profile_id',
+                    to: 'profiles.profile_id',
+                },
+            },
+        }
+    }
     static get joiSchema() {
         return Joi.object({
             profile_id: Joi.number(),

backend/lib/plugins/profile.js

@@ -7,6 +7,7 @@ const ResponseModel = require('../models/response')
 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')
 
@@ -27,6 +28,7 @@ module.exports = {
         server.registerService(ProfileService)
 
         await server.route(ProfileProfilesRoute)
+        await server.route(ProfileScoreRoute)
         await server.route(ProfileCreateRoute)
         await server.route(ProfileUpdateRoute)
     },

backend/lib/routes/profile/profiles.js

@@ -15,7 +15,10 @@ const validators = {
     // headers: true,
 
     /** Validate the route params (/active/{thing}) */
-    params: Joi.object({ user_id: Joi.number() }),
+    params: Joi.object({
+        user_type: Joi.string(),
+        user_id: Joi.number(),
+    }),
 
     /** Validate the route query (/active/{thing}?limit=10&offset=10) */
     // query: true,
@@ -25,23 +28,23 @@ const validators = {
 
 const responseSchemas = {
     profilesList: Joi.object({
-        profile_id: Joi.number().required(),
-        user_id: Joi.number().required(),
+        profile_id: Joi.number().integer().greater(0).required(),
+        user_id: Joi.number().integer().greater(0).required(),
         responses: Joi.array().items(
             Joi.object({
-                response_id: Joi.number().required(),
-                profile_id: Joi.number().required(),
                 response_key_id: Joi.number().required(),
+                profile_id: Joi.number().required(),
+                response_id: Joi.number().required(),
                 val: Joi.string().required(),
             }),
         ),
-        response_keys: Joi.array(),
+        user_type: Joi.string().required(),
     }),
 }
 
 module.exports = {
     method: 'GET',
-    path: '/{user_id}',
+    path: '/{user_type}/{user_id}',
     options: {
         ...pluginConfig.docs,
         tags: ['api'],
@@ -51,7 +54,11 @@ module.exports = {
         handler: async function (request, h) {
             const { profileService } = request.services()
             const userId = request.params.user_id
-            const profiles = await profileService.getCompleteProfilesFor(userId)
+            const type = request.params.user_type
+            const profiles = await profileService.getCompleteProfilesFor(
+                userId,
+                type,
+            )
             try {
                 return {
                     ok: true,

backend/lib/routes/profile/score.js

@@ -0,0 +1,73 @@
+'use strict'
+
+const Joi = require('joi')
+
+const pluginConfig = {
+    handlerType: 'score',
+    docs: {
+        description: 'scores',
+        notes: 'A list of profile scores',
+    },
+}
+
+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: true,
+}
+
+const responseSchemas = {}
+
+module.exports = {
+    method: 'GET',
+    path: '/score/{user_id}',
+    options: {
+        ...pluginConfig.docs,
+        tags: ['api'],
+        /** Protect this route with authentication? */
+        auth: false,
+
+        handler: async function (request, h) {
+            const { profileService } = request.services()
+            const userId = request.params.user_id
+            const profiles = await profileService.scoreProfilesFor(userId)
+            try {
+                return {
+                    ok: true,
+                    handler: pluginConfig.handlerType,
+                    data: profiles,
+                }
+            } 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: Joi.array().items(),
+            }),
+        },
+    },
+}

backend/lib/routes/survey/questions.js

@@ -24,8 +24,9 @@ const validators = {
 const responseSchemas = {
     responseKeysList: Joi.object({
         response_key_id: Joi.number().required(),
-        profile_id: Joi.number().required(),
-        val: Joi.string().required(),
+        response_key_category: Joi.string().required(),
+        response_key_prompt: Joi.string().required(),
+        response_key_description: Joi.any(),
     }),
 }
 

backend/lib/routes/survey/responses.js

@@ -24,7 +24,6 @@ const validators = {
 const responseSchemas = {
     responseKeysList: Joi.object({
         response_key_id: Joi.number().required(),
-        profile_id: Joi.number().required(),
     }),
 }
 

backend/lib/services/match-maker.js

@@ -1,8 +1,20 @@
-class ScoreKeeper {
-    constructor() {}
-    score(proposer) {
-        return { ...proposer }
-    }
+const similarity = require('compute-cosine-similarity')
+const magic = 1000
+
+const ScoreKeeper = {
+    score: (seeker, potentialMatch) => {
+        const seekerResponseValues = seeker.profileResponses.map(res =>
+            parseInt(Object.values(res)),
+        )
+        const potentialMatchResponseValues =
+            potentialMatch.profileResponses.map(res =>
+                parseInt(Object.values(res)),
+            )
+        return Math.floor(
+            similarity(seekerResponseValues, potentialMatchResponseValues) *
+                magic,
+        )
+    },
 }
 
 module.exports = class MatchMaker {
@@ -10,10 +22,7 @@ module.exports = class MatchMaker {
         this.proposer = settings.proposer
 
         // Score main profile
-        this.keeper = new ScoreKeeper()
-        this.proposer.score = this.keeper.score(this.proposer)
-
-        this.profiles = this.getProfilesFor(settings)
+        this.keeper = ScoreKeeper
     }
     runPrematch(settings) {
         // grab all profiles form the db

backend/lib/services/profile.js

@@ -1,4 +1,42 @@
 const Schmervice = require('@hapipal/schmervice')
+const cosineSimilarity = require('compute-cosine-similarity')
+
+const magic = 1000
+const scoreResponses = (seeker, potentialMatch) => {
+    if (seeker.responses.length != potentialMatch.responses.length)
+        return {
+            error: `complete responses for profile: ${seeker.profile_id} unqeual to profile: ${potentialMatch.profile_id}`,
+        }
+
+    const checkValCb = res => {
+        const val = parseInt(Object.values(res))
+        return isNaN(val) ? 0 : val
+    }
+    return Math.floor(
+        cosineSimilarity(
+            seeker.responses.map(checkValCb),
+            potentialMatch.responses.map(checkValCb),
+        ) * magic,
+    )
+}
+const userTypes = {
+    seeker: 'seeker',
+    poster: 'poster',
+}
+
+/**
+ * Class to hold our retrieved profile information
+ * in a convenient wrapper
+ * !: This needs to match the responseSchema in profiles.js
+ */
+class CompleteProfile {
+    constructor(profile, type) {
+        this.user_id = profile.user_id // int user_id
+        this.profile_id = profile.profile_id // int profile_id
+        this.responses = profile.responses // [] of all responses
+        this.user_type = type
+    }
+}
 
 module.exports = class ProfileService extends Schmervice.Service {
     constructor(...args) {
@@ -23,30 +61,18 @@ module.exports = class ProfileService extends Schmervice.Service {
         return [...new Set(profileIdsToGrab)]
     }
 
-    async getCompleteProfilesFor(userId) {
-        const { Profile, Response } = this.server.models()
+    async getCompleteProfilesFor(userId, type) {
+        const { Profile } = this.server.models()
 
-        const dedupedProfiles = await this._getProfileIdsForUserId(userId)
+        const dedupedProfileIds = await this._getProfileIdsForUserId(userId)
 
-        const responses = await Response.query().whereIn(
-            'profile_id',
-            dedupedProfiles,
-        )
-        const profiles = await Profile.query().whereIn(
-            'profile_id',
-            dedupedProfiles,
-        )
+        const profilesEntries = await Profile.query()
+            .whereIn('profile_id', dedupedProfileIds)
+            .withGraphFetched('responses')
 
         //** Get responses asociated with each profile_id */
-        return profiles.map(profile => {
-            if (!profile.responses) profile.responses = []
-            profile.response_keys = []
-            responses.forEach(response => {
-                if (response.profile_id !== profile.profile_id) return
-                profile.response_keys.push(response.response_key_id)
-                profile.responses.push(response)
-            })
-            return profile
+        return profilesEntries.map(profile => {
+            return new CompleteProfile(profile, type)
         })
     }
 
@@ -57,6 +83,8 @@ module.exports = class ProfileService extends Schmervice.Service {
      * @returns {object}
      */
     async saveResponsesCreateProfileFor(userId, responses, txn) {
+        const { Profile, Response } = this.server.models()
+
         const profile = await Profile.query(txn).insert({
             user_id: userId,
         })
@@ -78,7 +106,7 @@ module.exports = class ProfileService extends Schmervice.Service {
      * @returns {Array} updated responses
      */
     async updateResponsesInProfile(profileId, responses, txn) {
-        const { Profile, Response } = this.server.models()
+        const { Response } = this.server.models()
         for (const responseToSave of responses) {
             await Response.query(txn)
                 .update({
@@ -115,4 +143,33 @@ module.exports = class ProfileService extends Schmervice.Service {
 
         return await Profile.query().delete().where('profile_id', profileId)
     }
+
+    /**
+     * Score a profile
+     * @param {number} userId
+     * @returns {Array} Ordered and scored Profiles
+     */
+    async scoreProfilesFor(userId) {
+        const { User } = this.server.models(['user'])
+        const { Profile } = this.server.models()
+
+        const user = await User.query().findOne('user_id', userId)
+        const userProfile = await Profile.query()
+            .findOne('user_id', userId)
+            .withGraphFetched('responses')
+        const isPosterOpposite = user.is_poster == 1 ? 0 : 1
+        const userType = Object.keys(userTypes)[isPosterOpposite]
+
+        const profileIdsOfOppositeType = await Profile.query().withGraphFetched(
+            'responses',
+        )
+
+        return profileIdsOfOppositeType.map(profile => ({
+            profile_id: profile.profile_id,
+            score: scoreResponses(
+                userProfile,
+                new CompleteProfile(profile, userType),
+            ),
+        }))
+    }
 }