:tada: start over

backend/db/data-generator/classes.js

@@ -1,30 +0,0 @@
-class User {
-    constructor(id) {
-        this.user_id = id
-        this.user_name = ''
-        this.user_email = ''
-        this.is_admin = false
-        this.is_poster = false
-        this.is_verified = false
-    }
-}
-class Profile {
-    constructor(id, override) {
-        this.user_id = override?.user_id ? override.user_id : id
-        this.profile_id = override?.profile_id ? override.profile_id + id : id
-    }
-}
-class Response {
-    constructor(id) {
-        this.response_id = id
-        this.profile_id = null
-        this.response_key_id = null
-        this.val = null
-    }
-}
-
-module.exports = {
-    User,
-    Profile,
-    Response,
-}

backend/db/data-generator/config.json

@@ -1,46 +0,0 @@
-{
-    "mockOutputPath": "./db/generated",
-    "magic": 1000,
-    "total": 100,
-    "ignore": [],
-    "batchSize": 10,
-    "percentageOfSeekers": 90,
-    "scoreVals": [1, 2, 3, 4, 5, 6, 7],
-    "header": "/**\n* GENERATED MOCK SIIMEE DATA\n*/",
-    "possibleZipcodes": [
-        "90012",
-        "90040",
-        "90058",
-        "90064",
-        "90065",
-        "90240",
-        "90274",
-        "90278",
-        "90280",
-        "90290",
-        "90291",
-        "90292",
-        "90293",
-        "90840",
-        "91001",
-        "91011",
-        "91030",
-        "91201",
-        "91399",
-        "91401",
-        "97075"
-    ],
-    "scoreKeys": [1, 2, 3, 4, 5, 6],
-    "nameKey": 7,
-    "emailKey": 8,
-    "passwordKey": 9,
-    "zipcodeKey": 10,
-    "mediaKey": 12,
-    "langKey": 13,
-    "durationKey": 14,
-    "presenceKey": 15,
-    "blurbKey": 16,
-    "urgencyKey": 17,
-    "pronounsKey": 18,
-    "distanceKey": 19
-}

backend/db/data-generator/generate.ipynb

