:sparkles: added mock for tags and associations | including tags on profiles | using prescore table | including aspect scores and composite scores

backend/db/mock.js

 module.exports = {
     users: [],
     profiles: [],
+    tags: [
+        {
+            tag_id: 1,
+            tag_category: 'verification',
+            tag_description: 'verified',
+            is_active: true,
+        },
+    ],
+    tag_associations: [
+        {
+            tag_association_id: 1,
+            profile_id: 1,
+            tag_id: 1,
+            is_deleted: false,
+        },
+        {
+            tag_association_id: 2,
+            profile_id: 2,
+            tag_id: 1,
+            is_deleted: false,
+        },
+        {
+            tag_association_id: 3,
+            profile_id: 3,
+            tag_id: 1,
+            is_deleted: false,
+        },
+        {
+            tag_association_id: 4,
+            profile_id: 5,
+            tag_id: 1,
+            is_deleted: false,
+        },
+    ],
     response_keys: [
         {
             response_key_id: 1,

backend/db/seeds/12-tags.js

+const mock = require('../mock')
+
+exports.seed = function (knex) {
+    // Deletes ALL existing entries
+    return knex('tags')
+        .truncate()
+        .then(function () {
+            // Inserts seed entries
+            return knex('tags').insert(mock.tags)
+        })
+}

backend/db/seeds/13-tag_associations.js

+const mock = require('../mock')
+
+exports.seed = function (knex) {
+    // Deletes ALL existing entries
+    return knex('tag_associations')
+        .truncate()
+        .then(function () {
+            // Inserts seed entries
+            return knex('tag_associations').insert(mock.tag_associations)
+        })
+}

backend/lib/models/aspect.js

+const Schwifty = require('@hapipal/schwifty')
+const Joi = require('joi')
+const config = require('../../db/data-generator/config.json')
+
+const aspects = { aspect_id: Joi.number() }
+const possible_combinations = Math.pow(config.scoreVals.length, 2)
+for(let i = 1; i <= possible_combinations; i++) {
+    aspects[i] = Joi.number()
+}
+
+module.exports = class Aspect extends Schwifty.Model {
+    static get tableName() {
+        return 'prescored_aspects'
+    }
+    static get joiSchema() {
+        return Joi.object(aspects)
+    }
+}

backend/lib/models/aspect_label.js

+const Schwifty = require('@hapipal/schwifty')
+const Joi = require('joi')
+
+module.exports = class AspectLabel extends Schwifty.Model {
+    static get tableName() {
+        return 'aspect_labels'
+    }
+    static get joiSchema() {
+        return Joi.object({ 
+            aspect_id: Joi.number(),
+            a: Joi.string(),
+            b: Joi.string()
+        })
+    }
+}

backend/lib/models/profile.js

 const Schwifty = require('@hapipal/schwifty')
 const Joi = require('joi')
+const TagAssociation = require('./tag-association')
 const Response = require('./response')
 const User = require('./user')
 
     }
     static get relationMappings() {
         return {
+            tags: {
+                relation: Schwifty.Model.HasManyRelation,
+                modelClass: TagAssociation,
+                join: {
+                    from: 'tag_associations.profile_id',
+                    to: 'profiles.profile_id',
+                },
+            },
             responses: {
                 relation: Schwifty.Model.HasManyRelation,
                 modelClass: Response,

backend/lib/models/tag-association.js

+const Schwifty = require('@hapipal/schwifty')
+const Joi = require('joi')
+
+const Tag = require('./tag')
+
+module.exports = class TagAssociation extends Schwifty.Model {
+    static get tableName() {
+        return 'tag_associations'
+    }
+    static get relationMappings() {
+        return {
+            description: {
+                relation: Schwifty.Model.BelongsToOneRelation,
+                modelClass: Tag,
+                join: {
+                    from: 'tag_associations.tag_id',
+                    to: 'tags.tag_id',
+                },
+            },
+        }
+    }
+    static get joiSchema() {
+        return Joi.object({
+            tag_association_id: Joi.number(),
+            profile_id: Joi.number(),
+            tag_id: Joi.number(),
+            is_deleted: Joi.bool(),
+        })
+    }
+}

backend/lib/models/tag.js

+const Schwifty = require('@hapipal/schwifty')
+const Joi = require('joi')
+
+module.exports = class Tag extends Schwifty.Model {
+    static get tableName() {
+        return 'tags'
+    }
+    static get joiSchema() {
+        return Joi.object({
+            tag_id: Joi.number(),
+            tag_category: Joi.string(),
+            tag_description: Joi.string(),
+            is_active: Joi.bool(),
+        })
+    }
+}

backend/lib/plugins/profile.js

 const Schmervice = require('@hapipal/schmervice')
 
 const ProfileModel = require('../models/profile')
+const TagModel = require('../models/tag')
+const TagAssociationModel = require('../models/tag-association')
+const AspectModel = require('../models/aspect')
+const AspectLabelModel = require('../models/aspect_label')
 const ResponseModel = require('../models/response')
 const ZipCodeModel = require('../models/zip-code')
 const MatchQueueModel = require('../models/matchqueue')
     version: '1.0.0',
     register: async (server, options) => {
         await server.registerModel(ProfileModel)
+        await server.registerModel(TagModel)
+        await server.registerModel(TagAssociationModel)
+        await server.registerModel(AspectModel)
+        await server.registerModel(AspectLabelModel)
         await server.registerModel(ResponseModel)
         await server.registerModel(ZipCodeModel)
         await server.registerModel(MatchQueueModel)

backend/lib/routes/profile/queue.js

                 user_id: Joi.number(),
                 user_name: Joi.string(),
                 responses: Joi.array().items(),
+                tags: Joi.array().items(),
                 user_media: Joi.string(),
                 user_type: Joi.any(),
                 user: Joi.object()

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

         // and this route utilizes getCompleteProfiles
         user_name: Joi.string(),
         user_media: Joi.string(),
+        tags: Joi.array().items(),
         responses: Joi.array().items(
             Joi.object({
                 response_key_id: Joi.number().required(),

backend/lib/services/profile.js

 const Schmervice = require('@hapipal/schmervice')
-const cosineSimilarity = require('compute-cosine-similarity')
 const haversine = require('haversine')
-const zipcodeKey = 7
-const magic = 1000
-const scoreResponses = (seeker, potentialMatch) => {
+
+const _ZIPCODEKEY = 7
+const scoreResponses = (seeker, potentialMatch, prescoreLookup) => {
     if (seeker.responses.length != potentialMatch.responses.length)
         return {
             error: `complete responses for profile: ${seeker.profile_id} unqeual to profile: ${potentialMatch.profile_id} | ${seeker.responses.length}:${potentialMatch.responses.length}`,
         }
-
-    const checkValCb = res => {
-        const val = parseInt(res.val)
-        return isNaN(val) ? 0 : val
+    
+    const aRes = [...seeker.responses]
+    const bRes = [...potentialMatch.responses]
+
+    const composite = []
+    while(aRes.length + bRes.length > 0) {
+        const mKey = resList => {
+            let el = resList.shift()
+            let pair = el.val
+            el = resList.shift()
+            return `${pair}:${el.val}`
+        }
+        composite.push(prescoreLookup[mKey(aRes)][mKey(bRes)])
     }
-
-    return Math.floor(
-        cosineSimilarity(
-            seeker.responses.map(checkValCb),
-            potentialMatch.responses.map(checkValCb),
-        ) * magic,
-    )
+    return { total: Math.round(composite.reduce((a, b) => a + b) / composite.length), aspects: composite }
 }
 const filterByDistance = (profileList, max) => {
     return profileList.filter(profile => {
         return profileDistance <= adjustedMaxDistance
     })
 }
-const scoreAll = (profileList, userProfile) => {
+const scoreAll = (profileList, userProfile, prescoreLookup) => {
     return profileList.map(profile => {
         return {
             // Uncomment to return the whole profile
             // ...profile,
             profile_id: profile.profile_id,
-            score: scoreResponses(userProfile, profile),
+            score: scoreResponses(userProfile, profile, prescoreLookup),
             distance: profile.distance,
         }
     })
     // There should only be one zip code entry per profile
     let zipRes = profile.responses.filter(
         // Whatever the zipcode questions is
-        response => response.response_key_id == zipcodeKey,
+        response => response.response_key_id == _ZIPCODEKEY,
     )[0]
 
     const responseIndexForZip = profile.responses.indexOf(zipRes)
     return zipRes.val
 }
 
+const makeScoreLookup = (aspects, labels) => {
+    const labelLookup = {}
+    labels.forEach(label => labelLookup[label.aspect_id] = label)
+
+    const scoreLookup = {}
+    aspects.forEach(aspect => {
+        const key = labelLookup[aspect.aspect_id]
+        scoreLookup[`${key.a}:${key.b}`] = {}
+        Object.keys(aspect).forEach(aspect_id => {
+            if(!labelLookup[aspect_id]) return
+            const comp = labelLookup[aspect_id]
+            const score = aspect[aspect_id]
+            scoreLookup[`${key.a}:${key.b}`][`${comp.a}:${comp.b}`] = score
+        })
+        
+    })
+    return scoreLookup
+}
+
 /**
  * Class to hold our retrieved profile information
  * in a convenient wrapper
         this.user_name = profile.user.user_name // string user_name
         this.user_media = profile.user_media // string user_media
         this.responses = profile.responses // [] of all responses
+        this.tags = profile.tags // [] of all tags
         this.user_type = type
     }
 }
 module.exports = class ProfileService extends Schmervice.Service {
     constructor(...args) {
         super(...args)
+        this.scoreLookup = {}
+        this.tagLookup = {}
+    }
+    async _setScoreLookup() {
+        if(!Object.keys(this.scoreLookup).length) {
+            const { Aspect, AspectLabel } = this.server.models()
+            const aspects = await Aspect.query()
+            const labels = await AspectLabel.query()
+            this.scoreLookup = makeScoreLookup(aspects, labels)
+        }
+    }
+    async _setTagLookup() {
+        if(!Object.keys(this.tagLookup).length) {
+            const { Tag } = this.server.models()
+            const allTagDescriptions = await Tag.query()
+            allTagDescriptions.forEach(desc => this.tagLookup[desc.tag_id] = {
+                description: desc.tag_description,
+                category: desc.tag_category,
+            })
+        }
     }
-
     /**
      * Internal method to get list of profile_ids for this user
      * @param {number} userId
 
     async getCompleteProfilesFor(userId, type) {
         const { Profile } = this.server.models()
+        await this._setTagLookup()
 
         const dedupedProfileIds = await this._getProfileIdsForUserId(userId)
-
+        
         const profilesEntries = await Profile.query()
             .whereIn('profile_id', dedupedProfileIds)
+            .withGraphFetched('tags')
             .withGraphFetched('responses')
             // CHECKTHIS: Added this because we added user.user_name to CompleteProfile
             // so without this, we get undefined user_name
             .withGraphFetched('user')
 
+        profilesEntries.forEach(profile => {
+            profile.tags = profile.tags.map(tag => this.tagLookup[tag.tag_id])
+        })
+        
         //** Get responses asociated with each profile_id */
         return profilesEntries.map(profile => {
             return new CompleteProfile(profile, type)
 
     async getProfilesFor(profileIdArray, type, includeResponses = true) {
         const { Profile } = this.server.models()
-        // profilesEntries is profiles in database row order 
+        await this._setScoreLookup()
+        await this._setTagLookup()
+        
+
+        // profilesEntries is profiles in dataaspect_labelsbase row order 
         const profilesEntries = includeResponses ? await Profile.query()
             .whereIn('profile_id', profileIdArray)
+            .withGraphFetched('tags')
             .withGraphFetched('responses')
             .withGraphFetched('user') : await Profile.query()
             .whereIn('profile_id', profileIdArray)
+            .withGraphFetched('tags')
             .withGraphFetched('user') 
 
         // taking the info from profilesEntries
                     if(!includeResponses) {
                         delete complete['responses']
                     }
+                    if(entry?.tags?.length){
+                        complete.tags = entry.tags.map(tag => this.tagLookup[tag.tag_id])
+                    }
                     completeProfiles.push(complete)
                 }
             })
-        })  
+        })
         return completeProfiles
     }
 
      */
     async scoreProfilesFor(profileId, maxDistance, distanceUnit) {
         const { Profile } = this.server.models()
+        
+        await this._setScoreLookup()
 
         // Our User Profile to score for
         const userProfile = await Profile.query()
 
         // Only include profiles that included zipcode response
         profileIdsOfOppositeType = profileIdsOfOppositeType.filter(profile => {
-            const zipcodeResponses = profile.responses.filter(response => response.response_key_id == zipcodeKey)
+            const zipcodeResponses = profile.responses.filter(res => res.response_key_id == _ZIPCODEKEY)
             return zipcodeResponses.length > 0
         })
 
         const scoredProfilesWithDistance = scoreAll(
             distanceFilteredProfiles,
             userProfile,
+            this.scoreLookup
         )
 
         // Order by score
-        return scoredProfilesWithDistance.sort((a, b) => a.score - b.score)
+        return scoredProfilesWithDistance.sort((a, b) => b.score.total - a.score.total)
     }
 
     /**