Initial commit

Added prototype leaderboard component, util/scores, and scores migration

Author: jimmyl02

Dockerfile

@@ -13,4 +13,4 @@ COPY . .
 
 USER node
 
-CMD ["node", "index.js"]
+CMD ["node", "index.js"]

migrations/1581292018019_add-users.js

@@ -1,5 +1,4 @@
 exports.up = function (pgm) {
-  pgm.createExtension('uuid-ossp')
   pgm.createTable('users', {
     id: { type: 'uuid', primaryKey: true },
     name: { type: 'string', unique: true, notNull: true },
@@ -11,5 +10,4 @@ exports.up = function (pgm) {
 
 exports.down = function (pgm) {
   pgm.dropTable('users')
-  pgm.dropExtension('uuid-ossp')
 }

migrations/1581297115194_add-solves.js

@@ -0,0 +1,11 @@
+exports.up = function (pgm) {
+  pgm.createTable('solves', {
+    id: { type: 'uuid', primaryKey: true },
+    challengeid: { type: 'string', unique: true, notNull: true },
+    userid: { type: 'string', unique: true, notNull: true },
+  })
+}
+  
+exports.down = function (pgm) {
+  pgm.dropTable('solves')
+}

server/api/auth-login.js

@@ -0,0 +1,24 @@
+const { responses } = require('../responses')
+
+module.exports = {
+  method: 'post',
+  path: '/auth/login',
+  requireAuth: true,
+  schema: {
+    type: 'object',
+    properties: {
+      email: {
+        type: 'string'
+      },
+      password: {
+        type: 'string'
+      }
+    },
+    required: ['email', 'password']
+  },
+  handler: ({ req, uuid }) => {
+    return [responses.goodLogin, {
+      uuid
+    }]
+  }
+}

server/api/index.js

@@ -1,4 +1,66 @@
 const express = require('express')
+const Ajv = require('ajv')
+const { responses, responseList } = require('../responses')
+const auth = require('../auth')
+
 const router = express.Router()
 
-module.exports = router
+const routes = [
+  require('./auth-login'),
+  require('./leaderboard')
+]
+
+const routeValidators = routes.map((route) => new Ajv().compile(route.schema))
+
+routes.forEach((route, i) => {
+  router[route.method](route.path, async (req, res) => {
+    const sendResponse = (responseKind, data = null) => {
+      const response = responseList[responseKind]
+      if (response === undefined) {
+        throw new Error(`unknown response ${responseKind}`)
+      }
+      res.set('content-type', 'application/json')
+      res.status(response.status)
+      res.send(JSON.stringify({
+        kind: responseKind,
+        message: response.message,
+        data
+      }))
+    }
+
+    let uuid
+    if (route.requireAuth) {
+      const authHeader = req.get('authorization')
+      if (authHeader === undefined || !authHeader.startsWith('Bearer ')) {
+        sendResponse(responses.badToken)
+        return
+      }
+      uuid = await auth.token.getUserId(authHeader.slice('Bearer '.length))
+    }
+
+    const validator = routeValidators[i]
+    if (validator !== undefined && !validator(req.body)) {
+      sendResponse(responses.badBody)
+      return
+    }
+
+    let response
+    try {
+      response = await route.handler({
+        req,
+        uuid
+      })
+    } catch (e) {
+      sendResponse(responses.errorInternal)
+      console.error(e.stack)
+    }
+
+    if (response instanceof Array) {
+      sendResponse(...response)
+    } else {
+      sendResponse(response)
+    }
+  })
+})
+
+module.exports = router

server/api/leaderboard.js

@@ -0,0 +1,66 @@
+const db = require('../database')
+
+const { responses } = require('../responses')
+const challenges = require('../challenges')
+const { getScore } = require('../util/scores')
+
+module.exports = {
+  method: 'get',
+  path: '/leaderboard',
+  requireAuth: false,
+  schema: {},
+  handler: ({ req, uuid }) => {
+
+    let solveAmount = {}
+    let challengeValues = {}
+    let userSolves = {}
+    let userScores = []
+    const solves = db.leaderboard.getSolves()
+    const users = db.leaderboard.getUsers()
+
+    for(let i = 0; i < solves.length; i++){
+      // Accumulate in solveAmount
+      if(solveAmount[!solves[i].challengeid]){
+        solveAmount[solves[i].challengeid] = 1
+      }else{
+        solveAmount[solves[i].challengeid]++
+      }
+      // Store which challenges each user solved for later
+      if(!userSolves[solves[i].userid]){
+        userSolves[solves[i].userid] = [solves[i].challengeid]
+      }else{
+        userSolves[solves[i].userid].push(solves[i].challengeid)
+      }
+    }
+
+    for(let i = 0; i < challenges.getAllChallenges().length; i++){
+      const challenge = challenges.getAllChallenges()[i]
+      if(!solveAmount[challenge.id]){
+        // There are currently no solves
+        challengeValues[challenge.id] = getScore('dynamic', challlenge.points.min, challenge.points.max, 0)
+      }else{
+        challengeValues[challenge.id] = getScore('dynamic', challlenge.points.min, challenge.points.max, solveAmount[challenge.id])
+      }
+    }
+
+    for(let i = 0; i < users.length; i++){
+      if(!userSovles[users[i].userid]){
+        // The user has not solved anything
+        userScores.push([users[i].username, 0])
+      }else{
+        let currScore = 0
+        for(let j = 0; j < userSolves[users[i].userid]; j++){
+          // Add the score for the specific solve loaded fr om the challengeValues array using ids
+          currScore += challengeValues[userSolves[users[i].userid][j]]
+        }
+        userScores.push([users[i].username, currScore])
+      }
+    }
+
+    const sortedUsers = userScores.sort((a, b) => b[1] - a[1])
+
+    return [responses.goodLeaderboard, {
+      sortedUsers
+    }]
+  }
+}

server/auth/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+    token: require('./token')
+  }

server/database/leaderboard.js

@@ -0,0 +1,14 @@
+const db = require('./db')
+
+const ret = {
+  getSolves: () => {
+    return db.query('SELECT * FROM solves')
+      .then(res => res.rows)
+  },
+  getUsers: () => {
+    return db.query('SELECT id AS userid, username FROM users')
+      .then(res => res.rows)
+  }
+}
+
+module.exports = ret

server/responses/index.js

@@ -0,0 +1,53 @@
+const responseList = {
+    goodLogin: {
+      status: 200,
+      message: 'The login was successful.'
+    },
+    goodRegister: {
+      status: 200,
+      message: 'The account was created.'
+    },
+    badEmail: {
+      status: 400,
+      message: 'The email address is malformed.'
+    },
+    badUnknownEmail: {
+      status: 404,
+      message: 'The account does not exist.'
+    },
+    badKnownEmail: {
+      status: 409,
+      message: 'An account with this email already exists.'
+    },
+    badPassword: {
+      status: 401,
+      message: 'The password is incorrect.'
+    },
+    goodLeaderboard: {
+      status: 200,
+      message: 'The retrieval of the leaderbard was successful.'
+    },
+    badBody: {
+      status: 400,
+      message: 'The request body does not meet requirements.'
+    },
+    badToken: {
+      status: 401,
+      message: 'The token provided is invalid.'
+    },
+    errorInternal: {
+      status: 500,
+      message: 'An internal error occurred.'
+    }
+  }
+  
+  const responses = {}
+  Object.keys(responseList).forEach((kind) => {
+    responses[kind] = kind
+  })
+  
+  module.exports = {
+    responseList,
+    responses
+  }
+  

server/util/scores.js

@@ -0,0 +1,12 @@
+const threshold = 100;
+
+module.exports = {
+    getScore: (type, minVal, maxVal, solves) => {
+      if(type === 'static'){
+        return minVal
+      }else{
+        // Assumes dynamic if type is not static
+        return Math.ceil((minVal - maxVal) / Math.pow(threshold, 2) * Math.pow(solves, 2) + maxVal)
+      }
+    }
+  }