@@ -1,197 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Scoring: ((1, 1), (7, 7))\n",
-      "1515\n",
-      "\n",
-      "Scoring: ((2, 1), (2, 2))\n",
-      "9000\n",
-      "\n",
-      "Scoring: ((2, 7), (6, 3))\n",
-      "4343\n",
-      "\n",
-      "Scoring: ((6, 3), (1, 2))\n",
-      "4901\n",
-      "\n",
-      "Scoring: ((5, 6), (4, 6))\n",
-      "9000\n",
-      "\n",
-      "Scoring: ((1, 2), (3, 3))\n",
-      "7764\n",
-      "\n",
-      "Scoring: ((1, 1), (1, 1))\n",
-      "10000\n"
-     ]
-    }
-   ],
-   "source": [
-    "import json\n",
-    "import copy\n",
-    "from itertools import product\n",
-    "from scipy import spatial\n",
-    "import math\n",
-    "import numpy\n",
-    "\n",
-    " \n",
-    "f = open('./config.json')\n",
-    "from_json_config = json.load(f)\n",
-    "config = {}\n",
-    "config[\"all_possible_responses\"] = from_json_config[\"scoreVals\"]\n",
-    "config[\"magic\"] = from_json_config[\"magic\"]\n",
-    "config[\"aspect_size\"] = 2\n",
-    "config[\"write\"]= True\n",
-    "config[\"file\"] = \"../generated/prescore_matrix.json\"\n",
-    "config[\"delimiter\"] = \"-\"\n",
-    "config[\"version\"] = \"0.1.0\"\n",
-    "# max distance = distance between top left and bottom right indices in matrix\n",
-    "config[\"max_euclidean_distance\"] =  math.sqrt(\n",
-    "    math.pow(len(config[\"all_possible_responses\"])-1, 2) +\n",
-    "    math.pow(len(config[\"all_possible_responses\"])-1, 2)\n",
-    "    ) \n",
-    "f.close()\n",
-    "\n",
-    "def createPermutations(possibilities, size):\n",
-    "    return tuple(product(possibilities, repeat=size))\n",
-    "\n",
-    "\n",
-    "def getAspectFromSurveys(survey_a, survey_b, size):\n",
-    "    if (survey_a.__len__() < size | survey_b.__len__() < size):\n",
-    "        raise Exception(\"Surveys must both contain more items than size\")\n",
-    "\n",
-    "    def store(survey, length):\n",
-    "        col = []\n",
-    "        for i in range(size):\n",
-    "            val = survey.pop(0)\n",
-    "            col.append(val)\n",
-    "        return col\n",
-    "\n",
-    "    # Take the first <size> elements from the list\n",
-    "    col_a = tuple(store(survey_a, size))\n",
-    "    col_b = tuple(store(survey_b, size))\n",
-    "\n",
-    "    if (col_a.__len__() != size | col_b.__len__() != size ):\n",
-    "        raise Exception(\"No aspect values found in survey\")\n",
-    "\n",
-    "    return (col_a, col_b)\n",
-    "\n",
-    "\n",
-    "def scoreAspect(aspect_ab):\n",
-    "    a = aspect_ab[0]\n",
-    "    b = aspect_ab[1]\n",
-    "    return (1 - spatial.distance.cosine(a,b)) * config[\"magic\"]\n",
-    "\n",
-    "def euclideanDistance(aspect_ab):\n",
-    "    a = numpy.array(aspect_ab[0])\n",
-    "    b = numpy.array(aspect_ab[1])\n",
-    "    return numpy.linalg.norm(a - b)\n",
-    "\n",
-    "def prescore_matrix_from(vals):\n",
-    "    m = {}\n",
-    "    for val in vals:\n",
-    "        m[val] = []\n",
-    "        for other_val in vals:\n",
-    "            distance = euclideanDistance((val,other_val))\n",
-    "            score = (config[\"max_euclidean_distance\"] - distance) * config[\"magic\"] + 1515\n",
-    "            # score = scoreAspect((val, other_val))\n",
-    "            adjusted_score = round(score)\n",
-    "            m[val].append(adjusted_score)\n",
-    "    return m\n",
-    "\n",
-    "\n",
-    "def lookup_prescore_in(score_matrix, vals, aspect_ab):\n",
-    "    print(\"\\nScoring:\", aspect_ab)\n",
-    "    aspect_a, aspect_b = aspect_ab\n",
-    "    # Look-up using the index because\n",
-    "    # \n",
-    "    pos_b = vals.index(aspect_b)\n",
-    "    return score_matrix[aspect_a][pos_b]\n",
-    "\n",
-    "\n",
-    "# !: Mutates your input\n",
-    "def score_aspect(input_a, input_b, score_matrix, vals):\n",
-    "    aspect_ab = getAspectFromSurveys(input_a, input_b, config[\"aspect_size\"])\n",
-    "    return lookup_prescore_in(score_matrix, vals, aspect_ab)\n",
-    "\n",
-    "\n",
-    "def run():\n",
-    "    # Set the keys for the look-up\n",
-    "    xy_axis_vals = createPermutations(config[\"all_possible_responses\"], config[\"aspect_size\"])\n",
-    "    m = prescore_matrix_from(xy_axis_vals)\n",
-    "\n",
-    "    # Example:\n",
-    "    res = config[\"all_possible_responses\"]\n",
-    "    input_a = [\n",
-    "        res[0], res[0], # One aspect\n",
-    "        res[1], res[0],\n",
-    "        res[1], res[6],\n",
-    "        res[5], res[2],\n",
-    "        res[4], res[5],\n",
-    "        res[0], res[1],\n",
-    "        res[0], res[0],\n",
-    "    ]\n",
-    "    input_b = [\n",
-    "        res[6], res[6], # One aspect\n",
-    "        res[1], res[1],\n",
-    "        res[5], res[2],\n",
-    "        res[0], res[1],\n",
-    "        res[3], res[5],\n",
-    "        res[2], res[2],\n",
-    "        res[0], res[0],\n",
-    "    ]\n",
-    "    for i in range(round(input_a.__len__() / 2)):\n",
-    "        print(score_aspect(input_a, input_b, m, xy_axis_vals))\n",
-    "\n",
-    "\n",
-    "    if(config[\"write\"] == True):\n",
-    "        # Serializing json\n",
-    "        str_m = {}\n",
-    "        for key, values in m.items():\n",
-    "            delimiter = config[\"delimiter\"]\n",
-    "            str_key = delimiter.join([str(v) for v in key])\n",
-    "            str_m[str_key] = [int(val) for val in values]\n",
-    "            str_m[\"_config\"] = config\n",
-    "        json_object = json.dumps(str_m, indent = 4)\n",
-    "        with open(config[\"file\"], \"w\") as file:\n",
-    "            # write to file\n",
-    "            file.write(json_object)\n",
-    "run()\n"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3.10.6 64-bit",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.6"
-  },
-  "orig_nbformat": 4,
-  "vscode": {
-   "interpreter": {
-    "hash": "b0fa6594d8f4cbf19f97940f81e996739fb7646882a419484c72d19e05852a7e"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

backend/db/data-generator/index.js

@@ -1,187 +0,0 @@
-const fs = require('fs')
-const config = require('./config')
-const random = require('./random')
-const classes = require('./classes')
-const mock = require('./mock')
-
-let batchCount = 1 // Counter to track how many things we've generated
-let extraProfilesToGenerate = 1
-let extraProfileCount = 0 // Counter to track how many EXTRA profiles we've generated
-let generatedResponseCount = 0 // Counter to track every response generated
-
-// Values for responsess as strings
-const possibleResponses = {
-    not_important: null,
-    some_what_important: null,
-    important: null,
-    very_important: null,
-    extremely_important: null,
-    mandatory: null,
-}
-for (let i = 0; i < Object.keys(possibleResponses).length; i++) {
-    const key = Object.keys(possibleResponses)[i]
-    possibleResponses[key] = config.scoreVals[i].toString()
-}
-
-/**
- * Our initial file setup
- */
-const write = async (batchNum, outputDataObject) => {
-    const filename = `_batch_${batchNum}.js`
-    await fs.writeFile(`${config.mockOutputPath}/${filename}`, '', () => {})
-    fs.appendFile(
-        `${config.mockOutputPath}/${filename}`,
-        config.header +
-            'module.exports = ' +
-            JSON.stringify(outputDataObject, null, '  '),
-        err => {
-            if (err) {
-                console.error(err)
-                return
-            }
-        },
-    )
-}
-
-// Helper functions
-const generate = (classObj, amount, meta) => {
-    const instances = []
-    for (let i = 0; i < amount; i++) {
-        let startFrom = meta?.starting ? meta.starting - config.batchSize : 0
-        instances.push(new classObj(i + startFrom + 1, meta))
-    }
-    return instances
-}
-
-console.log('\nStarting...\n---')
-
-/**
- * Generate Users
- */
-const generateUsers = () => {
-    let users = generate(classes.User, config.batchSize, {
-        starting: config.batchSize * batchCount,
-    })
-    users.forEach(user => {
-        user.is_poster = random.number(100) > config.percentageOfSeekers ? 1 : 0
-        if (user.is_poster) {
-            extraProfilesToGenerate = extraProfilesToGenerate + random.number(2)
-        }
-        user.user_name = random.name() + ' ' + random.name()
-        user.user_email = random.email()
-    })
-    console.log('COMPLETED: Generated Users...')
-    return users
-}
-
-/**
- * Generate Profiles
- */
-const generateProfiles = jobPosterIds => {
-    let profiles = generate(classes.Profile, config.batchSize, {
-        starting: config.batchSize * batchCount,
-        profile_id: extraProfileCount,
-    })
-
-    // Generate extra job posting profiles
-    // attributed to random user.is_poster === true
-    // TODO: Clean this up. Hard to read...
-    if (extraProfilesToGenerate > 0) {
-        let extras = []
-        for (let l = 0; l < extraProfilesToGenerate; l++) {
-            const generatedExtraProfiles = generate(classes.Profile, 1, {
-                user_id:
-                    jobPosterIds.length > 1
-                        ? random.valFrom(jobPosterIds)
-                        : jobPosterIds[0],
-                profile_id:
-                    config.batchSize * batchCount + extraProfileCount + l,
-            })
-            extras = [...extras, ...generatedExtraProfiles]
-        }
-        extras.forEach(profile => {
-            profiles.push(profile)
-            extraProfileCount++
-        })
-    }
-    console.log('COMPLETED: Generated Profiles...')
-    return profiles
-}
-
-/**
- * Generate Responses
- */
-const generateResponses = profiles => {
-    // Generate responses first, before filling in details
-    let responses = generate(
-        classes.Response,
-        (config.batchSize + extraProfilesToGenerate) *
-            mock.response_keys.length,
-        { starting: generatedResponseCount + config.batchSize },
-    )
-    profiles.forEach((profile, i) => {
-        const startingIndex = i * mock.response_keys.length
-        for (let k = 0; k < mock.response_keys.length; k++) {
-            const resToEdit = responses[startingIndex + k]
-            resToEdit.response_key_id = k + 1
-            resToEdit.profile_id = profile.profile_id
-
-            if (resToEdit.response_key_id < config.zipcodeKey) {
-                resToEdit.val = random.valFrom(Object.values(possibleResponses))
-            } else if (resToEdit.response_key_id == config.zipcodeKey) {
-                resToEdit.val = random.valFrom(config.possibleZipcodes)
-            } else {
-                switch (resToEdit.response_key_id) {
-                    case config.mediaKey:
-                        resToEdit.val = random.media()
-                        break
-                    case config.langKey:
-                        resToEdit.val = random.language()
-                        break
-                    case config.durationKey:
-                        resToEdit.val = random.duration()
-                        break
-                    case config.presenceKey:
-                        resToEdit.val = random.location()
-                        break
-                    case config.blurbKey:
-                        resToEdit.val = random.blurb()
-                        break
-                }
-            }
-        }
-    })
-    generatedResponseCount = generatedResponseCount + responses.length
-    console.log('COMPLETED: Generated Responses...')
-    return responses
-}
-
-/**
- * Our main generator loop
- */
-for (
-    let batch = config.batchSize;
-    batch <= config.total;
-    batch += config.batchSize
-) {
-    const users = generateUsers()
-
-    let jobPosterIds = users
-        .filter(user => user.is_poster > 0)
-        .map(user => user.user_id)
-    // Guarantee ONE job poster
-    if (!jobPosterIds.length) {
-        random.valFrom(users).is_poster = 1
-        jobPosterIds = users
-            .filter(user => user.is_poster > 0)
-            .map(user => user.user_id)
-    }
-
-    const profiles = generateProfiles(jobPosterIds)
-    const responses = generateResponses(profiles)
-
-    write(config.batchSize * batchCount, { users, profiles, responses })
-    batchCount++
-}
-
-console.log('---\nFINISHED...\n===\n')

backend/db/data-generator/lorem.js

@@ -1,230 +0,0 @@
-/**
- * @fileOverview Generates "Lorem ipsum" style text.
- * @author rviscomi@gmail.com Rick Viscomi,
- * 		tinsley@tinsology.net Mathew Tinsley
- * @version 1.0
- */
-
-/**
- *	Copyright (c) 2009, Mathew Tinsley (tinsley@tinsology.net)
- *	All rights reserved.
- *
- *	Redistribution and use in source and binary forms, with or without
- *	modification, are permitted provided that the following conditions are met:
- *		* Redistributions of source code must retain the above copyright
- *		  notice, this list of conditions and the following disclaimer.
- *		* Redistributions in binary form must reproduce the above copyright
- *		  notice, this list of conditions and the following disclaimer in the
- *		  documentation and/or other materials provided with the distribution.
- *		* Neither the name of the organization nor the
- *		  names of its contributors may be used to endorse or promote products
- *		  derived from this software without specific prior written permission.
- *
- *	THIS SOFTWARE IS PROVIDED BY MATHEW TINSLEY ''AS IS'' AND ANY
- *	EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- *	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- *	DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
- *	DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- *	(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- *	LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- *	ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- *	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- *	SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/**
- * @class Jibborish generator.
- */
-var LoremIpsum = function () {};
-
-/**
- * Average number of words per sentence.
- * @constant {number}
- */
-LoremIpsum.WORDS_PER_SENTENCE_AVG = 24.460;
-
-/**
- * Standard deviation of the number of words per sentence.
- * @constant {number}
- */
-LoremIpsum.WORDS_PER_SENTENCE_STD = 5.080;
-
-/**
- * List of possible words.
- * @constant {Array.string}
- */
-LoremIpsum.WORDS = [
-		'lorem', 'ipsum', 'dolor', 'sit', 'amet', 'consectetur',
-		'adipiscing', 'elit', 'curabitur', 'vel', 'hendrerit', 'libero',
-		'eleifend', 'blandit', 'nunc', 'ornare', 'odio', 'ut',
-		'orci', 'gravida', 'imperdiet', 'nullam', 'purus', 'lacinia',
-		'a', 'pretium', 'quis', 'congue', 'praesent', 'sagittis', 
-		'laoreet', 'auctor', 'mauris', 'non', 'velit', 'eros',
-		'dictum', 'proin', 'accumsan', 'sapien', 'nec', 'massa',
-		'volutpat', 'venenatis', 'sed', 'eu', 'molestie', 'lacus',
-		'quisque', 'porttitor', 'ligula', 'dui', 'mollis', 'tempus',
-		'at', 'magna', 'vestibulum', 'turpis', 'ac', 'diam',
-		'tincidunt', 'id', 'condimentum', 'enim', 'sodales', 'in',
-		'hac', 'habitasse', 'platea', 'dictumst', 'aenean', 'neque',
-		'fusce', 'augue', 'leo', 'eget', 'semper', 'mattis', 
-		'tortor', 'scelerisque', 'nulla', 'interdum', 'tellus', 'malesuada',
-		'rhoncus', 'porta', 'sem', 'aliquet', 'et', 'nam',
-		'suspendisse', 'potenti', 'vivamus', 'luctus', 'fringilla', 'erat',
-		'donec', 'justo', 'vehicula', 'ultricies', 'varius', 'ante',
-		'primis', 'faucibus', 'ultrices', 'posuere', 'cubilia', 'curae',
-		'etiam', 'cursus', 'aliquam', 'quam', 'dapibus', 'nisl',
-		'feugiat', 'egestas', 'class', 'aptent', 'taciti', 'sociosqu',
-		'ad', 'litora', 'torquent', 'per', 'conubia', 'nostra',
-		'inceptos', 'himenaeos', 'phasellus', 'nibh', 'pulvinar', 'vitae',
-		'urna', 'iaculis', 'lobortis', 'nisi', 'viverra', 'arcu',
-		'morbi', 'pellentesque', 'metus', 'commodo', 'ut', 'facilisis',
-		'felis', 'tristique', 'ullamcorper', 'placerat', 'aenean', 'convallis',
-		'sollicitudin', 'integer', 'rutrum', 'duis', 'est', 'etiam',
-		'bibendum', 'donec', 'pharetra', 'vulputate', 'maecenas', 'mi',
-		'fermentum', 'consequat', 'suscipit', 'aliquam', 'habitant', 'senectus',
-		'netus', 'fames', 'quisque', 'euismod', 'curabitur', 'lectus',
-		'elementum', 'tempor', 'risus', 'cras'
-];
-
-/**
- * Generate "Lorem ipsum" style words.
- * @param num_words {number} Number of words to generate.
- * @return {string} "Lorem ipsum..."
- */
-LoremIpsum.prototype.generate = function (num_words) {
-	var words, ii, position, word, current, sentences, sentence_length, sentence;
-	
-	/**
-	 * @default 100
-	 */
-	num_words = num_words || 100;
-	
-	words = [LoremIpsum.WORDS[0], LoremIpsum.WORDS[1]];
-	num_words -= 2;
-	
-	for (ii = 0; ii < num_words; ii++) {
-		position = Math.floor(Math.random() * LoremIpsum.WORDS.length);
-		word = LoremIpsum.WORDS[position];
-		
-		if (ii > 0 && words[ii - 1] === word) {
-			ii -= 1;
-			
-		} else {
-			words[ii] = word;
-		}
-	}
-	
-	sentences = [];
-	current = 0;
-	
-	while (num_words > 0) {
-		sentence_length = this.getRandomSentenceLength();
-		
-		if (num_words - sentence_length < 4) {
-			sentence_length = num_words;
-		}
-		
-		num_words -= sentence_length;
-		
-		sentence = [];
-		
-		for (ii = current; ii < (current + sentence_length); ii++) {
-			sentence.push(words[ii]);
-		}
-		
-		sentence = this.punctuate(sentence);
-		current += sentence_length;
-		sentences.push(sentence.join(' '));
-	}
-	
-	return sentences.join(' ');
-};
-
-/**
- * Insert commas and periods in the given sentence.
- * @param {Array.string} sentence List of words in the sentence.
- * @return {Array.string} Sentence with punctuation added.
- */
-LoremIpsum.prototype.punctuate = function (sentence) {
-	var word_length, num_commas, ii, position;
-	
-	word_length = sentence.length;
-	
-	/* End the sentence with a period. */
-	sentence[word_length - 1] += '.';
-	
-	if (word_length < 4) {
-		return sentence;
-	}
-	
-	num_commas = this.getRandomCommaCount(word_length);
-	
-	for (ii = 0; ii <= num_commas; ii++) {
-		position = Math.round(ii * word_length / (num_commas + 1));
-		
-		if (position < (word_length - 1) && position > 0) {
-			/* Add the comma. */
-			sentence[position] += ',';
-		}
-	}
-	
-	/* Capitalize the first word in the sentence. */
-	sentence[0] = sentence[0].charAt(0).toUpperCase() + sentence[0].slice(1);
-	
-	return sentence;
-};
-
-/**
- * Produces a random number of commas.
- * @param {number} word_length Number of words in the sentence.
- * @return {number} Random number of commas
- */
-LoremIpsum.prototype.getRandomCommaCount = function (word_length) {
-	var base, average, standard_deviation;
-	
-	/* Arbitrary. */
-	base = 6;
-	
-	average = Math.log(word_length) / Math.log(base);
-	standard_deviation = average / base;
-	
-	return Math.round(this.gaussMS(average, standard_deviation));
-};
-
-/**
- * Produces a random sentence length based on the average word length
- * of an English sentence.
- * @return {number} Random sentence length
- */
-LoremIpsum.prototype.getRandomSentenceLength = function () {
-	return Math.round(
-			this.gaussMS(
-					LoremIpsum.WORDS_PER_SENTENCE_AVG,
-					LoremIpsum.WORDS_PER_SENTENCE_STD
-			)
-	);
-};
-
-/**
- * Produces a random number.
- * @return {number} Random number
- */
-LoremIpsum.prototype.gauss = function () {
-	return (Math.random() * 2 - 1) +
-			(Math.random() * 2 - 1) +
-			(Math.random() * 2 - 1);
-};
-
-/**
- * Produces a random number with Gaussian distribution.
- * @param {number} mean
- * @param {number} standard_deviation
- * @return {number} Random number
- */
-LoremIpsum.prototype.gaussMS = function (mean, standard_deviation) {
-	return Math.round(this.gauss() * standard_deviation + mean);
-};
-
-module.exports = {
-	LoremIpsum
-}

backend/db/data-generator/mock.js

@@ -1,760 +0,0 @@
-module.exports = {
-    users: [],
-    profiles: [],
-    tags: [
-        {
-            tag_id: 1,
-            tag_category: 'verification',
-            tag_description: 'verified',
-            is_active: true,
-        },
-        {
-            tag_id: 2,
-            tag_category: 'reveal',
-            tag_description: 'verified',
-            is_active: true,
-        },
-        {
-            tag_id: 3,
-            tag_category: 'reveal',
-            tag_description: 'pronoun',
-            is_active: true,
-        },
-        {
-            tag_id: 4,
-            tag_category: 'reveal',
-            tag_description: 'image',
-            is_active: true,
-        },
-        {
-            tag_id: 5,
-            tag_category: 'reveal',
-            tag_description: 'blurb',
-            is_active: true,
-        },
-        {
-            tag_id: 6,
-            tag_category: 'reveal',
-            tag_description: 'urgency',
-            is_active: true,
-        },
-        {
-            tag_id: 7,
-            tag_category: 'reveal',
-            tag_description: 'user_name',
-            is_active: true,
-        },
-        {
-            tag_id: 8,
-            tag_category: 'reveal',
-            tag_description: 'user_email',
-            is_active: true,
-        },
-        {
-            tag_id: 9,
-            tag_category: 'healthcare--certification',
-            tag_description: 'ADM-BC',
-            is_active: true,
-        },
-        {
-            tag_id: 10,
-            tag_category: 'healthcare--certification',
-            tag_description: 'CBHC',
-            is_active: true,
-        },
-        {
-            tag_id: 11,
-            tag_category: 'healthcare--certification',
-            tag_description: 'CEN',
-            is_active: true,
-        },
-        {
-            tag_id: 12,
-            tag_category: 'healthcare--certification',
-            tag_description: 'CFRN',
-            is_active: true,
-        },
-        {
-            tag_id: 13,
-            tag_category: 'healthcare--certification',
-            tag_description: 'CMCN',
-            is_active: true,
-        },
-    ],
-    tag_associations: [
-        {
-            tag_association_id: 1,
-            profile_id: 1,
-            grouping_id: null,
-            tag_id: 1,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 2,
-            profile_id: 2,
-            grouping_id: null,
-            tag_id: 1,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 3,
-            profile_id: 3,
-            grouping_id: null,
-            tag_id: 1,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 4,
-            profile_id: 45,
-            grouping_id: null,
-            tag_id: 1,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 5,
-            profile_id: 45,
-            grouping_id: 2,
-            tag_id: 8,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 6,
-            profile_id: 45,
-            grouping_id: 2,
-            tag_id: 5,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 7,
-            profile_id: 2,
-            grouping_id: 2,
-            tag_id: 5,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 8,
-            profile_id: 41,
-            grouping_id: 1,
-            tag_id: 4,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 9,
-            profile_id: 41,
-            grouping_id: 1,
-            tag_id: 5,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 10,
-            profile_id: 4,
-            grouping_id: null,
-            tag_id: 1,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 11,
-            profile_id: 5,
-            grouping_id: null,
-            tag_id: 1,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 12,
-            profile_id: 6,
-            grouping_id: null,
-            tag_id: 3,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 13,
-            profile_id: 7,
-            grouping_id: null,
-            tag_id: 8,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 14,
-            profile_id: 8,
-            grouping_id: null,
-            tag_id: 7,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 15,
-            profile_id: 9,
-            grouping_id: 1,
-            tag_id: 2,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 16,
-            profile_id: 10,
-            grouping_id: 2,
-            tag_id: 2,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 17,
-            profile_id: 11,
-            grouping_id: 2,
-            tag_id: 3,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 18,
-            profile_id: 12,
-            grouping_id: 3,
-            tag_id: 4,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 19,
-            profile_id: 13,
-            grouping_id: 3,
-            tag_id: 7,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 20,
-            profile_id: 14,
-            grouping_id: 4,
-            tag_id: 6,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 21,
-            profile_id: 15,
-            grouping_id: 1,
-            tag_id: 1,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 22,
-            profile_id: 16,
-            grouping_id: 1,
-            tag_id: 2,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 23,
-            profile_id: 17,
-            grouping_id: null,
-            tag_id: 6,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 24,
-            profile_id: 18,
-            grouping_id: null,
-            tag_id: 8,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 25,
-            profile_id: 19,
-            grouping_id: null,
-            tag_id: 3,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 26,
-            profile_id: 20,
-            grouping_id: null,
-            tag_id: 3,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 27,
-            profile_id: 21,
-            grouping_id: 2,
-            tag_id: 1,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 28,
-            profile_id: 22,
-            grouping_id: 2,
-            tag_id: 1,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 29,
-            profile_id: 23,
-            grouping_id: 3,
-            tag_id: 2,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 30,
-            profile_id: 24,
-            grouping_id: 4,
-            tag_id: 4,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 31,
-            profile_id: 25,
-            grouping_id: 5,
-            tag_id: 3,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 32,
-            profile_id: 26,
-            grouping_id: 1,
-            tag_id: 4,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 33,
-            profile_id: 27,
-            grouping_id: null,
-            tag_id: 3,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 34,
-            profile_id: 28,
-            grouping_id: null,
-            tag_id: 3,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 35,
-            profile_id: 29,
-            grouping_id: null,
-            tag_id: 7,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 36,
-            profile_id: 30,
-            grouping_id: null,
-            tag_id: 6,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 37,
-            profile_id: 31,
-            grouping_id: 3,
-            tag_id: 4,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 38,
-            profile_id: 32,
-            grouping_id: 3,
-            tag_id: 5,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 39,
-            profile_id: 33,
-            grouping_id: 3,
-            tag_id: 5,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 40,
-            profile_id: 34,
-            grouping_id: 4,
-            tag_id: 7,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 41,
-            profile_id: 35,
-            grouping_id: 4,
-            tag_id: 8,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 42,
-            profile_id: 36,
-            grouping_id: 1,
-            tag_id: 1,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 43,
-            profile_id: 37,
-            grouping_id: 1,
-            tag_id: 2,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 44,
-            profile_id: 38,
-            grouping_id: null,
-            tag_id: 2,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 45,
-            profile_id: 39,
-            grouping_id: null,
-            tag_id: 6,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 46,
-            profile_id: 40,
-            grouping_id: null,
-            tag_id: 5,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 47,
-            profile_id: 41,
-            grouping_id: null,
-            tag_id: 6,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 48,
-            profile_id: 42,
-            grouping_id: 1,
-            tag_id: 8,
-            is_deleted: false,
-        },
-        {
-            tag_association_id: 49,
-            profile_id: 43,
-            grouping_id: 1,
-            tag_id: 7,
-            is_deleted: false,
-        },
-        // NOTE: profile_id 147 is chosen based off of GENERATED data,
-        // after running 'npm run generate', replace 147 in mock to next profile_id to be genearted
-        // i.e. last profile_id number + 1
-        // TODO: remove from mock data once bare bones matching logic can show poorly matched matches...
-        {
-            tag_association_id: 50,
-            profile_id: 139,
-            grouping_id: 2,
-            tag_id: 7,
-            is_deleted: false,
-        },
-    ],
-    response_keys: [
-        {
-            response_key_id: 1,
-            response_key_category: 'visionary_vs_implementer',
-            response_key_prompt:
-                'Do you prefer to work with those who are driven by their Visionary insights, or those who are driven more by their Implementation?',
-            response_key_description: 'first round draft scoring question',
-            aspect: 'visionary_vs_implementer',
-            category: 'aspect',
-            placeholder: null,
-            invalidInputPrompt: null,
-        },
-        {
-            response_key_id: 2,
-            response_key_category: 'creative_vs_methodical',
-            response_key_prompt:
-                'Have you found more success working with employees that are more Creative or those that are more Methodical?',
-            response_key_description: 'first round draft scoring question',
-            aspect: 'creative_vs_methodical',
-            category: 'aspect',
-            placeholder: null,
-            invalidInputPrompt: null,
-        },
-        {
-            response_key_id: 3,
-            response_key_category: 'dynamic_vs_ordered',
-            response_key_prompt:
-                'Which do you find to be the ideal working environment, one that is more Collaborative or one that is more Independent?',
-            response_key_description: 'first round draft scoring question',
-            aspect: 'dynamic_vs_ordered',
-            category: 'aspect',
-            placeholder: null,
-            invalidInputPrompt: null,
-        },
-        {
-            response_key_id: 4,
-            response_key_category: 'precise_vs_resourceful',
-            response_key_prompt:
-                'Is the success of your team more likely if it includes individuals who are more Innovative, or those that are more Conventional when fulfilling their job duties?',
-            response_key_description: 'first round draft scoring question',
-            aspect: 'precise_vs_resourceful',
-            category: 'aspect',
-            placeholder: null,
-            invalidInputPrompt: null,
-        },
-        {
-            response_key_id: 5,
-            response_key_category: 'big_Picture_vs_focused',
-            response_key_prompt:
-                'When fulfilling the role of the hiring leader, do you find yourself focusing more on the Big Picture or The Task At Hand?',
-            response_key_description: 'first round draft scoring question',
-            aspect: 'big_Picture_vs_focused',
-            category: 'aspect',
-            placeholder: null,
-            invalidInputPrompt: null,
-        },
-        {
-            response_key_id: 6,
-            response_key_category: 'guided_vs_self-managed',
-            response_key_prompt:
-                'Do you prefer to Guide your employees towards achieving the team goals, or do you prefer your employees to be Self-Managed?',
-            response_key_description: 'first round draft scoring question',
-            aspect: 'guided_vs_self-managed',
-            category: 'aspect',
-            placeholder: null,
-            invalidInputPrompt: null,
-        },
-        {
-            response_key_id: 7,
-            response_key_category: 'profile',
-            response_key_prompt:
-                'First things first, could you provide us with your name? [break] I am called [break] when others address me.',
-            response_key_description: 'required for profile creation',
-            aspect: null,
-            category: 'input',
-            placeholder: 'Joe Doe',
-            invalidInputPrompt: 'So sorry, but what is your name?',
-        },
-        {
-            response_key_id: 8,
-            response_key_category: 'profile',
-            response_key_prompt:
-                'In order for others to reach out to you on Siimee, we will need you to provide your email address.[break]When reaching out to me, [break] is my preferred email.',
-            response_key_description: 'required for profile creation',
-            aspect: null,
-            category: 'input',
-            placeholder: 'joe@mailme.com',
-            invalidInputPrompt:
-                'It looks like that email is not valid, try en email that is formatted like so: joe@joe.com',
-        },
-        {
-            response_key_id: 9,
-            response_key_category: 'profile',
-            response_key_prompt:
-                'So far so good! Next we will need you to establish a super secret password. Your password should be at least 14 characters long and have at least 2 special characters.[break]My [break] is a very secure passcode that only I will have access to!',
-            response_key_description: 'required for profile creation',
-            aspect: null,
-            category: 'input',
-            placeholder: 'supersecr3tp@ssword',
-            invalidInputPrompt:
-                'That password does not fit our requirements, please follow the above instructions to generate a secure password.',
-        },
-        {
-            response_key_id: 10,
-            response_key_category: 'profile',
-            response_key_prompt:
-                'Looking good! Doing great. The next piece of info needed is your zip code. That way we can be sure to only show you other people in your area.[break]My zip code, [break] is the general area where I wish to see results in.',
-            response_key_description: 'required for distance calculations',
-            aspect: null,
-            category: 'input',
-            placeholder: '90012',
-            invalidInputPrompt:
-                'Oops! That is not a recognized zipcode, please enter a 5 digit zipcode like: 97869',
-        },
-        {
-            response_key_id: 11,
-            response_key_category: 'profile',
-            response_key_prompt:
-                'What are you seeking? Are you looking to find a position to be employed in, or are you looking to employ a candidate?[break] I am a [break] seeking an employer/employee.',
-            response_key_description: 'required for profile generation',
-            aspect: null,
-            category: 'choice',
-            placeholder: null,
-            invalidInputPrompt:
-                'In order to provide you with the best results, Siimee will need to know whether you are an employer looking to fill a position, or a candidate looking for an employment. Please take a look at our above options and choose one.',
-        },
-        {
-            response_key_id: 12,
-            response_key_category: 'profile',
-            response_key_prompt:
-                'Hey, you are almost done! Please provide an image of yourself so others can recognize you if you ever meet up IRL:',
-            response_key_description: 'required for profile pictures',
-            aspect: null,
-            category: 'input',
-            placeholder: null,
-            invalidInputPrompt:
-                'It appears you have yet to upload an image. Please provide Siimee with an image in case you want to show others what you look like.',
-        },
-        {
-            response_key_id: 13,
-            response_key_category: 'profile',
-            response_key_prompt:
-                'What language is your native language?[break] I consider [break] language as my native language.',
-            response_key_description:
-                'programming and spoken language preference',
-            aspect: null,
-            category: 'choice',
-            placeholder: null,
-            invalidInputPrompt:
-                'We try our best to provide results in the language of your choosing. ¿Prefieres ver resultados en español? Ou peut-être parlez-vous français? Or would you prefer to see results in english?',
-        },
-        {
-            response_key_id: 14,
-            response_key_category: 'profile',
-            response_key_prompt:
-                'What kind of duration would you prefer? Are you looking for part-time, full-time, other?[break] Currently, I am looking for a [break] job at this time.',
-            response_key_description:
-                'duration preference for hours able to dedicate to work',
-            aspect: null,
-            category: 'choice',
-            placeholder: null,
-            invalidInputPrompt:
-                'Looks like you have yet to  fill out what kind of work you are most interested in. As in, part-time, full-time. Take a look at our above options and choose whatever feels right for you right now. You can always edit them later!',
-        },
-        {
-            response_key_id: 15,
-            response_key_category: 'profile',
-            response_key_prompt:
-                'Would you prefer remote, hybrid, in-person work?[break] Personally I would prefer a [break] job right now. It is just what works best for me.',
-            response_key_description:
-                'location preference for where work happens',
-            aspect: null,
-            category: 'choice',
-            placeholder: null,
-            invalidInputPrompt:
-                'Hold up! So sorry to put a pause here, but it looks like you have not chosen whether to work remotely or in person. No worries, if you are unsure, just choose the flexible option.',
-        },
-        {
-            response_key_id: 16,
-            response_key_category: 'profile',
-            response_key_prompt:
-                'Please provide us with a short blurb about yourself. What is your backstory?[break] My origin story starts like this:[break]',
-            response_key_description: 'required for profile description',
-            aspect: null,
-            category: 'input',
-            placeholder: 'my backstory starts long long ago...',
-            invalidInputPrompt:
-                'Whoa! Cool story. Unfortunately your backstory is either too long or too short. Please tell us a bit about yourself between 1 and 100 characters.',
-        },
-        {
-            response_key_id: 17,
-            response_key_category: 'profile',
-            response_key_prompt:
-                'How soon do you need the position filled or you need to be employed? [break]I am currently [break] when it comes to employment opportunities right now.',
-            response_key_description: 'urgency for when work is required',
-            aspect: null,
-            category: 'choice',
-            placeholder: null,
-            invalidInputPrompt:
-                'Looks like you left this field blank. Take a look at our provided options and tell us when you would like be employed.',
-        },
-        {
-            response_key_id: 18,
-            response_key_category: 'profile',
-            response_key_prompt:
-                'When others refer to you, what pronouns do you prefer they use?[break]I prefer to be called [break] when others refer to me.',
-            response_key_description: 'required for profile pronouns',
-            aspect: null,
-            category: 'choice',
-            placeholder: null,
-            invalidInputPrompt:
-                'Ensuring that others on our platform are aware of what your preferred pronouns are is important to us. Please choose from one of the above options.',
-        },
-        {
-            response_key_id: 19,
-            response_key_category: 'profile',
-            response_key_prompt:
-                'What distance from your home are you looking to work in?[break] Preferably, I would like to work [break] from my place of residence.',
-            response_key_description:
-                'preference for commuting distance cutoff',
-            aspect: null,
-            category: 'input',
-            placeholder: '5 mi',
-            invalidInputPrompt:
-                'Whoa! You either left this field blank or tried to input an astronomically large distance you would like to see results from. Please input a distance you would like to see results in.',
-        },
-    ],
-    responses: [],
-    memberships: [
-        {
-            membership_id: 1,
-            profile_id: 41,
-            grouping_id: 1,
-            membership_type: 'participant',
-            can_edit: false,
-            is_active: true,
-        },
-        {
-            membership_id: 2,
-            profile_id: 46,
-            grouping_id: 1,
-            membership_type: 'participant',
-            can_edit: false,
-            is_active: true,
-        },
-        {
-            membership_id: 4,
-            profile_id: 46,
-            grouping_id: 2,
-            membership_type: 'participant',
-            can_edit: false,
-            is_active: true,
-        },
-    ],
-    groupings: [
-        {
-            grouping_id: 1,
-            grouping_name: '1663285820.067_41_46',
-            grouping_type: 'match',
-        },
-        {
-            grouping_id: 2,
-            grouping_name: '1663285820.067_147_46',
-            grouping_type: 'match',
-        },
-    ],
-    messages: [],
-    match_queues: [
-        { 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: 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 },
-        {
-            match_queue_id: 10,
-            profile_id: 46,
-            target_id: 41,
-            is_deleted: false,
-        },
-        {
-            match_queue_id: 11,
-            profile_id: 46,
-            target_id: 40,
-            is_deleted: false,
-        },
-        {
-            match_queue_id: 12,
-            profile_id: 40,
-            target_id: 46,
-            is_deleted: false,
-        },
-        {
-            match_queue_id: 13,
-            profile_id: 41,
-            target_id: 46,
-            is_deleted: false,
-        },
-        {
-            match_queue_id: 14,
-            profile_id: 42,
-            target_id: 46,
-            is_deleted: false,
-        },
-        {
-            match_queue_id: 15,
-            profile_id: 43,
-            target_id: 46,
-            is_deleted: false,
-        },
-        {
-            match_queue_id: 16,
-            profile_id: 44,
-            target_id: 46,
-            is_deleted: false,
-        },
-    ],
-}

backend/db/data-generator/random.js

@@ -1,109 +0,0 @@
-const lipsum = require('./lorem')
-
-const randomNumber = max => {
-    return Math.floor(Math.random() * max) < 1
-        ? 1
-        : Math.floor(Math.random() * max)
-}
-const randomValFrom = arr => arr[randomNumber(arr.length)]
-const randomEmail = (length = 5) => {
-    let chars =
-        'abcdefghijklmnopqrstuvwxyz-_abcdefghijklmnopqrstuvwxyz0123456789'
-    let str = ''
-    for (let i = 0; i < length + randomNumber(9); i++) {
-        str += chars.charAt(Math.floor(Math.random() * chars.length))
-    }
-    const suffixs = [
-        '@gmail.com',
-        '@aol.com',
-        '@yahoo.com',
-        '@apple.com',
-        '@hotmail.com',
-        '@rocket-mail.com',
-        '@mail.com',
-    ]
-    return str + randomValFrom(suffixs)
-}
-const randomName = (length = 4) => {
-    let chars = 'aeiouaeiouabcdefghijklmnoprstuvwyabcdefghijklmnopqrstuvwxyz'
-    let str = ''
-    for (let i = 0; i < length + randomNumber(9); i++) {
-        str += chars.charAt(Math.floor(Math.random() * chars.length))
-    }
-    return str
-}
-const randomMedia = () => {
-    const stockimg = [
-        'https://i.imgur.com/a4wirDS.png',
-        'https://i.imgur.com/F6GxGXG.jpeg',
-        'https://i.imgur.com/ekrkdNt.jpeg',
-        'https://i.imgur.com/VtMTfDg.jpeg',
-        'https://i.imgur.com/9Fwouqm.jpeg',
-        'https://i.imgur.com/rOjRCgo.jpeg',
-        'https://i.imgur.com/FwSdQww.jpeg',
-        'https://i.imgur.com/JjZyzXL.jpeg',
-        'https://i.imgur.com/1DsSQ1s.jpeg',
-    ]
-    return randomValFrom(stockimg)
-}
-
-const randomLang = () => {
-    const langs = [
-        'javascript',
-        'python',
-        'ruby',
-        'erlang',
-        'haskall',
-        'php',
-        'swift',
-        'rust',
-        'objective-c',
-        'common lisp',
-        'java',
-        'perl',
-        'cobol',
-        'fortran',
-        'julia',
-        'c#',
-        'go',
-        'c++',
-    ]
-    return randomValFrom(langs)
-}
-
-const randomDuration = () => {
-    const duration = ['full', 'part']
-    return randomValFrom(duration)
-}
-
-const randomLocation = () => {
-    const location = ['onsite', 'remote', 'flexible']
-    return randomValFrom(location)
-}
-
-const randomBlurb = () => {
-    const l = new lipsum.LoremIpsum()
-    return l.generate(randomNumber(50))
-}
-
-
-module.exports = {
-    randomNumber,
-    randomValFrom,
-    randomEmail,
-    randomName,
-    randomMedia,
-    randomLang,
-    randomDuration,
-    randomLocation,
-    randomBlurb,
-    number: randomNumber,
-    valFrom: randomValFrom,
-    email: randomEmail,
-    name: randomName,
-    media: randomMedia,
-    language: randomLang,
-    duration: randomDuration,
-    location: randomLocation,
-    blurb: randomBlurb
-}

backend/db/dataSort.js

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

backend/db/knex.js

@@ -1,3 +1,3 @@
 const environment = process.env.NODE_ENV || 'development'
 const config = require('../knexfile')[environment]
-module.exports = require('knex')(config)
+module.exports = require('knex')(config)

backend/db/migrations/20210527173933_create_profiles_table.js

@@ -1,10 +0,0 @@
-exports.up = function (knex) {
-    return knex.schema.createTable('profiles', function (table) {
-        table.increments('profile_id').primary()
-        table.integer('user_id').notNullable()
-    })
-}
-
-exports.down = function (knex) {
-    return knex.schema.dropTable('profiles')
-}

backend/db/migrations/20210527174416_create_response_keys_table.js

@@ -1,16 +0,0 @@
-exports.up = function (knex) {
-    return knex.schema.createTable('response_keys', function (table) {
-        table.increments('response_key_id').primary()
-        table.string('response_key_category').notNullable()
-        table.string('response_key_prompt')
-        table.string('response_key_description')
-        table.string('aspect')
-        table.string('category')
-        table.string('placeholder')
-        table.string('invalidInputPrompt')
-    })
-}
-
-exports.down = function (knex) {
-    return knex.schema.dropTable('response_keys')
-}

backend/db/migrations/20210527174422_create_responses_table.js

@@ -1,12 +0,0 @@
-exports.up = function (knex) {
-    return knex.schema.createTable('responses', function (table) {
-        table.increments('response_id').primary()
-        table.integer('profile_id').notNullable()
-        table.integer('response_key_id').notNullable()
-        table.specificType('val', 'VARCHAR(1000)')
-    })
-}
-
-exports.down = function (knex) {
-    return knex.schema.dropTable('responses')
-}

backend/db/migrations/20210527174434_create_groupings_table.js

@@ -1,11 +0,0 @@
-exports.up = function (knex) {
-    return knex.schema.createTable('groupings', function (table) {
-        table.increments('grouping_id').primary()
-        table.string('grouping_name', 128).notNullable()
-        table.string('grouping_type', 128).notNullable() // Don't over normalize
-    })
-}
-
-exports.down = function (knex) {
-    return knex.schema.dropTable('groupings')
-}

backend/db/migrations/20210527174440_create_memberships_table.js

@@ -1,14 +0,0 @@
-exports.up = function (knex) {
-    return knex.schema.createTable('memberships', function (table) {
-        table.increments('membership_id').primary()
-        table.integer('profile_id').notNullable() // From
-        table.integer('grouping_id').notNullable() // To
-        table.string('membership_type', 128).notNullable() // Don't over normalize
-        table.boolean('can_edit').notNullable()
-        table.boolean('is_active').notNullable()
-    })
-}
-
-exports.down = function (knex) {
-    return knex.schema.dropTable('memberships')
-}

backend/db/migrations/20210527174448_create_messages_table.js

@@ -1,12 +0,0 @@
-exports.up = function (knex) {
-    return knex.schema.createTable('messages', function (table) {
-        table.increments('message_id').primary()
-        table.integer('user_id').notNullable()
-        table.integer('grouping_id').notNullable()
-        table.string('message', 255).notNullable()
-    })
-}
-
-exports.down = function (knex) {
-    return knex.schema.dropTable('messages')
-}

backend/db/migrations/20210929163630_zipcodes.js

@@ -1,14 +0,0 @@
-exports.up = function (knex) {
-    return knex.schema.createTable('zip_codes', function (table) {
-        table.integer('zip_code_id').primary()
-        table.string('latitude', 16).notNullable()
-        table.string('longitude', 16).notNullable()
-        table.string('city', 128).notNullable()
-        table.string('state', 16).notNullable()
-        table.string('county', 128).notNullable()
-    })
-}
-
-exports.down = function (knex) {
-    return knex.schema.dropTable('zip_codes')
-}

backend/db/migrations/20211003195015_create_match_queues_table.js

@@ -1,12 +0,0 @@
-exports.up = function (knex) {
-    return knex.schema.createTable('match_queues', function (table) {
-        table.increments('match_queue_id').primary()
-        table.integer('profile_id').notNullable()
-        table.integer('target_id').notNullable()
-        table.boolean('is_deleted').notNullable()
-    })
-}
-
-exports.down = function (knex) {
-    return knex.schema.dropTable('match_queues')
-}

backend/db/migrations/20220313230903_create_scores_table.js

@@ -1,16 +0,0 @@
-const matrix = require('../generated/prescore_matrix.json')
-
-exports.up = function (knex) {
-    return knex.schema.createTable('prescored_aspects', function (table) {
-        table.integer('aspect_id').primary()
-        const firstRow = Object.keys(matrix)[0]
-        colVals = matrix[firstRow]
-        colVals.forEach((col, i) => {
-            table.smallint(`${i + 1}`).notNullable()
-        })
-    })
-}
-
-exports.down = function (knex) {
-    return knex.schema.dropTable('prescored_aspects')
-}

backend/db/migrations/20220313233557_create_aspects_table.js

@@ -1,13 +0,0 @@
-const matrix = require('../generated/prescore_matrix.json')
-
-exports.up = function (knex) {
-    return knex.schema.createTable('aspect_labels', function (table) {
-        table.integer('aspect_id').primary()
-        table.smallint('a').notNullable()
-        table.smallint('b').notNullable()
-    })
-}
-
-exports.down = function (knex) {
-    return knex.schema.dropTable('aspect_labels')
-}

backend/db/migrations/20220403111017_create_tag_descriptions_table.js

@@ -1,12 +0,0 @@
-exports.up = function (knex) {
-    return knex.schema.createTable('tags', function (table) {
-        table.increments('tag_id').primary()
-        table.string('tag_category', 128).notNullable() // Don't over normalize
-        table.string('tag_description', 128).notNullable() // Don't over normalize
-        table.boolean('is_active').notNullable()
-    })
-}
-
-exports.down = function (knex) {
-    return knex.schema.dropTable('tags')
-}

backend/db/migrations/20220403111037_create_tag_associations_table.js

@@ -1,13 +0,0 @@
-exports.up = function (knex) {
-    return knex.schema.createTable('tag_associations', function (table) {
-        table.increments('tag_association_id').primary()
-        table.integer('profile_id').notNullable()
-        table.integer('grouping_id')
-        table.integer('tag_id').notNullable()
-        table.boolean('is_deleted').notNullable()
-    })
-}
-
-exports.down = function (knex) {
-    return knex.schema.dropTable('tag_associations')
-}

backend/db/migrations/20220403111101_create_user_passwords_table.js

@@ -1,13 +0,0 @@
-exports.up = function (knex) {
-    return knex.schema.createTable('user_identities', function (table) {
-        table.increments('user_pw_id').primary()
-        table.integer('user_id').notNullable()
-        table.string('uname', 16)
-        table.string('pw', 16)
-        table.boolean('is_deleted').notNullable()
-    })
-}
-
-exports.down = function (knex) {
-    return knex.schema.dropTable('user_identities')
-}

backend/db/migrations/20220403112041_create_blocked_profiles_table.js

@@ -1,12 +0,0 @@
-exports.up = function (knex) {
-    return knex.schema.createTable('blocked_associations', function (table) {
-        table.increments('block_id').primary()
-        table.integer('profile_id').notNullable()
-        table.integer('profile_id_to_block').notNullable()
-        table.boolean('is_active').notNullable()
-    })
-}
-
-exports.down = function (knex) {
-    return knex.schema.dropTable('blocked_associations')
-}

backend/db/migrations/20220901171733_user_authentication.js

@@ -1,12 +0,0 @@
-exports.up = function (knex) {
-    return knex.schema.createTable('authentication', function (table) {
-        table.string('user_email', 90).primary().unique()
-        table.date('created_at').notNullable()
-        // table.char('token').notNullable()
-        table.binary('token')
-    })
-}
-
-exports.down = function (knex) {
-    return knex.schema.dropTable('authentication')
-}

backend/db/seeds/01-users.js

@@ -1,30 +0,0 @@
-const mock = require('../data-generator/mock')
-const fs = require('fs')
-const dataSort = require ('../dataSort')
-const { batchSize } = require('../data-generator/config.json')
-
-let users = []
-const generatedDataPath = './db/generated'
-let fileNames = fs.readdirSync(generatedDataPath)
-for (let name of fileNames) {
-    const data = require(`../generated/${name}`)
-    if(name[0] == '_') {
-        users = [...users, ...data.users]
-    }
-}
-// sort data
-users = dataSort(users, 'user_id')
-
-exports.seed = async knex => {
-    await knex('users').del()
-    let usersToPush = []
-    let len = users.length
-    for (let i = 1; i <= len; i += 1) {
-        usersToPush.push(users.shift())
-        if (i % batchSize === 0) {
-            await knex('users').insert(usersToPush)
-            usersToPush = []
-        }
-        
-    }
-}

backend/db/seeds/02-profiles.js

@@ -1,31 +0,0 @@
-const mock = require('../data-generator/mock')
-const fs = require('fs')
-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] == '_') {
-        profiles = [...profiles, ...data.profiles]
-    }
-}
-
-profiles = dataSort(profiles, 'profile_id').filter(
-    profile => !ignore.includes(profile.profile_id),
-)
-
-exports.seed = async knex => {
-    await knex('profiles').del()
-    let profilesToPush = []
-    let len = profiles.length
-    for (let i = 1; i <= len; i += 1) {
-        profilesToPush.push(profiles.shift())
-        if (i % batchSize === 0 || i > profiles.length) {
-            await knex('profiles').insert(profilesToPush)
-            profilesToPush = []
-        }
-    }
-}

