add player weapon route

src/client/client.ts

@@ -1,5 +1,6 @@
 import { Router } from 'express'
 import weapons from './weapons'
+import player from './player'
 const router = Router()
 //timeout middleware ?
 router.get('/*', (req, res, next) => {
@@ -16,7 +17,7 @@ router.get('/players/:playerId', (req, res, next) => {})
 router.get('/servers/', (req, res, next) => {})
 router.get('/servers/:serverId/', (req, res, next) => {})
 router.get('/servers/:serverId/players', (req, res, next) => {})
-router.get('/servers/:serverId/players/:playerId', (req, res, next) => {})
+router.get('/servers/:serverId/player/:playerId', player)
 
-router.use('/', weapons)
+router.use('/servers/:serverId/weapons', weapons)
 export default router

src/client/player.ts

@@ -0,0 +1,113 @@
+import { RequestHandler } from 'express'
+import { param } from 'express-validator'
+import { validateErrors } from '../common'
+import cache from '../cache/redis'
+import { sql } from 'kysely'
+import db from '../db/db'
+
+const { count, max } = db.fn
+
+const middlewares: RequestHandler[] = [
+  param(['serverId', 'playerId']).exists().toInt().isInt(),
+  validateErrors,
+  async (req, res) => {
+    const server = Number(req.params.serverId)
+    const player = Number(req.params.playerId)
+    await processPlayerWeapons(server, player)
+    const killsData = await cache.HGETALL(
+      `servers:${server}:players:${player}:weapons:kills`
+    )
+    const deathData = await cache.HGETALL(
+      `servers:${server}:players:${player}:weapons:deaths`
+    )
+    const data: { [x: string]: { kills: string; deaths: string } } = {}
+    Object.keys(killsData).forEach((key) => {
+      data[key] = { kills: killsData[key], deaths: deathData[key] }
+    })
+
+    res.status(200).send(data)
+  }
+]
+
+async function processPlayerWeapons(server: number, player: number) {
+  let last_entry =
+    Number(
+      await cache.HGET(
+        `servers:${server}:players:${player}:weapons`,
+        'last_entry'
+      )
+    ) || 0
+  const newData = await db
+    .with('killdata', () =>
+      db
+        .selectFrom('kill')
+        .select([count('kill.id').as('num_kills'), 'kill.cause_of_death'])
+        .where('attacker_id', '=', player.toString())
+        .where('kill.id', '>', last_entry)
+        .where('kill.server', '=', server)
+        .whereRef('attacker_id', '!=', 'victim_id')
+        .groupBy('cause_of_death')
+    )
+    .with('deathdata', () =>
+      db
+        .selectFrom('kill')
+        .select([count('kill.id').as('num_deaths'), 'kill.cause_of_death'])
+        .where('victim_id', '=', player.toString())
+        .where('kill.id', '>', last_entry)
+        .where('kill.server', '=', server)
+        .groupBy('cause_of_death')
+    )
+    .selectFrom('killdata')
+    .select([
+      sql<number>`coalesce(killdata.num_kills, 0)`.as('kills'),
+      sql<number>`coalesce(deathdata.num_deaths, 0)`.as('deaths'),
+      sql<string>`COALESCE(killdata.cause_of_death, deathdata.cause_of_death)`.as(
+        'weapon'
+      ),
+      db
+        .selectFrom('kill')
+        .select(max('kill.id').as('last_entry'))
+        .as('last_entry')
+    ])
+    .fullJoin(
+      'deathdata',
+      'deathdata.cause_of_death',
+      'killdata.cause_of_death'
+    )
+    .orderBy('kills', 'desc')
+    .execute()
+  //if no new kills
+  if (newData.length == 0) {
+    return
+  }
+  last_entry = newData.reduce(
+    (acc, current) => (current.last_entry > acc ? current.last_entry : acc),
+    0
+  )
+  console.log(newData)
+  const promises: Promise<number>[] = []
+  newData.forEach(({ weapon, kills, deaths }) => {
+    promises.push(
+      cache.HINCRBY(
+        `servers:${server}:players:${player}:weapons:deaths`,
+        weapon,
+        deaths
+      ),
+      cache.HINCRBY(
+        `servers:${server}:players:${player}:weapons:kills`,
+        weapon,
+        kills
+      )
+    )
+  })
+  promises.push(
+    cache.HSET(
+      `servers:${server}:players:${player}:weapons`,
+      'last_entry',
+      newData[0].last_entry
+    )
+  )
+  await Promise.all(promises)
+}
+
+export default middlewares

src/client/weapons.ts

@@ -1,32 +1,24 @@
-import { Router } from 'express'
-import { param, validationResult } from 'express-validator'
+import { RequestHandler } from 'express'
+import { param } from 'express-validator'
+import { validateErrors } from '../common'
 import cache from '../cache/redis'
 import db from '../db/db'
-const router = Router()
+
 const { count, max } = db.fn
 
-router.get(
-  '/servers/:serverId/weapons',
+const middlewares: RequestHandler[] = [
   param('serverId').exists().toInt().isInt(),
+  validateErrors,
   async (req, res) => {
-    const errors = validationResult(req)
-    if (!errors.isEmpty()) {
-      console.error(JSON.stringify(errors))
-      return res.status(400).json({ errors: errors.array() })
-    }
-    if (!req.params) {
-      res.sendStatus(500)
-      return
-    }
     const server = Number(req.params.serverId)
-    await processTopWeapons(server)
+    await processWeapons(server)
     const data = await cache.HGETALL(`servers:${server}:weapons`)
     delete data.last_entry
     res.status(200).send(data)
   }
-)
+]
 
-async function processTopWeapons(server: number) {
+async function processWeapons(server: number) {
   let last_entry =
     Number(await cache.HGET(`servers:${server}:weapons`, 'last_entry')) || 0
   const newData = await db
@@ -34,7 +26,10 @@ async function processTopWeapons(server: number) {
     .select([
       count<number>('kill.id').as('num_kills'),
       'kill.cause_of_death',
-      max('kill.id').as('last_entry')
+      db
+        .selectFrom('kill')
+        .select(max('kill.id').as('last_entry'))
+        .as('last_entry')
     ])
     .where('server', '=', server)
     .where('kill.id', '>', last_entry)
@@ -60,4 +55,4 @@ async function processTopWeapons(server: number) {
   await Promise.all(promises)
 }
 
-export default router
+export default middlewares