backend/db/seeds/03-response_keys.js

@@ -1,24 +0,0 @@
-const mock = require('../data-generator/mock')
-const fs = require('fs')
-
-let response_keys = []
-const generatedDataPath = './db/generated'
-let fileNames = fs.readdirSync(generatedDataPath)
-for (let name of fileNames) {
-    const data = require(`../generated/${name}`)
-    if(name[0] == '_' && data?.response_keys) {
-        response_keys = [...response_keys, ...data.response_keys]
-    }
-}
-
-exports.seed = function (knex) {
-    // Deletes ALL existing entries
-    return knex('response_keys')
-        .truncate()
-        .then(function () {
-            // Inserts seed entries
-            return response_keys.length > 0
-                ? knex('response_keys').insert(response_keys)
-                : knex('response_keys').insert(mock.response_keys)
-        })
-}

backend/db/seeds/04-responses.js

@@ -1,35 +0,0 @@
-const mock = require('../data-generator/mock')
-const fs = require('fs')
-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] == '_') {
-        responses = [...responses, ...data.responses]
-    }
-}
-/**
- * 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()
-    let responsesToPush = []
-    const len = responses.length
-    for (let i = 1; i <= len; i += 1) {
-        responsesToPush.push(responses.shift())
-        // if (i % batchSize === 0 || i > responses.length) {
-        // await knex('responses').insert(responsesToPush)
-        // responsesToPush = []
-        // }
-    }
-    await knex('responses').insert(responsesToPush)
-}

backend/db/seeds/05-memberships.js

@@ -1,11 +0,0 @@
-const mock = require('../data-generator/mock')
-
-exports.seed = function (knex) {
-    // Deletes ALL existing entries
-    return knex('memberships')
-        .truncate()
-        .then(function () {
-            // Inserts seed entries
-            return knex('memberships').insert(mock.memberships)
-        })
-}

backend/db/seeds/06-groupings.js

@@ -1,11 +0,0 @@
-const mock = require('../data-generator/mock')
-
-exports.seed = function (knex) {
-    // Deletes ALL existing entries
-    return knex('groupings')
-        .truncate()
-        .then(function () {
-            // Inserts seed entries
-            return knex('groupings').insert(mock.groupings)
-        })
-}

backend/db/seeds/07-messages.js

@@ -1,11 +0,0 @@
-const mock = require('../data-generator/mock')
-
-exports.seed = function (knex) {
-    // Deletes ALL existing entries
-    return knex('messages')
-        .truncate()
-        .then(function () {
-            // Inserts seed entries
-            return knex('messages').insert(mock.messages)
-        })
-}

backend/db/seeds/08-zipcodes.js

@@ -1,11 +0,0 @@
-const zips = require('../zipcodes')
-
-exports.seed = function (knex) {
-    // Deletes ALL existing entries
-    return knex('zip_codes')
-        .truncate()
-        .then(function () {
-            // Inserts seed entries
-            return knex('zip_codes').insert(zips)
-        })
-}

backend/db/seeds/09-match_queues.js

@@ -1,10 +0,0 @@
-const mock = require('../data-generator/mock')
-exports.seed = function (knex) {
-    // Deletes ALL existing entries
-    return knex('match_queues')
-        .truncate()
-        .then(function () {
-            // Inserts seed entries
-            return knex('match_queues').insert(mock.match_queues)
-        })
-}

backend/db/seeds/10-scores.js

@@ -1,29 +0,0 @@
-const aspects = require('../generated/prescore_matrix.json')
-
-exports.seed = function (knex) {
-    // Deletes ALL existing entries
-    return knex('prescored_aspects')
-        .truncate()
-        .then(function () {
-            let rowCount = 1
-            const makeRow = scores => {
-                scoreMap = {}
-                scores.forEach((score, i) => {
-                    scoreMap['aspect_id'] = rowCount
-                    scoreMap[i + 1] = score
-                })
-                return scoreMap
-            }
-            
-            const rows = []
-            Object.values(aspects).forEach(rowOfScores => {
-                if(Array.isArray(rowOfScores)) {
-                    const row = makeRow(rowOfScores)
-                    rows.push(row)
-                    rowCount++
-                }
-            })
-            // Inserts seed entries
-            return knex('prescored_aspects').insert(rows)
-        })
-}

backend/db/seeds/11-aspects.js

@@ -1,25 +0,0 @@
-const aspects = require('../generated/prescore_matrix.json')
-
-exports.seed = function (knex) {
-    // Deletes ALL existing entries
-    return knex('aspect_labels')
-        .truncate()
-        .then(function () {
-            let rowCount = 1
-            const rows = []
-            Object.keys(aspects).forEach(label => {
-                if(label != '_config') {
-                    const row = {
-                        aspect_id: rowCount
-                    }
-                    const ab = label.split('-')
-                    row.a = parseInt(ab[0])
-                    row.b = parseInt(ab[1])
-                    rows.push(row)
-                    rowCount++
-                }
-            })
-            // Inserts seed entries
-            return knex('aspect_labels').insert(rows)
-        })
-}

backend/db/seeds/12-tags.js

@@ -1,11 +0,0 @@
-const mock = require('../data-generator/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

@@ -1,11 +0,0 @@
-const mock = require('../data-generator/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/db/survey-generator.js

@@ -1,265 +0,0 @@
-const fs = require('fs')
-const similarity = require('compute-cosine-similarity')
-const config = require('./data-generator/config.js')
-
-const magic = config.magic // Multiply cosine similary by this
-
-const not_important = config.scoreVals[0]
-const somewhat_important = config.scoreVals[1]
-const important = config.scoreVals[2]
-const very_important = config.scoreVals[3]
-const extremely_important = config.scoreVals[4]
-const mandatory = config.scoreVals[5]
-
-// -
-// 1440 - 2400 total range
-// 1440 - 1900 limited range
-// -
-// Reserved for REALLY important answers
-// like full-time vs part-time
-// and remote vs onsite only
-// 400 mandatory
-
-const importance = [
-    not_important,
-    somewhat_important,
-    important,
-    very_important,
-    extremely_important,
-]
-
-const langs = [
-    'javascript',
-    'python',
-    'ruby',
-    'erlang',
-    'haskall',
-    'php',
-    'swift',
-    'rust',
-    'objective-c',
-    'common lisp',
-    'java',
-    'perl',
-    'cobol',
-    'fortran',
-    'julia',
-    'c#',
-    'go',
-    'c++',
-]
-const duration = ['full', 'part']
-const location = ['onsite', 'remote', 'flexible']
-
-const otherWeightLookup = {
-    full: mandatory,
-    part: mandatory,
-    onsite: mandatory,
-    remote: mandatory,
-    flexible: mandatory,
-}
-const rand = max => {
-    return Math.floor(Math.random() * max) < 1
-        ? 1
-        : Math.floor(Math.random() * max)
-}
-
-class DummyProfile {
-    constructor() {
-        this.id = null
-        this.profileResponses = null
-        this.langPref = null
-        this.durationPref = null
-        this.locationPref = null
-
-        this.shouldDelete = false
-
-        // profile is constructed of 12 answers, 2 for each dimension
-        this.profileResponses = this.getRandomAnswers(12, importance)
-        this.langPref = this.getRandomAnswers(rand(4), langs)
-        this.durationPref = this.getRandomAnswers(1, duration)
-        this.locationPref = this.getRandomAnswers(1, location)
-
-        this.matchPref = null
-
-        this.candidateIndex = 0
-        this.otp = null
-        this.forder = []
-    }
-    clearPlaceholderMatches() {
-        this.matchPref = this.matchPref.filter(
-            match => match.shouldDelete == false,
-        )
-        this.forder = this.forder.filter(
-            potentialFiance => potentialFiance.shouldDelete == false,
-        )
-        if (this.otp.shouldDelete) {
-            this.otp = null
-        }
-        // console.log(this.matchPref)
-    }
-    rank(p) {
-        for (let i = 0; i < this.matchPref.length; i++)
-            if (this.matchPref[i] === p) return i
-        return this.matchPref.length + 1
-    }
-    prefers(p) {
-        return this.rank(p) < this.rank(this.otp)
-    }
-    nextCandidate() {
-        if (this.candidateIndex >= this.matchPref.length) return null
-        return this.matchPref[this.candidateIndex++]
-    }
-    engageTo(p) {
-        if (p.otp) p.otp.otp = null
-        p.otp = this
-        p.forder.unshift(this)
-        if (this.otp) this.otp.otp = null
-        this.otp = p
-        this.forder.unshift(p)
-    }
-    // My stuff
-    getRandomAnswers(count, options) {
-        const answers = []
-        for (let i = 0; i < count; i++) {
-            const random = rand(options.length)
-            answers.push(options[random])
-        }
-        return answers
-    }
-}
-
-function engageEveryone(guys) {
-    var done
-    do {
-        done = true
-        guys.forEach(guy => {
-            if (!guy.otp) {
-                done = false
-                const gal = guy.nextCandidate()
-                if (!gal.otp || gal.prefers(guy)) guy.engageTo(gal)
-            }
-        })
-    } while (!done)
-}
-const generateDummyProfiles = (count, startFrom) => {
-    const profiles = []
-    for (let i = 0; i < count; i++) {
-        const dummyProfile = new DummyProfile()
-        dummyProfile.id = startFrom + i + 1
-        profiles.push(dummyProfile)
-    }
-    profiles.forEach(dummy => {
-        dummy.profileResponses = dummy.profileResponses.map(
-            (answer, response_key_id) => {
-                const answerObj = {}
-                // aka: id for the question we asked
-                answerObj[response_key_id] = answer
-                return answerObj
-            },
-        )
-    })
-    return profiles
-}
-
-const generatedSeekers = generateDummyProfiles(20, 0)
-const generatedProviders = generateDummyProfiles(5, generatedSeekers.length)
-const balanceSeekersAndProviders = (seekers, providers) => {
-    let diff = 0
-    let smallerList = null
-
-    if (seekers.length < providers.length) {
-        diff = providers.length - seekers.length
-        smallerList = seekers
-    } else {
-        diff = seekers.length - providers.length
-        smallerList = providers
-    }
-    let fillerId = seekers.length + providers.length
-    for (let i = 0; i < diff; i++) {
-        const filler = new DummyProfile()
-        filler.id = fillerId + i + 1
-        filler.profileResponses = filler.profileResponses.map(
-            (answer, response_key_id) => {
-                const answerObj = {}
-                // aka: id for the question we asked
-                answerObj[response_key_id] = answer
-                return answerObj
-            },
-        )
-        filler.shouldDelete = true
-        smallerList.push(filler)
-    }
-}
-
-const scoreMatch = (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,
-    )
-}
-const compareProfile = (seeker, unorderedPotentialMatches) => {
-    const scored = unorderedPotentialMatches
-        .map(potentialMatch => {
-            // add the match to object keyed by score
-            return {
-                profileMatchScore: scoreMatch(seeker, potentialMatch),
-                profile: potentialMatch,
-            }
-        })
-        .sort((a, b) => a.profileMatchScore - b.profileMatchScore)
-    // return ordered by score
-    return scored.map(profileScore => profileScore.profile)
-}
-
-balanceSeekersAndProviders(generatedSeekers, generatedProviders)
-
-// Score
-generatedSeekers.forEach(seeker => {
-    seeker.matchPref = compareProfile(seeker, generatedProviders)
-})
-generatedProviders.forEach(provider => {
-    provider.matchPref = compareProfile(provider, generatedSeekers)
-})
-
-// Everything balanced ready for stable marriage
-if (generatedSeekers.length == generatedProviders.length) {
-    engageEveryone(generatedProviders)
-    generatedSeekers.forEach(seeker => seeker.clearPlaceholderMatches())
-    generatedProviders.forEach(provider => provider.clearPlaceholderMatches())
-
-    console.log('\nuser:', generatedProviders[0].id, '| provider')
-    console.log(
-        'otp',
-        generatedProviders[0].otp ? generatedProviders[0].otp.id : null,
-        'rank',
-        generatedProviders[0].otp
-            ? generatedProviders[0].matchPref
-                  .map(m => m.id)
-                  .indexOf(generatedProviders[0].otp.id) + 1
-            : generatedProviders[0].otp,
-    )
-    // console.log(generatedProviders[0].matchPref.map(m => m.id))
-    console.log(generatedProviders[0])
-
-    console.log('---')
-
-    console.log('user:', generatedSeekers[0].id, '| seeker')
-    console.log(
-        'otp',
-        generatedSeekers[0].otp ? generatedSeekers[0].otp.id : null,
-        'rank',
-        generatedSeekers[0].otp
-            ? generatedSeekers[0].matchPref
-                  .map(m => m.id)
-                  .indexOf(generatedSeekers[0].otp.id) + 1
-            : generatedSeekers[0].otp,
-    )
-    console.log(generatedSeekers[0])
-    // console.log(generatedSeekers[0].matchPref.map(m => m.id))
-}

backend/lib/auth/strategies/jwt.js

@@ -1,73 +0,0 @@
-'use strict'
-const JWT = require('jsonwebtoken')
-const crypto = require('crypto')
-
-const hashToken = async token => {
-    const salt = process.env.APP_SESSION_SALT
-    try {
-        return crypto.createHmac('sha256', salt).update(token).digest('hex')
-    } catch (err) {
-        throw new Error(err.message)
-    }
-}
-
-const createToken = (data, expiration = 600) => {
-    const key = process.env.APP_SECRET
-    const obj = {}
-
-    Object.assign(obj, { ...data })
-    return JWT.sign(obj, key, { expiresIn: expiration })
-}
-
-const validateToken = token => {
-    const key = process.env.APP_SECRET
-    try {
-        return JWT.verify(token, key)
-    } catch (err) {
-        return { payload: null, message: err.message }
-    }
-}
-
-module.exports = options => {
-    return {
-        key: options.jwtKey,
-        verifyOptions: {
-            algorithms: ['HS256'],
-        },
-        // TODO: Naming conventions need to be reversed again??
-        validate: async (decoded, request, h) => {
-            const sessionTokenFromHeaders = request.headers.authorization
-            const hashedSessionTokenFromHeaders = await hashToken(
-                sessionTokenFromHeaders,
-            )
-            const activeSession =
-                request.server.app.activeSessions[hashedSessionTokenFromHeaders]
-            if (!activeSession)
-                throw new Error(
-                    `No session found for ${hashedSessionTokenFromHeaders}`,
-                )
-
-            const sessionToken = activeSession.sessionToken
-            const accessToken = activeSession.accessToken
-            const validatedSessionToken = validateToken(sessionToken)
-            const validatedAccessToken = validateToken(accessToken)
-            if (!validatedAccessToken.payload) {
-                console.log('accessToken no longer valid, reissuing... ')
-                activeSession.accessToken = createToken(
-                    { payload: validatedSessionToken.payload },
-                    // NOTE: Expiration of new sessionToken set for 200 seconds (testing)
-                    100,
-                )
-            }
-            try {
-                const validatedJwt = JWT.verify(
-                    sessionToken,
-                    process.env.APP_SECRET,
-                )
-                return { isValid: true, credentials: validatedJwt.email }
-            } catch (err) {
-                return { isValid: false, error: err.message }
-            }
-        },
-    }
-}

backend/lib/index.js

@@ -1,10 +1,4 @@
 const UserPlugin = require('./plugins/user')
-const MembershipPlugin = require('./plugins/membership')
-const SurveyPlugin = require('./plugins/survey')
-const ProfilePlugin = require('./plugins/profile')
-const NotificationPlugin = require('./plugins/notification')
-const HealthPlugin = require('./plugins/health')
-const FilterPlugin = require('./plugins/filter')
 
 /**
  * A Hapi server instance
@@ -29,31 +23,5 @@ exports.plugin = {
         await server.register(UserPlugin, {
             routes: { prefix: '/user' },
         })
-
-        await server.register(MembershipPlugin, {
-            routes: { prefix: '/membership' },
-        })
-
-        await server.register(SurveyPlugin, {
-            routes: {
-                prefix: '/survey',
-            },
-        })
-
-        await server.register(ProfilePlugin, {
-            routes: { prefix: '/profile' },
-        })
-
-        await server.register(NotificationPlugin, {
-            routes: { prefix: '/notification' },
-        })
-
-        await server.register(HealthPlugin, {
-            routes: { prefix: '/health' },
-        })
-
-        await server.register(FilterPlugin, {
-            routes: { prefix: '/filter' },
-        })
     },
 }

backend/lib/models/aspect.js

@@ -1,18 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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/authentication.js

@@ -1,12 +0,0 @@
-const Schwifty = require('@hapipal/schwifty')
-const Joi = require('joi')
-const { userAuth } = require('../schemas/authentication')
-
-module.exports = class Auth extends Schwifty.Model {
-    static get tableName() {
-        return 'authentication'
-    }
-    static get joiSchema() {
-        return userAuth
-    }
-}

backend/lib/models/grouping.js

@@ -1,28 +0,0 @@
-const Schwifty = require('@hapipal/schwifty')
-const groupingSchema = require('../schemas/groupings')
-const Profile = require('./profile')
-
-module.exports = class Grouping extends Schwifty.Model {
-    static get tableName() {
-        return 'groupings'
-    }
-    static get relationMappings() {
-        return {
-            profiles: {
-                relation: Schwifty.Model.ManyToManyRelation,
-                modelClass: Profile,
-                join: {
-                    from: 'groupings.grouping_id',
-                    through: {
-                        from: 'memberships.grouping_id',
-                        to: 'memberships.profile_id'
-                    },
-                    to: 'profiles.profile_id'
-                },
-            },
-        }
-    }
-    static get joiSchema() {
-        return groupingSchema.single
-    }
-}

backend/lib/models/matchqueue.js

@@ -1,28 +0,0 @@
-const Schwifty = require('@hapipal/schwifty')
-const User = require('./user')
-const queueSchema = require('../schemas/queues')
-
-module.exports = class MatchQueue extends Schwifty.Model {
-    static get tableName() {
-        return 'match_queues'
-    }
-    static get relationMappings() {
-        return {
-            user: {
-                relation: Schwifty.Model.HasOneThroughRelation,
-                modelClass: User,
-                join: {
-                    from: 'match_queues.target_id',
-                    through: {
-                        from: 'profiles.profile_id',
-                        to: 'profiles.user_id',
-                    },
-                    to: 'users.user_id',
-                },
-            },
-        }
-    }
-    static get joiSchema() {
-        return queueSchema.single
-    }
-}

backend/lib/models/membership.js

@@ -1,11 +0,0 @@
-const Schwifty = require('@hapipal/schwifty')
-const membershipSchema = require('../schemas/memberships')
-
-module.exports = class Membership extends Schwifty.Model {
-    static get tableName() {
-        return 'memberships'
-    }
-    static get joiSchema() {
-        return membershipSchema.single
-    }
-}

backend/lib/models/message.js

@@ -1,13 +0,0 @@
-const Schwifty = require('@hapipal/schwifty')
-const Joi = require('joi')
-
-module.exports = class Message extends Schwifty.Model {
-    static get tableName() {
-        return 'messages'
-    }
-    static get joiSchema() {
-        return Joi.object({
-            message_id: Joi.number().required(),
-        })
-    }
-}

backend/lib/models/profile.js

@@ -1,45 +0,0 @@
-const Schwifty = require('@hapipal/schwifty')
-const Joi = require('joi')
-const TagAssociation = require('./tag-association')
-const Response = require('./response')
-const User = require('./user')
-
-module.exports = class Profile extends Schwifty.Model {
-    static get tableName() {
-        return 'profiles'
-    }
-    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,
-                join: {
-                    from: 'responses.profile_id',
-                    to: 'profiles.profile_id',
-                },
-            },
-            user: {
-                relation: Schwifty.Model.BelongsToOneRelation,
-                modelClass: User,
-                join: {
-                    from: 'users.user_id',
-                    to: 'profiles.user_id',
-                },
-            },
-        }
-    }
-    static get joiSchema() {
-        return Joi.object({
-            profile_id: Joi.number(),
-            user_id: Joi.number(),
-        })
-    }
-}

backend/lib/models/response-key.js

@@ -1,12 +0,0 @@
-const Schwifty = require('@hapipal/schwifty')
-const Joi = require('joi')
-const surveyResponseSchema = require('../schemas/responses')
-
-module.exports = class ResponseKey extends Schwifty.Model {
-    static get tableName() {
-        return 'response_keys'
-    }
-    static get joiSchema() {
-        return surveyResponseSchema.key
-    }
-}

backend/lib/models/response.js

@@ -1,11 +0,0 @@
-const Schwifty = require('@hapipal/schwifty')
-const responseSchema = require('../schemas/responses')
-
-module.exports = class Response extends Schwifty.Model {
-    static get tableName() {
-        return 'responses'
-    }
-    static get joiSchema() {
-        return responseSchema.single
-    }
-}

backend/lib/models/tag-association.js

@@ -1,25 +0,0 @@
-const Schwifty = require('@hapipal/schwifty')
-
-const tagSchema = require('../schemas/tags')
-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 tagSchema.association
-    }
-}

backend/lib/models/tag.js

@@ -1,11 +0,0 @@
-const Schwifty = require('@hapipal/schwifty')
-const tagSchema = require('../schemas/tags')
-
-module.exports = class Tag extends Schwifty.Model {
-    static get tableName() {
-        return 'tags'
-    }
-    static get joiSchema() {
-        return tagSchema.single
-    }
-}

backend/lib/models/user.js

@@ -1,18 +1,14 @@
+const { single } = require('../schemas/user')
 const Schwifty = require('@hapipal/schwifty')
-const Joi = require('joi')
 
+/**
+ * @typedef User
+ */
 module.exports = class User extends Schwifty.Model {
     static get tableName() {
         return 'users'
     }
     static get joiSchema() {
-        return Joi.object({
-            user_id: Joi.number(),
-            user_name: Joi.string(),
-            user_email: Joi.string().required(),
-            is_poster: Joi.number().required(),
-            is_admin: Joi.number().required(),
-            is_verified: Joi.number().required(),
-        })
+        return single
     }
 }

backend/lib/models/zip-code.js

@@ -1,18 +0,0 @@
-const Schwifty = require('@hapipal/schwifty')
-const Joi = require('joi')
-
-module.exports = class ZipCode extends Schwifty.Model {
-    static get tableName() {
-        return 'zip_codes'
-    }
-    static get joiSchema() {
-        return Joi.object({
-            zip_code_id: Joi.number(),
-            latitude: Joi.string().required(),
-            longitude: Joi.string().required(),
-            city: Joi.string().required(),
-            state: Joi.string().required(),
-            county: Joi.string().required(),
-        })
-    }
-}

backend/lib/plugins/filter.js

@@ -1,13 +0,0 @@
-const Schmervice = require('@hapipal/schmervice')
-const FilterRoute = require('../routes/filter/get')
-const FilterService = require('../services/filter')
-
-module.exports = {
-    name: 'filter-plugin',
-    version: '1.0.0',
-    register: async (server, options) => {
-        await server.register(Schmervice)
-        await server.registerService(FilterService)
-        await server.route(FilterRoute)
-    },
-}

backend/lib/plugins/health.js

@@ -1,9 +0,0 @@
-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/membership.js

@@ -1,35 +0,0 @@
-const Objection = require('objection')
-const Schmervice = require('@hapipal/schmervice')
-
-const GroupingModel = require('../models/grouping')
-const MembershipModel = require('../models/membership')
-
-const MembershipService = require('../services/membership')
-
-const MembershipJoinRoute = require('../routes/membership/join')
-const MembershipLeaveRoute = require('../routes/membership/leave')
-const MembershipActiveRoute = require('../routes/membership/active')
-const MembershipRevealRoute = require('../routes/membership/reveal')
-
-module.exports = {
-    name: 'membership-plugin',
-    version: '1.0.0',
-    register: async (server, options) => {
-        await server.registerModel(GroupingModel)
-        await server.registerModel(MembershipModel)
-
-        // Bind to global context
-        // So we can use Objection transactions
-        server.bind({
-            transaction: fn => Objection.transaction(server.knex(), fn),
-        })
-
-        await server.register(Schmervice)
-        server.registerService(MembershipService)
-
-        await server.route(MembershipJoinRoute)
-        await server.route(MembershipLeaveRoute)
-        await server.route(MembershipActiveRoute)
-        await server.route(MembershipRevealRoute)
-    },
-}

backend/lib/plugins/notification.js

@@ -1,119 +0,0 @@
-const _allStreams = {}
-
-const NotificationRoute = require('../routes/notification')
-
-/** Heavily lifted from: https://github.com/mtharrison/susie/blob/master/lib/index.js */
-
-const Stream = require('stream')
-const PassThrough = Stream.PassThrough
-const Transform = Stream.Transform
-
-const ENDER = { event: 'end', data: '' }
-
-/**
- * Stringify a stream
- * ?: I don't really get what this is doing
- * @param {Stream} event
- * @returns {string}
- */
-const _stringifyEvent = function (event) {
-    let str = ''
-    const endl = '\r\n'
-    for (const i in event) {
-        let val = event[i]
-        if (val instanceof Buffer) {
-            val = val.toString()
-        }
-        if (typeof val === 'object') {
-            val = JSON.stringify(val)
-        }
-        str += i + ': ' + val + endl
-    }
-    str += endl
-    return str
-}
-
-/**
- * Transform extension
- * ?: I don't really get what this is doing
- * @param {object} options
- * @param {object} objectMode
- */
-class Transformer extends Transform {
-    constructor(options, objectMode) {
-        super({ objectMode })
-        options = options || {}
-        this.counter = 1
-        this.event = options.event || null
-        this.generateId = options.generateId
-            ? options.generateId
-            : () => this.counter++
-    }
-    _transform(chunk, encoding, callback) {
-        const event = {
-            id: this.generateId(chunk),
-            data: chunk,
-        }
-        if (this.event) {
-            event.event = this.event
-        }
-        this.push(_stringifyEvent(event))
-        callback()
-    }
-    _flush(callback) {
-        this.push(_stringifyEvent(ENDER))
-        callback()
-    }
-}
-
-/**
- * Callback to decorate server toolkit (h)
- * !: Currently we only support ObjectMode streams
- * ?: I don't really get what this is doing
- * @param {Stream} event stream input
- * @param {Toolkit} h hapi common response toolkit
- * @param {object} streamOptions
- */
-const _event = (event, h, streamOptions) => {
-    let active
-    if (event instanceof Stream.Readable) {
-        if (event._readableState.objectMode) {
-            active = new PassThrough()
-            const through = new Transformer(streamOptions, true)
-            through.pipe(active)
-            event.pipe(through)
-        }
-        return h
-            .response(active)
-            .header('content-type', 'text/event-stream')
-            .header('content-encoding', 'identity')
-    }
-}
-
-/**
- * Takes an open HTTP stream and writes
- * a msg to it, then fires notification plugin's
- * _event callback
- * @param {object} msg you want to send
- * @param {string} name <profileId>.<eventType>
- * @param {boolean} shouldInitialize
- * @param {Toolkit} h hapi common response toolkit
- */
-const onNotify = (name, msg, h, shouldInitialize = false) => {
-    if (shouldInitialize) {
-        _allStreams[name] = new PassThrough({ objectMode: true })
-    }
-    if (!_allStreams[name]) return
-    _allStreams[name].write(msg)
-
-    return _event(_allStreams[name], h, { event: name })
-}
-
-module.exports = {
-    name: 'notification-plugin',
-    version: '1.0.0',
-    register: async server => {
-        await server.route(NotificationRoute)
-        server.method('notify', onNotify)
-    },
-}

backend/lib/plugins/profile.js

@@ -1,63 +0,0 @@
-const Objection = require('objection')
-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')
-
-const ProfileService = require('../services/profile')
-const MatchQueueService = require('../services/matchqueue')
-const MatchService = require('../services/match')
-
-const ProfileScoreRoute = require('../routes/profile/score')
-const ProfileUpdateRoute = require('../routes/profile/update')
-const ProfileInsertRoute = require('../routes/profile/insert')
-const ProfileRespondRoute = require('../routes/profile/respond')
-const ProfileMatchRoute = require('../routes/profile/match')
-const ProfileQueueRoute = require('../routes/profile/queue')
-const ProfileGetRoute = require('../routes/profile/get')
-const ProfilePatchQueueRoute = require('../routes/profile/patch-queue')
-const TagRevealRoute = require('../routes/tag/reveal')
-const TagGetRoute = require('../routes/tag/get')
-
-module.exports = {
-    name: 'profile-plugin',
-    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)
-
-        // Bind to global context
-        // So we can use Objection transactions
-        server.bind({
-            transaction: fn => Objection.transaction(server.knex(), fn),
-        })
-
-        await server.register(Schmervice)
-        await server.registerService(ProfileService)
-        await server.registerService(MatchQueueService)
-        await server.registerService(MatchService)
-
-        await server.route(ProfileScoreRoute)
-        await server.route(ProfileRespondRoute)
-        await server.route(ProfileUpdateRoute)
-        await server.route(ProfileInsertRoute)
-        await server.route(ProfileMatchRoute)
-        await server.route(ProfileQueueRoute)
-        await server.route(ProfileGetRoute)
-        await server.route(ProfilePatchQueueRoute)
-        await server.route(TagRevealRoute)
-        await server.route(TagGetRoute)
-    },
-}

backend/lib/plugins/survey.js

@@ -1,28 +0,0 @@
-const Objection = require('objection')
-const Schmervice = require('@hapipal/schmervice')
-
-const ReponseKeyModel = require('../models/response-key')
-
-const ResponseService = require('../services/response')
-
-const ResponseQuestionsRoute = require('../routes/survey/questions')
-
-module.exports = {
-    name: 'survey-plugin',
-    version: '1.0.0',
-    register: async (server, options) => {
-        await server.registerModel(ReponseKeyModel)
-
-        // Bind to global context
-        // So we can use Objection transactions
-        server.bind({
-            transaction: fn => Objection.transaction(server.knex(), fn),
-        })
-
-        await server.register(Schmervice)
-        server.registerService(ResponseService)
-
-        await server.route(ResponseQuestionsRoute)
-    },
-    models: { ReponseKeyModel },
-}

backend/lib/plugins/user.js

@@ -1,40 +1,18 @@
 const Objection = require('objection')
 const Schmervice = require('@hapipal/schmervice')
 const Schwifty = require('@hapipal/schwifty')
-const Jwt = require('hapi-auth-jwt2')
-const JwtStrategy = require('../auth/strategies/jwt')
 
 const UserModel = require('../models/user')
-const AuthModel = require('../models/authentication')
-
-const UserProfileCreateRoute = require('../routes/user/create-profile')
-const UserLoginRoute = require('../routes/user/login')
-const UserSignupRoute = require('../routes/user/signup')
-const UserEmailRoute = require('../routes/user/send-email.js')
-const UserVerifyActiveRoute = require('../routes/user/verify-session.js')
-const UserCreateTokenRoute = require('../routes/user/token.js')
-const UserValidateSessionRoute = require('../routes/user/validate-session.js')
-const UserRemoveSessionRoute = require('../routes/user/remove-session.js')
-const UserPassword = require('../routes/user/authentication')
-
 const UserService = require('../services/user')
-const DisplayService = require('../services/display')
-const HealthService = require('../services/health')
+
+const GetUser = require('../routes/user/get-user')
 
 module.exports = {
     name: 'user-plugin',
     version: '1.0.0',
     register: async (server, options) => {
-        await server.register(Jwt)
         await server.register(Schwifty)
         await server.registerModel(UserModel)
-        await server.registerModel(AuthModel)
-
-        const mainApp = server.registrations['main-app-plugin']
-        const jwtOptions = JwtStrategy(mainApp.options)
-
-        server.auth.strategy('default_jwt', 'jwt', jwtOptions)
-        server.auth.default('default_jwt')
 
         // Bind to global context
         // So we can use Objection transactions
@@ -44,17 +22,7 @@ module.exports = {
 
         await server.register(Schmervice)
         server.registerService(UserService)
-        server.registerService(DisplayService)
-        server.registerService(HealthService)
 
-        await server.route(UserLoginRoute)
-        await server.route(UserSignupRoute)
-        await server.route(UserProfileCreateRoute)
-        await server.route(UserEmailRoute)
-        await server.route(UserVerifyActiveRoute)
-        await server.route(UserCreateTokenRoute)
-        await server.route(UserValidateSessionRoute)
-        await server.route(UserRemoveSessionRoute)
-        await server.route(UserPassword)
+        await server.route(GetUser)
     },
 }

backend/lib/routes/filter/get.js

@@ -1,89 +0,0 @@
-'use strict'
-
-// NOTE: Current Implementation does not require this route
-// (see Auth.vue in components/onboarding and queue route with filter.js)
-const Joi = require('joi')
-const apiSchema = require('../../schemas/api')
-const errorSchema = require('../../schemas/errors')
-const filterSchema = require('../../schemas/filter')
-const profileSchema = require('../../schemas/profiles')
-
-const pluginConfig = {
-    handlerType: 'filter',
-    docs: {
-        description: 'Filter match pool',
-        notes: 'Returns filtered subset of match pool',
-    },
-}
-
-const validators = {
-    query: Joi.object({
-        match_pool: Joi.array().items(profileSchema.single),
-        distance: Joi.string(),
-        presence: Joi.string(),
-    }),
-}
-
-const responseSchemas = {
-    filteredMatchPool: filterSchema.matchPool, // array of profiles
-    error: errorSchema.single,
-}
-
-module.exports = {
-    method: 'GET',
-    path: '/',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        auth: false,
-        cors: true,
-        handler: async function (request, h) {
-            const { filterService } = request.server.services()
-            let matchPool = request.query.match_pool
-            matchPool = filterService.byDistance(
-                matchPool,
-                request.query.distance,
-            )
-            matchPool = filterService.byPresence(
-                matchPool,
-                request.query.presence,
-            )
-            try {
-                return h
-                    .response({
-                        ok: true,
-                        handler: pluginConfig.handlerType,
-                        data: matchPool,
-                    })
-                    .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.filteredMatchPool,
-                    })
-                    .label('api_single_res'),
-                409: apiSchema.single
-                    .append({
-                        data: responseSchemas.error,
-                    })
-                    .label('error_single_res'),
-            },
-        },
-    },
-}

backend/lib/routes/health/get.js

@@ -1,69 +0,0 @@
-'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/membership/active.js

@@ -1,176 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-const apiSchema = require('../../schemas/api')
-const errorSchema = require('../../schemas/errors')
-const groupingSchema = require('../../schemas/groupings')
-const params = require('../../schemas/params')
-
-const pluginConfig = {
-    handlerType: 'grouping',
-    docs: {
-        description: 'active memberships',
-        notes: 'A list of groupings with active membership',
-    },
-}
-
-const validators = {
-    /** Validate the header (cookie check) */
-    // headers: true,
-
-    /** Validate the route params (/active/{thing}) */
-    params: params.profileId,
-
-    /** Validate the route query (/active/{thing}?limit=10&offset=10) */
-    query: Joi.object({ type: Joi.string().lowercase().min(6).max(11) }),
-
-    /** Validate the incoming payload (POST method) */
-    // payload: true,
-}
-
-const responseSchemas = {
-    single: groupingSchema.single,
-    list: groupingSchema.listWithProfiles,
-    error: errorSchema.single,
-}
-
-const _activeGroupingIds = allMemberships => {
-    const active = {}
-    allMemberships.forEach(membership => {
-        if (!membership.is_active) return
-        if (!active[membership.grouping_id]) {
-            active[membership.grouping_id] = []
-        }
-        active[membership.grouping_id].push(membership)
-    })
-    const ids = []
-    Object.values(active).forEach(profileListInGrouping => {
-        if (profileListInGrouping.length == 2) {
-            ids.push(profileListInGrouping[0].grouping_id)
-        }
-    })
-    return ids
-}
-
-module.exports = {
-    method: 'GET',
-    path: '/{profile_id}',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        /** Protect this route with authentication? */
-        auth: false,
-        cors: true,
-        handler: async function (request, h) {
-            const { membershipService, profileService, userService } =
-                request.server.services()
-            const membershipType = request.query.type
-
-            const profileId = request.params.profile_id
-            const groupings = await membershipService.findGroupingsByProfileId(
-                profileId,
-                membershipType,
-            )
-            if (!groupings.length) {
-                return {
-                    ok: true,
-                    handler: pluginConfig.handlerType,
-                    data: [],
-                }
-            }
-            const groupingIds = groupings.map(grouping => grouping.grouping_id)
-            const memberships =
-                await membershipService.findMemberships(groupingIds)
-            let profileIds = memberships
-                .filter(membership => membership.profile_id !== profileId)
-                .map(membership => membership.profile_id)
-            profileIds =
-                !profileIds.length || profileIds[0] === undefined
-                    ? []
-                    : profileIds
-            /** Assemble complete profiles to reference and pass */
-            const completedProfiles = !profileIds.length
-                ? []
-                : await profileService.getProfilesFor(profileIds, 'participant')
-            /**
-             * Heavily process the result by storing just a profile_id
-             * and attach complete profiles
-             * !: This still assumes only ONE other profile
-             * TODO: should be refactored to many other profiles
-             */
-            const reformattedGroupings =
-                groupings.length && completedProfiles.length
-                    ? groupings.map(grouping => {
-                          const otherPid = grouping.profiles.find(
-                              p => p.profile_id != profileId,
-                          ).profile_id
-                          grouping.profile = completedProfiles.find(
-                              p => otherPid == p.profile_id,
-                          )
-                          grouping.is_paired = _activeGroupingIds(
-                              memberships,
-                          ).includes(grouping.grouping_id)
-                          delete grouping.profiles
-                          return grouping
-                      })
-                    : []
-            /** Grabs revealTags */
-            const revealTags =
-                profileIds.length && groupingIds.length
-                    ? await profileService.getTagsFor(
-                          profileIds,
-                          groupingIds,
-                          'reveal',
-                      )
-                    : undefined
-
-            /** If the revealTags exist, the completedProfile's hidden info is
-             * removed and replaced with the completedProfile's user information
-             * Otherwise the completedProfiles remain unchanged
-             */
-            const user = completedProfiles.length
-                ? await userService.findById(
-                      completedProfiles.map(p => p.user_id),
-                  )
-                : undefined
-
-            // TODO: Refactor this. Is it safe to always use completedProfiles[0]?
-            if (revealTags && user) {
-                revealTags.forEach(t => {
-                    if (!t.tag.tag_description) return
-                    completedProfiles[0][t.tag.tag_description] =
-                        user[t.tag.tag_description]
-                })
-            }
-
-            try {
-                return {
-                    ok: true,
-                    handler: pluginConfig.handlerType,
-                    data: reformattedGroupings,
-                }
-            } 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: apiSchema.single
-                .append({
-                    data: responseSchemas.list,
-                })
-                .label('grouping_list_res'),
-        },
-    },
-}

backend/lib/routes/membership/join.js

@@ -1,150 +0,0 @@
-const Joi = require('joi')
-
-const apiSchema = require('../../schemas/api')
-const errorSchema = require('../../schemas/errors')
-const groupingSchema = require('../../schemas/groupings')
-const params = require('../../schemas/params')
-
-const pluginConfig = {
-    handlerType: 'grouping',
-    docs: {
-        description: 'join',
-        notes: 'Join a grouping by creating a membership record',
-    },
-}
-
-const validators = {
-    params: params.profileId,
-    payload: groupingSchema.single
-        .append({
-            target_id: Joi.number().required(),
-            role: Joi.string(),
-        })
-        .label('grouping_membership_single'),
-}
-
-const responseSchemas = {
-    response: Joi.object({
-        memberships: Joi.array().items(),
-        hasMatch: Joi.boolean(),
-        groupings: Joi.array().items(),
-    }).label('grouping_membership_list'),
-    error: errorSchema.single,
-}
-
-module.exports = {
-    method: 'POST',
-    path: '/{profile_id}/join',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        auth: false,
-        cors: true,
-
-        /**
-         * Join a grouping by creating a membership record
-         * @param {*} request
-         * @param {*} h
-         * @returns {object}
-         */
-        handler: async function (request, h) {
-            try {
-                console.log('---')
-                const { membershipService } = request.server.services()
-
-                /** Grab payload info */
-                const profileId = request.params.profile_id
-                const res = request.payload
-                const groupingToWrite = {
-                    grouping_id: res.grouping_id,
-                    grouping_name: res.grouping_name,
-                    grouping_type: res.grouping_type,
-                }
-
-                /** Default to participant role */
-                const role = res.role ? res.role : 'participant'
-
-                // TODO: LIMIT the amount of groupings by checking type
-                // !: You should only be able to match with the target_id ONCE
-                // !: You should only be associated with a single company too
-
-                /** User membership service method to create membership */
-                const { memberships, groupings } =
-                    await membershipService.joinGrouping(
-                        profileId,
-                        res.target_id,
-                        groupingToWrite,
-                        role,
-                    )
-
-                const hasMatch = memberships.every(
-                    membership => membership && membership.is_active == true,
-                )
-
-                if (hasMatch) {
-                    request.server.methods.notify(
-                        `${profileId}.stonk`,
-                        {
-                            name: `${res.target_id} Match Fffound`,
-                            // TODO: add urls for chat
-                            url: `<a href="/profile/${res.target_id}">url</a>`,
-                            type: 'info',
-                        },
-                        h,
-                    )
-                    request.server.methods.notify(
-                        `${res.target_id}.stonk`,
-                        {
-                            name: `${profileId} Match Fffound`,
-                            // TODO: add urls for chat
-                            url: `<a href="/profile/${profileId}">url</a>`,
-                            type: 'info',
-                        },
-                        h,
-                    )
-                }
-                return h
-                    .response({
-                        ok: true,
-                        handler: pluginConfig.handlerType,
-                        data: {
-                            memberships,
-                            hasMatch,
-                            groupings,
-                        },
-                    })
-                    .code(200)
-            } catch (err) {
-                return h
-                    .response({
-                        ok: false,
-                        handler: pluginConfig.handlerType,
-                        data: { error: `${err}` },
-                    })
-                    .code(409)
-            }
-        },
-
-        /** Validate based on validators object */
-        validate: {
-            ...validators,
-            failAction: 'log',
-        },
-
-        /** Validate the server response */
-        response: {
-            status: {
-                200: apiSchema.single
-                    .append({
-                        data: responseSchemas.response,
-                    })
-                    .label('join_grouping_res'),
-                409: apiSchema.single
-                    .append({
-                        data: responseSchemas.error,
-                    })
-                    .label('error_single_res'),
-            },
-        },
-    },
-}

backend/lib/routes/membership/leave.js

@@ -1,49 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-const apiSchema = require('../../schemas/api')
-const pluginConfig = {
-    handlerType: 'grouping',
-    docs: {
-        description: 'leave',
-        notes: 'Leave a grouping by editing a membership record',
-    },
-}
-
-const validators = {
-    leave: {
-        payload: Joi.object(),
-    },
-}
-
-module.exports = {
-    method: 'POST',
-    path: '/leave',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        auth: false,
-        handler: async function (request, h) {
-            try {
-                return {
-                    ok: true,
-                    handler: pluginConfig.handlerType,
-                    data: { foo: 'bar' },
-                }
-            } catch (err) {
-                return {
-                    ok: false,
-                    handler: pluginConfig.handlerType,
-                    data: { error: `${err}` },
-                }
-            }
-        },
-        validate: validators.leave,
-        response: {
-            schema: apiSchema.single.append({
-                data: validators.leave,
-            }),
-            failAction: 'log',
-        },
-    },
-}

backend/lib/routes/membership/reveal.js

@@ -1,137 +0,0 @@
-const Joi = require('joi')
-
-const apiSchema = require('../../schemas/api')
-const errorSchema = require('../../schemas/errors')
-
-const pluginConfig = {
-    handlerType: 'reveal',
-    docs: {
-        description: 'reveal',
-        notes: 'Reveal profile information to a grouping by membership',
-    },
-}
-
-const validators = {
-    params: Joi.object({ grouping_id: Joi.number() }),
-    query: Joi.object({ profile_id: Joi.number(), tag_id: Joi.number() }),
-}
-
-const responseSchemas = {
-    response: Joi.object({
-        tags: Joi.array().items(),
-    }),
-    error: errorSchema.single,
-}
-module.exports = {
-    method: 'POST',
-    path: '/{grouping_id}/reveal',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        auth: false,
-        cors: true,
-        handler: async function (request, h) {
-            const { membershipService, profileService, userService } =
-                request.server.services()
-            const grouping_id = request.params.grouping_id
-            const { profile_id, tag_id } = request.query
-            try {
-                const associations = await profileService.revealProfileInfo({
-                    profile_id,
-                    grouping_id,
-                    tag_id,
-                    is_deleted: false,
-                })
-
-                // Notify both profiles that information has been revealed
-                const memberships = await membershipService.findMemberships([
-                    grouping_id,
-                ])
-                const idsInGroup = memberships.map(
-                    membership => membership.profile_id,
-                )
-                if (idsInGroup.length > 2)
-                    return console.error(
-                        'ERROR: idsInGroup cannot have more than 2 entries: ',
-                        idsInGroup,
-                    )
-                // Grab User Info from Users Table
-                const completeProfile = await profileService.getProfilesFor(
-                    [profile_id],
-                    'participant',
-                )
-                const userInfo = await userService.findById(
-                    completeProfile[0].user_id,
-                )
-
-                // Grab the TagAssociation that matches the revealed profile
-                // TODO: Check if there are multiple matching associations(?)(there shouldn't be)
-                let matchingAssociation = null
-                associations.forEach(tagAssoc => {
-                    if (
-                        tagAssoc.grouping_id === grouping_id &&
-                        tagAssoc.profile_id === profile_id &&
-                        tagAssoc.tag_id === tag_id
-                    ) {
-                        matchingAssociation = tagAssoc
-                    }
-                })
-                const description = matchingAssociation.tag.tag_description
-
-                idsInGroup.forEach(profile_id => {
-                    request.server.methods.notify(
-                        `${profile_id}.stonk`,
-                        {
-                            name: 'REVEALED_INFO',
-                            revealed_info: userInfo[description],
-                            profile_id: completeProfile[0].profile_id,
-                            grouping_id: grouping_id,
-                            tag: tag_id,
-                            description,
-                            type: 'info',
-                            url: `<a href="/chat/${profile_id}">url</a>`
-                        },
-                        h,
-                    )
-                })
-                return h
-                    .response({
-                        ok: true,
-                        handler: pluginConfig.handlerType,
-                        data: { tags: associations },
-                    })
-                    .code(200)
-            } catch (err) {
-                return h
-                    .response({
-                        ok: false,
-                        handler: pluginConfig.handlerType,
-                        data: { error: `${err}` },
-                    })
-                    .code(409)
-            }
-        },
-
-        /** Validate based on validators object */
-        validate: {
-            ...validators,
-            failAction: 'log',
-        },
-
-        /** Validate the server response */
-        response: {
-            status: {
-                200: apiSchema.single
-                    .append({
-                        data: responseSchemas.response,
-                    })
-                    .label('reveal_res'),
-                409: apiSchema.single
-                    .append({
-                        data: responseSchemas.error,
-                    })
-                    .label('error_single_res'),
-            },
-        },
-    },
-}

backend/lib/routes/notification/index.js

@@ -1,53 +0,0 @@
-const Joi = require('joi')
-const apiSchema = require('../../schemas/api')
-const errorSchema = require('../../schemas/errors')
-const params = require('../../schemas/params')
-
-const pluginConfig = {
-    handlerType: 'notifictaion',
-    docs: {
-        description: 'subscribe',
-        notes: 'Subscribe to notifications based on profile_id',
-    },
-}
-
-const validators = {
-    params: params.profileId,
-}
-
-module.exports = {
-    method: 'GET',
-    path: '/{profile_id}/subscribe',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        auth: false,
-        cors: true,
-        handler: async (request, h) => {
-            const { profile_id } = request.params
-
-            /**
-             * Write the initial stream
-             * !: this must remain open for notifications to work
-             */
-            return request.server.methods.notify(
-                `${profile_id}.stonk`,
-                {
-                    profile_id,
-                    name: 'BDGRS',
-                    price: (500 + Math.floor(Math.random() * 100)).toString(),
-                    order: Math.floor(Math.random() * 2) === 1 ? 'BUY' : 'SELL',
-                    type: 'info',
-                },
-                h,
-                true,
-            )
-        },
-
-        /** Validate based on validators object */
-        validate: {
-            ...validators,
-            failAction: 'log',
-        },
-    },
-}

backend/lib/routes/profile/get.js

@@ -1,80 +0,0 @@
-'use strict'
-
-const apiSchema = require('../../schemas/api')
-const errorSchema = require('../../schemas/errors')
-const profileSchema = require('../../schemas/profiles')
-const params = require('../../schemas/params')
-
-const pluginConfig = {
-    handlerType: 'profile',
-    docs: {
-        description: 'Returns a single profile with tags',
-        notes: 'returns from the Profiles Table',
-    },
-}
-
-const responseSchemas = {
-    profile: profileSchema.single,
-    error: errorSchema.single,
-}
-
-const validators = {
-    params: params.profileId,
-}
-
-module.exports = {
-    method: 'GET',
-    path: '/{profile_id}',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        // auth: 'default_jwt',
-        auth: false,
-        cors: true,
-        handler: async function (request, h) {
-            const { profile_id } = request.params
-            const { profileService } = request.server.services()
-
-            const res = {
-                ok: true,
-                handler: pluginConfig.handlerType,
-                data: null,
-            }
-
-            res.data = await profileService.getProfile(profile_id)
-
-            try {
-                return h.response(res).code(200)
-            } catch (err) {
-                return h
-                    .response({
-                        ok: false,
-                        handler: pluginConfig.handlerType,
-                        data: { error: `${err}` },
-                    })
-                    .code(409)
-            }
-        },
-        /** Validate based on validators object */
-        validate: {
-            ...validators,
-            failAction: 'log',
-        },
-
-        /** Validate the server response */
-        response: {
-            status: {
-                200: apiSchema.single
-                    .append({
-                        data: responseSchemas.profile,
-                    })
-                    .label('profile_single_res'),
-                409: apiSchema.single
-                    .append({
-                        data: responseSchemas.error,
-                    })
-                    .label('error_single_res'),
-            },
-        },
-    },
-}

backend/lib/routes/profile/insert.js

@@ -1,85 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-const apiSchema = require('../../schemas/api')
-const errorSchema = require('../../schemas/errors')
-const surveyResponseSchema = require('../../schemas/responses')
-const params = require('../../schemas/params')
-
-const pluginConfig = {
-    handlerType: 'profile',
-    docs: {
-        description: 'Insert responses',
-        notes: 'Insert new responses',
-    },
-}
-
-const responseSchemas = {
-    response: surveyResponseSchema.single,
-    error: errorSchema.single,
-}
-
-module.exports = {
-    method: 'POST',
-    path: '/{profile_id}/insert/{response_key_id?}',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        /** Protect this route with authentication? */
-        auth: false,
-        cors: true,
-
-        handler: async function (request, h) {
-            const { profileService } = request.services()
-            /** Grab payload info */
-            const res = request.payload
-
-            try {
-                // TODO: Currently passwords are stored in plain text, big no no...
-                const insertedResponse =
-                    await profileService.insertSingleResponseForProfile(res)
-
-                if (!insertedResponse) {
-                    throw new Error('Response not inserted')
-                }
-
-                return h
-                    .response({
-                        ok: true,
-                        handler: pluginConfig.handlerType,
-                        data: insertedResponse,
-                    })
-                    .code(200)
-            } catch (err) {
-                return h
-                    .response({
-                        ok: false,
-                        handler: pluginConfig.handlerType,
-                        data: { error: `${err}` },
-                    })
-                    .code(409)
-            }
-        },
-
-        /** Validate based on validators object */
-        validate: {
-            failAction: 'log',
-        },
-
-        /** Validate the server response */
-        response: {
-            status: {
-                200: apiSchema.single
-                    .append({
-                        data: responseSchemas.response,
-                    })
-                    .label('response_list_res'),
-                409: apiSchema.single
-                    .append({
-                        data: responseSchemas.error,
-                    })
-                    .label('error_single_res'),
-            },
-        },
-    },
-}

backend/lib/routes/profile/match.js

@@ -1,81 +0,0 @@
-'use strict'
-
-const apiSchema = require('../../schemas/api')
-const errorSchema = require('../../schemas/errors')
-const surveyResponseSchema = require('../../schemas/responses')
-
-const pluginConfig = {
-    handlerType: 'match',
-    docs: {
-        description: 'matches',
-        notes: 'Match everyone',
-    },
-}
-
-const validators = {}
-
-const responseSchemas = {
-    response: surveyResponseSchema.list,
-    error: errorSchema.single,
-}
-
-module.exports = {
-    method: 'GET',
-    path: '/match',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        /** Protect this route with authentication? */
-        auth: false,
-
-        handler: async function (request, h) {
-            const { matchService, matchQueueService } =
-                request.server.services()
-            const allQueues = await matchQueueService.getAllQueues()
-            const matched = await matchService.calcMatches(allQueues)
-            try {
-                if (!allQueues) {
-                    throw new RangeError('Unable to match profiles')
-                }
-
-                return h
-                    .response({
-                        ok: true,
-                        handler: pluginConfig.handlerType,
-                        data: matched,
-                    })
-                    .code(200)
-            } catch (err) {
-                return h
-                    .response({
-                        ok: false,
-                        handler: pluginConfig.handlerType,
-                        data: { error: `${err}` },
-                    })
-                    .code(409)
-            }
-        },
-
-        /** Validate based on validators object */
-        validate: {
-            ...validators,
-            failAction: 'log',
-        },
-
-        /** Validate the server response */
-        response: {
-            status: {
-                200: apiSchema.single
-                    .append({
-                        data: responseSchemas.response,
-                    })
-                    .label('response_list_res'),
-                409: apiSchema.single
-                    .append({
-                        data: responseSchemas.error,
-                    })
-                    .label('error_single_res'),
-            },
-        },
-    },
-}

backend/lib/routes/profile/patch-queue.js

@@ -1,97 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-const apiSchema = require('../../schemas/api')
-const errorSchema = require('../../schemas/errors')
-const profileSchema = require('../../schemas/profiles')
-const params = require('../../schemas/params')
-
-const pluginConfig = {
-    handlerType: 'profile',
-    docs: {
-        description: 'Updates match queue in place',
-        notes: 'Updates in place and does not delete from table',
-    },
-}
-
-const responseSchemas = {
-    response: Joi.array().items(
-        Joi.alternatives().try(
-            Joi.number().optional(),
-            profileSchema.single.optional(),
-        ),
-    ),
-    error: errorSchema.single,
-}
-
-const validators = {
-    params: params.profileId.append({ target_id: Joi.number() }),
-    query: params.profileInclude.append({ reinsert: Joi.boolean() }),
-}
-
-module.exports = {
-    method: 'PATCH',
-    path: '/{profile_id}/queue/{target_id}/delete',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        /** Protect this route with authentication? */
-        auth: false,
-        cors: true,
-        handler: async function (request, h) {
-            const { profile_id, target_id } = request.params
-            const { include_profile, reinsert } = request.query
-            const { profileService, matchQueueService } =
-                request.server.services()
-
-            const updatedQueue = await matchQueueService.markAsDeleted(
-                profile_id,
-                target_id,
-                reinsert,
-            )
-            const queueIds = updatedQueue.map(entry => entry.target_id)
-
-            const res = {
-                ok: true,
-                handler: pluginConfig.handlerType,
-                data:
-                    include_profile == true
-                        ? await profileService.getProfilesFor(queueIds)
-                        : queueIds,
-            }
-
-            try {
-                return h.response(res).code(200)
-            } catch (err) {
-                return h
-                    .response({
-                        ok: false,
-                        handler: pluginConfig.handlerType,
-                        data: { error: `${err}` },
-                    })
-                    .code(409)
-            }
-        },
-        /** Validate based on validators object */
-        validate: {
-            ...validators,
-            failAction: 'log',
-        },
-
-        /** Validate the server response */
-        response: {
-            status: {
-                200: apiSchema.single
-                    .append({
-                        data: responseSchemas.response,
-                    })
-                    .label('match_queue_res'),
-                409: apiSchema.single
-                    .append({
-                        data: responseSchemas.error,
-                    })
-                    .label('error_single_res'),
-            },
-        },
-    },
-}

backend/lib/routes/profile/queue.js

@@ -1,107 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-const apiSchema = require('../../schemas/api')
-const errorSchema = require('../../schemas/errors')
-const profileSchema = require('../../schemas/profiles')
-
-const pluginConfig = {
-    handlerType: 'profile',
-    docs: {
-        description: 'Returns previously scored profiles',
-        notes: 'returns from the MatchQueue Table',
-    },
-}
-
-const responseSchemas = {
-    response: Joi.array().items(
-        Joi.alternatives().try(Joi.number(), profileSchema.single),
-    ),
-    error: errorSchema.single,
-}
-
-const validators = {
-    params: Joi.object({
-        profile_id: Joi.string(),
-    }),
-    query: Joi.object({
-        include_profile: Joi.bool(),
-        limit: Joi.number(),
-        offset: Joi.number(),
-    }),
-}
-
-module.exports = {
-    method: 'GET',
-    path: '/{profile_id}/queue',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        /** Protect this route with authentication? */
-        auth: false,
-        cors: true,
-        handler: async function (request, h) {
-            const { profile_id } = request.params
-            const { limit, offset } = request.query
-            const { profileService, matchQueueService } =
-                request.server.services()
-
-            const queue = await matchQueueService.getQueue(
-                profile_id,
-                limit,
-                offset,
-            )
-            const queueIds = queue.map(entry => entry.target_id)
-
-            // HELP: I think there's an issue here
-            // queueIds spits out the queue profiles in the correct order
-            // ~However~ when it goes through getProfilesFor
-            // it comes back in literal database order regardless of is_deleted status
-            // console.log(
-            //     'include_profile results',
-            //     await profileService.getProfilesFor(queueIds),
-            // )
-            try {
-                return h
-                    .response({
-                        ok: true,
-                        handler: pluginConfig.handlerType,
-                        data: await profileService.getProfilesFor(
-                            queueIds,
-                            'participant',
-                        ),
-                    })
-                    .code(200)
-            } catch (err) {
-                return h
-                    .response({
-                        ok: false,
-                        handler: pluginConfig.handlerType,
-                        data: { error: `${err}` },
-                    })
-                    .code(409)
-            }
-        },
-        /** Validate based on validators object */
-        validate: {
-            ...validators,
-            failAction: 'log',
-        },
-
-        /** Validate the server response */
-        response: {
-            status: {
-                200: apiSchema.single
-                    .append({
-                        data: responseSchemas.response,
-                    })
-                    .label('match_queue_res'),
-                409: apiSchema.single
-                    .append({
-                        data: responseSchemas.error,
-                    })
-                    .label('error_single_res'),
-            },
-        },
-    },
-}

backend/lib/routes/profile/respond.js

@@ -1,107 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-const apiSchema = require('../../schemas/api')
-const errorSchema = require('../../schemas/errors')
-const surveyResponseSchema = require('../../schemas/responses')
-const params = require('../../schemas/params')
-
-const pluginConfig = {
-    handlerType: 'profile',
-    docs: {
-        description: 'Update profile',
-        notes: 'Update profile responses',
-    },
-}
-
-const responseSchemas = {
-    response: surveyResponseSchema.list,
-    error: errorSchema.single,
-}
-
-const validators = {
-    /** Validate the header (cookie check) */
-    // headers: true,
-
-    /** Validate the route params (/active/{thing}) */
-    params: params.profileId,
-
-    /** Validate the route query (/active/{thing}?limit=10&offset=10) */
-    query: Joi.object({
-        response_key_id: Joi.number(),
-        val: Joi.string(),
-    }),
-    /** Validate the incoming payload (POST method) */
-    // payload: responseSchemas.responses,
-}
-
-module.exports = {
-    method: 'POST',
-    path: '/{profile_id}/respond',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        /** Protect this route with authentication? */
-        auth: false,
-        cors: true,
-        handler: async function (request, h) {
-            const { profileService } = request.services()
-
-            const profileId = request.params.profile_id
-            const responseToSave = {
-                profile_id: profileId,
-                response_key_id: request.query.response_key_id,
-                val: request.query.val,
-            }
-            const allResponses = await profileService.saveResponseForProfile(
-                profileId,
-                responseToSave,
-            )
-
-            try {
-                // profileService.saveResponseForProfile() will return null if it exists
-                if (!allResponses) {
-                    throw new RangeError('Response already exists')
-                }
-
-                return h
-                    .response({
-                        ok: true,
-                        handler: pluginConfig.handlerType,
-                        data: allResponses,
-                    })
-                    .code(201)
-            } catch (err) {
-                return h
-                    .response({
-                        ok: false,
-                        handler: pluginConfig.handlerType,
-                        data: { error: `${err}` },
-                    })
-                    .code(409)
-            }
-        },
-
-        /** Validate based on validators object */
-        validate: {
-            ...validators,
-            failAction: 'log',
-        },
-
-        /** Validate the server response */
-        response: {
-            status: {
-                201: apiSchema.single
-                    .append({
-                        data: responseSchemas.response,
-                    })
-                    .label('response_list_res'),
-                409: apiSchema.single
-                    .append({
-                        data: responseSchemas.error,
-                    })
-                    .label('error_single_res'),
-            },
-        },
-    },
-}

backend/lib/routes/profile/score.js

@@ -1,118 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-const apiSchema = require('../../schemas/api')
-const errorSchema = require('../../schemas/errors')
-const params = require('../../schemas/params')
-const profileSchema = require('../../schemas/profiles')
-
-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: params.profileId,
-
-    /** Validate the route query (/active/{thing}?limit=10&offset=10) */
-    query: Joi.object({
-        max_distance: Joi.number(),
-        unit: Joi.string(),
-    }),
-    /** Validate the incoming payload (POST method) */
-    // payload: true,
-}
-
-const responseSchemas = {
-    response: Joi.array().items(Joi.object()),
-    error: errorSchema.single,
-}
-
-module.exports = {
-    method: 'GET',
-    path: '/{profile_id}/score',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        /** Protect this route with authentication? */
-        auth: false,
-        cors: true,
-        handler: async function (request, h) {
-            const { profileService, matchQueueService } =
-                request.server.services()
-
-            const profileId = request.params.profile_id
-            const maxDistanceMiles = request.query.max_distance
-            const distanceUnit = request.query.unit
-                ? request.query.unit
-                : 'mile'
-            const duration = request.query.duration
-            const presence =
-                request.query.presence === 'in_person'
-                    ? 'onsite'
-                    : request.query.presence
-            const certifications = request.query.certifications
-            const scoredProfiles = await profileService.scoreProfilesFor(
-                profileId,
-                maxDistanceMiles,
-                distanceUnit,
-                duration,
-                presence,
-                certifications,
-            )
-            try {
-                if (!scoredProfiles) {
-                    throw new RangeError('Unable to score profiles')
-                }
-                await matchQueueService.saveMatchQueue(
-                    profileId,
-                    scoredProfiles.map(profile => profile.profile_id),
-                )
-                return h
-                    .response({
-                        ok: true,
-                        handler: pluginConfig.handlerType,
-                        data: scoredProfiles,
-                    })
-                    .code(200)
-            } catch (err) {
-                return h
-                    .response({
-                        ok: false,
-                        handler: pluginConfig.handlerType,
-                        data: { error: `${err}` },
-                    })
-                    .code(409)
-            }
-        },
-
-        /** Validate based on validators object */
-        validate: {
-            ...validators,
-            failAction: 'log',
-        },
-
-        /** Validate the server response */
-        response: {
-            status: {
-                200: apiSchema.single
-                    .append({
-                        data: responseSchemas.response,
-                    })
-                    .label('profile_list_res'),
-                409: apiSchema.single
-                    .append({
-                        data: responseSchemas.error,
-                    })
-                    .label('error_single_res'),
-            },
-        },
-    },
-}

backend/lib/routes/profile/update.js

@@ -1,102 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-const apiSchema = require('../../schemas/api')
-const errorSchema = require('../../schemas/errors')
-const surveyResponseSchema = require('../../schemas/responses')
-const params = require('../../schemas/params')
-
-const pluginConfig = {
-    handlerType: 'profile',
-    docs: {
-        description: 'Update profile',
-        notes: 'Update profile responses',
-    },
-}
-
-const responseSchemas = {
-    response: surveyResponseSchema.list,
-    error: errorSchema.single,
-}
-
-const validators = {
-    /** Validate the header (cookie check) */
-    // headers: true,
-
-    /** Validate the route params (/active/{thing}) */
-    params: params.profileId,
-
-    /** Validate the route query (/active/{thing}?limit=10&offset=10) */
-    // query: true,
-    /** Validate the incoming payload (POST method) */
-    payload: responseSchemas.responses,
-}
-
-module.exports = {
-    method: 'PATCH',
-    path: '/{profile_id}/update/{response_id?}',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        /** Protect this route with authentication? */
-        auth: false,
-
-        handler: async function (request, h) {
-            const { profileService } = request.services()
-            const profileId = request.params.profile_id
-
-            /** Grab payload info */
-            const res = request.payload
-
-            try {
-                const updatedResponses =
-                    await profileService.updateResponsesInProfile(
-                        profileId,
-                        res,
-                    )
-
-                if (!updatedResponses) {
-                    throw new RangeError('Response not updated')
-                }
-
-                return h
-                    .response({
-                        ok: true,
-                        handler: pluginConfig.handlerType,
-                        data: updatedResponses,
-                    })
-                    .code(200)
-            } catch (err) {
-                return h
-                    .response({
-                        ok: false,
-                        handler: pluginConfig.handlerType,
-                        data: { error: `${err}` },
-                    })
-                    .code(409)
-            }
-        },
-
-        /** Validate based on validators object */
-        validate: {
-            ...validators,
-            failAction: 'log',
-        },
-
-        /** Validate the server response */
-        response: {
-            status: {
-                200: apiSchema.single
-                    .append({
-                        data: responseSchemas.response,
-                    })
-                    .label('response_list_res'),
-                409: apiSchema.single
-                    .append({
-                        data: responseSchemas.error,
-                    })
-                    .label('error_single_res'),
-            },
-        },
-    },
-}

backend/lib/routes/survey/questions.js

@@ -1,70 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-const apiSchema = require('../../schemas/api')
-const surveyResponseSchema = require('../../schemas/responses')
-
-const pluginConfig = {
-    handlerType: 'survey',
-    docs: {
-        description: 'Get survey questions',
-        notes: 'Returns a list of all possible survey questions in the form of response_keys',
-    },
-}
-
-/** Validator functions by request method */
-const validators = {
-    /** Validate the header (cookie check) */
-    // headers: true,
-    /** Validate the route params (/active/{thing}) */
-    // params: true,
-    /** Validate the route query (/active/{thing}?limit=10&offset=10) */
-    // query: true,
-    /** Validate the incoming payload (POST method) */
-    // payload: true,
-}
-const responseSchemas = {
-    response: surveyResponseSchema.keys,
-}
-
-module.exports = {
-    method: 'GET',
-    path: '/questions',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        /** Protect this route with authentication? */
-        auth: false,
-        cors: true,
-        handler: async function (request, h) {
-            const { responseService } = request.services()
-            const responseKeys = await responseService.getResponseKeys()
-            try {
-                return {
-                    ok: true,
-                    handler: pluginConfig.handlerType,
-                    data: responseKeys,
-                }
-            } 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: apiSchema.single
-                .append({
-                    data: responseSchemas.response,
-                })
-                .label('question_list_res'),
-            failAction: 'log',
-        },
-    },
-}

backend/lib/routes/survey/responses.js

@@ -1,71 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-const apiSchema = require('../../schemas/api')
-const surveyResponseSchema = require('../../schemas/responses')
-const params = require('../../schemas/params')
-
-const pluginConfig = {
-    handlerType: 'survey',
-    docs: {
-        description: 'Get responses to questions',
-        notes: 'Returns a list of all survey responses for a user',
-    },
-}
-
-/** Validator functions by request method */
-const validators = {
-    /** Validate the header (cookie check) */
-    // headers: true,
-    /** Validate the route params (/active/{thing}) */
-    params: params.userId,
-    /** Validate the route query (/active/{thing}?limit=10&offset=10) */
-    // query: true,
-    /** Validate the incoming payload (POST method) */
-    // payload: true,
-}
-const responseSchemas = {
-    response: surveyResponseSchema.keys,
-}
-
-module.exports = {
-    method: 'GET',
-    path: '/questions',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        /** Protect this route with authentication? */
-        auth: false,
-
-        handler: async function (request, h) {
-            const { responseService } = request.services()
-            const responseKeys = await responseService.getResponseKeys()
-            try {
-                return {
-                    ok: true,
-                    handler: pluginConfig.handlerType,
-                    data: responseKeys,
-                }
-            } 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: apiSchema.single
-                .append({
-                    data: responseSchemas.response,
-                })
-                .label('response_list_res'),
-            failAction: 'log',
-        },
-    },
-}

backend/lib/routes/tag/get.js

@@ -1,86 +0,0 @@
-'use strict'
-
-const apiSchema = require('../../schemas/api')
-const errorSchema = require('../../schemas/errors')
-const Joi = require('joi')
-
-const pluginConfig = {
-    handlerType: 'get',
-    docs: {
-        description: 'Get tags based on membership id',
-        notes: 'returns from the Tag Associations Table',
-    },
-}
-
-const responseSchemas = {
-    tags: Joi.array().items(Joi.object()),
-    error: errorSchema.single,
-}
-
-const validators = {
-    params: Joi.object({
-        profile_id: Joi.string(),
-        grouping_id: Joi.string(),
-    }),
-    query: Joi.object({ category: Joi.string() }),
-}
-
-module.exports = {
-    method: 'GET',
-    path: '/{profile_id}/tags/{grouping_id}',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        /** Protect this route with authentication? */
-        auth: false,
-        cors: true,
-        handler: async function (request, h) {
-            const { grouping_id, profile_id } = request.params
-            const { profileService } = request.server.services()
-            const { category } = request.query
-            const revealedTags = await profileService.getTagsFor(
-                profile_id,
-                grouping_id,
-                category,
-            )
-            try {
-                return h
-                    .response({
-                        ok: true,
-                        handler: pluginConfig.handlerType,
-                        data: revealedTags,
-                    })
-                    .code(200)
-            } catch (err) {
-                return h
-                    .response({
-                        ok: false,
-                        handler: pluginConfig.handlerType,
-                        data: { error: `${err}` },
-                    })
-                    .code(409)
-            }
-        },
-        /** Validate based on validators object */
-        validate: {
-            ...validators,
-            failAction: 'log',
-        },
-
-        /** Validate the server response */
-        response: {
-            status: {
-                200: apiSchema.single
-                    .append({
-                        data: responseSchemas.tags,
-                    })
-                    .label('tags_res'),
-                409: apiSchema.single
-                    .append({
-                        data: responseSchemas.error,
-                    })
-                    .label('error_single_res'),
-            },
-        },
-    },
-}

backend/lib/routes/tag/reveal.js

@@ -1,91 +0,0 @@
-'use strict'
-
-const apiSchema = require('../../schemas/api')
-const errorSchema = require('../../schemas/errors')
-const params = require('../../schemas/params')
-const Joi = require('joi')
-
-const pluginConfig = {
-    handlerType: 'reveal',
-    docs: {
-        description: 'Reveals part of a profile based on tag',
-        notes: 'returns from the Tag Associations Table',
-    },
-}
-
-const responseSchemas = {
-    tags: Joi.array().items(Joi.object()),
-    error: errorSchema.single,
-}
-
-const validators = {
-    params: params.profileId.append({ tag_id: Joi.number() }),
-    payload: Joi.object({
-        profile_id: Joi.number(),
-        membership_id: Joi.string().optional(),
-    }),
-}
-
-module.exports = {
-    method: 'POST',
-    path: '/{profile_id}/reveal/{tag_id}',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        /** Protect this route with authentication? */
-        auth: false,
-        cors: true,
-        handler: async function (request, h) {
-            const { profile_id, tag_id } = request.params
-            const { profileService } = request.server.services()
-
-            const revealedTags = await profileService.revealProfileInfo({
-                profile_id,
-                tag_id,
-                is_deleted: false,
-            })
-            try {
-                const tag = profileService.tagLookup[tag_id]
-                if (!tag || tag.tag_category != 'reveal') {
-                    throw `cannot reveal ${tag} tag`
-                }
-                return h
-                    .response({
-                        ok: true,
-                        handler: pluginConfig.handlerType,
-                        data: revealedTags,
-                    })
-                    .code(200)
-            } catch (err) {
-                return h
-                    .response({
-                        ok: false,
-                        handler: pluginConfig.handlerType,
-                        data: { error: `${err}` },
-                    })
-                    .code(409)
-            }
-        },
-        /** Validate based on validators object */
-        validate: {
-            ...validators,
-            failAction: 'log',
-        },
-
-        /** Validate the server response */
-        response: {
-            status: {
-                200: apiSchema.single
-                    .append({
-                        data: responseSchemas.tags,
-                    })
-                    .label('reveal_res'),
-                409: apiSchema.single
-                    .append({
-                        data: responseSchemas.error,
-                    })
-                    .label('error_single_res'),
-            },
-        },
-    },
-}

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

@@ -1,119 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-const errorSchema = require('../../schemas/errors')
-const params = require('../../schemas/params')
-
-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: params.userId,
-
-    /** 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(),
-        user_name: Joi.string(),
-    }).label('created_profile'),
-    error: errorSchema.single,
-}
-
-module.exports = {
-    method: 'POST',
-    path: '/{user_id}/profile',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        /** Protect this route with authentication? */
-        auth: false,
-        cors: true,
-        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
-                /** Don't log password in response table */
-                const resWithoutPass = res.filter(r => {
-                    return r.response_key_id !== 9
-                })
-                const profile =
-                    await profileService.saveResponsesCreateProfileFor(
-                        userId,
-                        resWithoutPass,
-                    )
-                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(409)
-            }
-        },
-
-        /** 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,
-                }).label('created_profile_res'),
-                409: Joi.object({
-                    ok: Joi.bool(),
-                    handler: Joi.string(),
-                    data: responseSchemas.error,
-                }).label('error_single_res'),
-            },
-        },
-    },
-}

backend/lib/routes/user/get-session.js

@@ -1,69 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-
-const pluginConfig = {
-    handlerType: 'authentication',
-    docs: {
-        get: {
-            description: 'creates session token for authentication',
-            notes: 'Creates session token for authentication',
-        },
-    },
-}
-
-const validators = {
-    payload: Joi.object({
-        payload: Joi.object({
-            email: Joi.string(),
-            name: Joi.string(),
-            seeking: Joi.string(),
-        }),
-    }),
-}
-
-module.exports = {
-    method: 'POST',
-    path: '/token',
-    options: {
-        ...pluginConfig.docs.get,
-        tags: ['api'],
-        auth: false,
-        cors: {
-            headers: ['Authorization', 'Content-Type'],
-            exposedHeaders: ['Authorization', 'Access-Control-Expose-Headers'],
-        },
-        handler: async function (request, h) {
-            const { userService } = request.server.services()
-            const res = request.payload
-            // NOTE: Session Token set for 5 minutes expiration (default)
-            const sessionToken = await userService.createToken(res, 600)
-            try {
-                const response = h.response({
-                    ok: true,
-                    handler: pluginConfig.handlerType,
-                    data: sessionToken,
-                })
-                response.header('Authorization', sessionToken)
-                return response
-            } catch (err) {
-                return {
-                    ok: false,
-                    handler: pluginConfig.handlerType,
-                    data: {
-                        error: err,
-                    },
-                }
-            }
-        },
-        validate: {
-            ...validators,
-            failAction: 'log',
-        },
-        response: {
-            // TODO: change back to accommodate new h.response return values
-            schema: Joi.any().label('get_session_res'),
-            failAction: 'log',
-        },
-    },
-}

backend/lib/routes/user/authentication.js → backend/lib/routes/user/get-user.js

@@ -1,44 +1,37 @@
-'use strict'
-
 const Joi = require('joi')
-const params = require('../../schemas/params')
 
 const pluginConfig = {
-    handlerType: 'password',
+    handlerType: 'user',
     docs: {
         get: {
-            description: 'get password',
-            notes: 'Returns a password by the user email passed in the path',
+            description: 'get user',
+            notes: 'Returns a user by the email passed in the path',
         },
     },
 }
 
-/** Validator functions by request method */
 const validators = {
-    /** Validate the route params (/active/{thing}) */
-    params: params.userEmail,
+    params: Joi.object({ user_email: Joi.string() }),
 }
 
 module.exports = {
     method: 'GET',
-    path: '/{user_email}/password',
+    path: '/{user_email}',
     options: {
         ...pluginConfig.docs.get,
         tags: ['api'],
         // auth: 'default_jwt',
         auth: false,
         cors: true,
-        handler: async function (request, h) {
+        handler: async (request, h) => {
             try {
                 const { userService } = request.services()
-                const userEmail = request.params.user_email
-
-                const password = await userService.getPassword(userEmail)
-
+                const email = request.params.user_email
+                const user = await userService.findByEmail(email)
                 return {
                     ok: true,
                     handler: pluginConfig.handlerType,
-                    data: { password: password },
+                    data: { user },
                 }
             } catch (err) {
                 return {

backend/lib/routes/user/login.js

@@ -1,101 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-const errorSchema = require('../../schemas/errors')
-const userSchema = require('../../schemas/user')
-
-const pluginConfig = {
-    handlerType: 'user',
-    docs: {
-        description: 'login',
-        notes: 'Attempt login',
-    },
-}
-
-/** Validator functions by request method */
-const validators = {
-    post: {
-        payload: Joi.object({
-            user_email: Joi.string(),
-            password: Joi.string(),
-        }),
-    },
-    user: userSchema.single,
-    error: errorSchema.single,
-}
-
-module.exports = {
-    method: 'POST',
-    path: '/login',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        auth: false,
-        cors: true,
-        handler: async function (request, h) {
-            try {
-                const { userService } = request.server.services()
-                const res = request.payload
-
-                // Callback to use as transaction
-                const login = async txn => {
-                    return await userService.login(
-                        {
-                            email: res.user_email,
-                            password: res.password,
-                        },
-                        txn,
-                    )
-                }
-
-                // Bound context from your plugin server declaration
-                await h.context.transaction(login)
-
-                // Uses Same Logic Behind Initial Sign Up,
-                // passing expected credentials to be used for logging in
-                const { userCredentials, token } =
-                    await userService.makeUserCredentials(res.user_email)
-
-                return {
-                    ok: true,
-                    handler: pluginConfig.handlerType,
-                    data: {
-                        user_email: userCredentials.email,
-                        jwt: token,
-                        answered: userCredentials,
-                    },
-                }
-            } catch (err) {
-                console.error(err)
-                return {
-                    ok: false,
-                    handler: pluginConfig.handlerType,
-                    data: { error: `${err}` },
-                }
-            }
-        },
-        validate: validators.post,
-        response: {
-            status: {
-                201: Joi.object({
-                    ok: Joi.bool(),
-                    handler: Joi.string(),
-                    data: Joi.object({
-                        user_email: Joi.string(),
-                        jwt: Joi.string(),
-                        answered: Joi.object({
-                            email: Joi.string(),
-                            name: Joi.string(),
-                            seeking: Joi.string(),
-                        }),
-                    }),
-                }).label('login_res'),
-                409: Joi.object({
-                    ok: Joi.bool(),
-                    handler: Joi.string(),
-                    data: validators.error,
-                }).label('login_error'),
-            },
-        },
-    },
-}

backend/lib/routes/user/remove-session.js

@@ -1,59 +0,0 @@
-'use strict'
-
-const { plugin } = require('@hapi/inert')
-const Joi = require('joi')
-
-const pluginConfig = {
-    handlerType: 'jwt',
-    docs: {
-        get: {
-            description: 'removes sessionToken from activeSessions upon logout',
-            notes: 'On logout, activeSessions no longer holds onto user credentials',
-        },
-    },
-}
-
-module.exports = {
-    method: 'POST',
-    path: '/remove-session',
-    options: {
-        ...pluginConfig.docs.get,
-        tags: ['api'],
-        auth: false,
-        cors: {
-            headers: ['Authorization', 'Content-Type'],
-            exposedHeaders: ['Authorization', 'Access-Control-Expose-Headers'],
-        },
-        handler: async function (request, h) {
-            const hashedSessionToken = request.payload
-            const { userService } = request.server.services()
-            try {
-                await userService.removeSession(hashedSessionToken)
-                return {
-                    ok: true,
-                    handler: pluginConfig.handlerType,
-                    data: {
-                        sessionTokenIsRemoved: true,
-                    },
-                }
-            } catch (err) {
-                return {
-                    ok: false,
-                    handler: pluginConfig.handlerType,
-                    data: { error: err.message },
-                }
-            }
-        },
-        validate: {
-            failAction: 'log',
-        },
-        response: {
-            schema: Joi.object({
-                ok: Joi.bool(),
-                handler: Joi.string(),
-                data: Joi.object(),
-            }).label('validate_session_res'),
-            failAction: 'log',
-        },
-    },
-}

backend/lib/routes/user/send-email.js

@@ -1,82 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-
-const pluginConfig = {
-    handlerType: 'email',
-    docs: {
-        get: {
-            description: 'sends confirmation email',
-            notes: 'Stores the email in memory in a hash and sends confirmation email for signup',
-        },
-    },
-}
-
-const validators = {
-    payload: Joi.object({
-        email: Joi.string(),
-        name: Joi.string(),
-        seeking: Joi.string(),
-        sessionToken: Joi.string(),
-    }),
-}
-
-module.exports = {
-    method: 'POST',
-    path: '/send-email/',
-    options: {
-        ...pluginConfig.docs.get,
-        tags: ['api'],
-        auth: false,
-        cors: true,
-        handler: async function (request, h) {
-            const { userService } = request.server.services()
-            const userCredentials = request.payload
-            try {
-                const emailSent = await userService.emailSent(userCredentials)
-                const hashedSessionToken = Object.keys(
-                    userService.activeSessions,
-                ).find(hashedToken => {
-                    return (
-                        userService.activeSessions[`${hashedToken}`].email ===
-                        userCredentials.email
-                    )
-                })
-                // Registers the activeSessions object for use by jwt auth strategy
-                request.server.app.activeSessions = userService.activeSessions
-                if (!hashedSessionToken?.length) {
-                    throw Error('hashedSessionToken not Found!!')
-                }
-                return {
-                    ok: true,
-                    handler: pluginConfig.handlerType,
-                    data: {
-                        emailSentSuccessfully: emailSent.wasSuccessfull,
-                        hashedSessionToken,
-                    },
-                }
-            } catch (err) {
-                console.log('err :=>', err)
-                return {
-                    ok: false,
-                    handler: pluginConfig.handlerType,
-                    data: {
-                        error: err,
-                    },
-                }
-            }
-        },
-        validate: {
-            ...validators,
-            failAction: 'log',
-        },
-        response: {
-            schema: Joi.object({
-                ok: Joi.bool(),
-                handler: Joi.string(),
-                data: Joi.object(),
-            }).label('email_res'),
-            failAction: 'log',
-        },
-    },
-}

backend/lib/routes/user/signup.js

@@ -1,105 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-const errorSchema = require('../../schemas/errors')
-const userSchema = require('../../schemas/user')
-
-const pluginConfig = {
-    handlerType: 'user',
-    docs: {
-        description: 'Create a user',
-        notes: 'Create a user and other things',
-    },
-}
-
-const validators = {
-    post: {
-        payload: userSchema.userSignup,
-    },
-}
-
-const responseSchemas = {
-    response: Joi.object({
-        user_id: Joi.number(),
-        user_name: Joi.string(),
-        user_email: Joi.string(),
-        is_poster: Joi.number(),
-        is_admin: Joi.number(),
-        is_verified: Joi.number(),
-    }).label('created_user'),
-    error: errorSchema.single,
-}
-
-// Brevo logic will go here,
-// send Brevo email with link that has jwt in it?
-
-module.exports = {
-    method: 'POST',
-    path: '/signup',
-    options: {
-        ...pluginConfig.docs,
-        tags: ['api'],
-        /** Protect this route with authentication? */
-        auth: false,
-        cors: true,
-        handler: async function (request, h) {
-            const { userService } = request.server.services()
-            const res = request.payload
-            const userName = res.user_name
-            const userEmail = res.user_email
-            const userType = res.is_poster
-            const userPw = res.user_pass ? res.user_pass : 'changeme'
-            try {
-                const user = await userService.signup({
-                    password: userPw,
-                    userInfo: {
-                        user_name: userName,
-                        user_email: userEmail,
-                        is_poster: userType,
-                        is_admin: 0,
-                        is_verified: 0,
-                    },
-                    created_at: Date.now(),
-                })
-                return h
-                    .response({
-                        ok: true,
-                        handler: pluginConfig.handlerType,
-                        data: user,
-                    })
-                    .code(201)
-            } catch (err) {
-                console.error('ERROR :=>', err)
-                return h
-                    .response({
-                        ok: false,
-                        handler: pluginConfig.handlerType,
-                        data: { error: `${err}` },
-                    })
-                    .code(409)
-            }
-        },
-
-        /** Validate based on validators object */
-        validate: {
-            ...validators.post,
-            failAction: 'log',
-        },
-
-        /** Validate the server response */
-        response: {
-            status: {
-                201: Joi.object({
-                    ok: Joi.bool(),
-                    handler: Joi.string(),
-                    data: responseSchemas.response,
-                }).label('created_user_res'),
-                409: Joi.object({
-                    ok: Joi.bool(),
-                    handler: Joi.string(),
-                    data: responseSchemas.error,
-                }).label('error_single_res'),
-            },
-        },
-    },
-}

backend/lib/routes/user/token.js

@@ -1,69 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-
-const pluginConfig = {
-    handlerType: 'authentication',
-    docs: {
-        get: {
-            description: 'creates session token for authentication',
-            notes: 'Creates session token for authentication',
-        },
-    },
-}
-
-const validators = {
-    payload: Joi.object({
-        payload: Joi.object({
-            email: Joi.string(),
-            name: Joi.string(),
-            seeking: Joi.string(),
-        }),
-    }),
-}
-
-module.exports = {
-    method: 'POST',
-    path: '/token',
-    options: {
-        ...pluginConfig.docs.get,
-        tags: ['api'],
-        auth: false,
-        cors: {
-            headers: ['Authorization', 'Content-Type'],
-            exposedHeaders: ['Authorization', 'Access-Control-Expose-Headers'],
-        },
-        handler: async function (request, h) {
-            const { userService } = request.server.services()
-            const res = request.payload
-            // NOTE: Session Token set for 5 minutes expiration (default)
-            const sessionToken = await userService.createToken(res, 600)
-            try {
-                const response = h.response({
-                    ok: true,
-                    handler: pluginConfig.handlerType,
-                    data: sessionToken,
-                })
-                response.header('Authorization', sessionToken)
-                return response
-            } catch (err) {
-                return {
-                    ok: false,
-                    handler: pluginConfig.handlerType,
-                    data: {
-                        error: err,
-                    },
-                }
-            }
-        },
-        validate: {
-            ...validators,
-            failAction: 'log',
-        },
-        response: {
-            // TODO: change back to accommodate new h.response return values
-            schema: Joi.any().label('get_session_res'),
-            failAction: 'log',
-        },
-    },
-}

backend/lib/routes/user/validate-session.js

@@ -1,77 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-
-const pluginConfig = {
-    handlerType: 'jwt',
-    docs: {
-        get: {
-            description: 'validates session token for each step of survey',
-            notes: 'Validates session token for each step of survey',
-        },
-    },
-}
-
-const validators = {
-    payload: Joi.string(),
-}
-
-module.exports = {
-    method: 'POST',
-    path: '/validate-session',
-    options: {
-        ...pluginConfig.docs.get,
-        tags: ['api'],
-        auth: false,
-        cors: {
-            headers: ['Authorization', 'Content-Type'],
-            exposedHeaders: ['Authorization', 'Access-Control-Expose-Headers'],
-        },
-        handler: async function (request, h) {
-            const hashedSessionToken = request.payload
-            const { userService, profileService } = request.server.services()
-            try {
-                const validatedSessionToken =
-                    userService.validateSession(hashedSessionToken)
-                if(validatedSessionToken?.email) throw new Error(`Could not validate token based on payload: ${request.payload}`)
-                
-                const user = await userService.findByUserEmail(
-                    validatedSessionToken.email,
-                )
-                const type = user.is_poster === 1 ? 'poster' : 'seeker'
-                const profiles = await profileService.getCompleteProfilesFor(
-                    user.user_id,
-                    type,
-                )
-                // TODO: handle user with multiple profiles...
-                const profileId = profiles[0].profile_id
-                return {
-                    ok: true,
-                    handler: pluginConfig.handlerType,
-                    data: {
-                        ...validatedSessionToken,
-                        profileId: profileId,
-                    },
-                }
-            } catch (err) {
-                return {
-                    ok: false,
-                    handler: pluginConfig.handlerType,
-                    data: { error: err.message },
-                }
-            }
-        },
-        validate: {
-            ...validators,
-            failAction: 'log',
-        },
-        response: {
-            schema: Joi.object({
-                ok: Joi.bool(),
-                handler: Joi.string(),
-                data: Joi.object(),
-            }).label('validate_session_res'),
-            failAction: 'log',
-        },
-    },
-}

backend/lib/routes/user/verify-session.js

@@ -1,90 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-
-const pluginConfig = {
-    handlerType: 'email',
-    docs: {
-        get: {
-            description: 'verifies confirmation email',
-            notes: 'Verifies the email from the stored hash',
-        },
-    },
-}
-
-const validators = {
-    params: Joi.object({
-        hashedSessionToken: Joi.string(),
-    }),
-}
-
-module.exports = {
-    method: 'GET',
-    path: '/verify/{hashedSessionToken}',
-    options: {
-        ...pluginConfig.docs.get,
-        tags: ['api'],
-        auth: false,
-        cors: true,
-        handler: async function (request, h) {
-            const { userService } = request.server.services()
-            const hash = request.params.hashedSessionToken
-            try {
-                const hashToMatch = Object.keys(
-                    userService.activeSessions,
-                ).find(hashedToken => {
-                    return hashedToken === hash
-                })
-                if (!hashToMatch?.length) {
-                    throw Error('hashToMatch Not Found!')
-                }
-                const now = Date.now()
-                const expiration = new Date(
-                    userService.activeSessions[`${hash}`].expiration,
-                )
-                if (now > expiration) {
-                    delete userService.activeSessions[hashToMatch]
-                    throw new Error(
-                        'you took to long to respond to the email...',
-                    )
-                }
-                if (!hashToMatch) {
-                    throw new Error('no record of email in cache')
-                }
-                // NOTE: When user responds to email,
-                // boolean value is set to true, allowing user back into the survey
-                userService.activeSessions[
-                    hashToMatch
-                ].emailWasRespondedTo = true
-                return {
-                    ok: true,
-                    handler: pluginConfig.handlerType,
-                    data: {
-                        hashesMatch: hashToMatch === hash,
-                    },
-                }
-            } catch (err) {
-                console.log('err :=>', err)
-                return {
-                    ok: false,
-                    handler: pluginConfig.handlerType,
-                    data: {
-                        error: err,
-                    },
-                }
-            }
-        },
-        validate: {
-            ...validators,
-            failAction: 'log',
-        },
-        response: {
-            schema: Joi.object({
-                ok: Joi.bool(),
-                handler: Joi.string(),
-                data: Joi.object(),
-            }).label('verify_email_res'),
-            failAction: 'log',
-        },
-    },
-}

backend/lib/schemas/api.js

@@ -1,12 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-
-const singleApiResponse = Joi.object({
-    ok: Joi.bool(),
-    handler: Joi.string(),
-}).label('api_single')
-
-module.exports = {
-    single: singleApiResponse
-}

backend/lib/schemas/authentication.js

@@ -1,13 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-
-const userAuth = Joi.object({
-    user_email: Joi.string(),
-    created_at: Joi.date(),
-    token: Joi.binary().allow(null)
-}).label('user_auth')
-
-module.exports = {
-    userAuth
-}

backend/lib/schemas/errors.js

@@ -1,11 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-
-const singleError = Joi.object({
-    error: Joi.string(),
-}).label('error_single')
-
-module.exports = {
-    single: singleError
-}

backend/lib/schemas/filter.js

@@ -1,8 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-const profileSchema = require('./profiles')
-
-module.exports = { 
-    matchPool: Joi.array().items(profileSchema.single).label('matchPool')
-}

backend/lib/schemas/groupings.js

@@ -1,28 +0,0 @@
-'use strict'
-
-const Joi = require('joi')
-const surveyProfileSchema = require('./profiles')
-
-const singleGrouping = Joi.object({
-    grouping_id: Joi.number(),
-    grouping_name: Joi.string(),
-    grouping_type: Joi.string(),
-    is_paired: Joi.boolean(),
-}).label('grouping_single')
-
-const singleWithProfile = Joi.object({
-    grouping_id: Joi.number(),
-    grouping_name: Joi.string(),
-    grouping_type: Joi.string(),
-    is_paired: Joi.boolean(),
-    profile: surveyProfileSchema.single,
-}).label('grouping_single_with_profile')
-
-module.exports = {
-    single: singleGrouping,
-    singleWithProfile,
-    list: Joi.array().items(singleGrouping).label('grouping_list'),
-    listWithProfiles: Joi.array()
-        .items(singleWithProfile)
-        .label('grouping_list_with_profiles'),
-}

backend/lib/schemas/health.js

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