ddstats-server/api/maps.js

import { Router } from 'express'
import { sqlite } from '../db/init.js'

const mapApi = Router()

mapApi.get(
    '/count',
    (req, res) => {
        const totalMaps = sqlite.prepare(`SELECT COUNT(*) as amount FROM maps`).get()

        return res.json({
            success: true,
            response: totalMaps.amount,
        })
    }
)

mapApi.get(
    '/get/:map',
    (req, res) => {
        let map = req.params.map

        /* Check if map exists */
        const check = sqlite.prepare(`SELECT map FROM maps WHERE map = ?`).get(map)
        if (!check) {
            return res.json({
                success: false,
                response: "No map found!",
            })
        }

        const info = sqlite.prepare(`SELECT * FROM maps WHERE map = ?`).get(map)

        /* TODO: Generate a table with this as a cache */
        /* Also generate indexes */
        const avgTime = sqlite.prepare(`SELECT avg(Time) as 'averageTime' FROM race WHERE map = ?`).get(map)
        const total = sqlite.prepare(`SELECT COUNT(*) as 'total' FROM race WHERE map = ?`).get(map)
        const unique = sqlite.prepare(`SELECT COUNT(distinct(name)) as 'unique' FROM race WHERE map = ?`).get(map)
        const teams = sqlite.prepare(`SELECT COUNT(distinct(ID)) as 'teams' FROM teamrace WHERE map = ?`).get(map)

        return res.json({
            success: true,
            response: {
                name: info.Map,
                category: info.Server,
                awardPoints: info.Points,
                rating: info.Stars,
                mapper: info.Mapper,
                release: info.Timestamp,
                /* TODO Get median time*/
                averageTime: avgTime.averageTime,
                finishes: {
                    unique: unique.unique,
                    total: total.total,
                    teams: teams.teams,
                }
            }
        })
    }
)

mapApi.get(
    '/getAll',
    (req, res) => {

        const allMaps = sqlite.prepare(
            `SELECT 
            map as name, 
            server as category, 
            points as awardPoints, 
            stars as rating, 
            mapper as mapper, 
            timestamp as release
        FROM maps`).all()

        return res.json({
            success: true,
            response: allMaps,
        })
    }
)

mapApi.get(
    '/category/:category',
    (req, res) => {
        let category = req.params.category

        /* Check if category exists */
        const check = sqlite.prepare(`SELECT server FROM maps WHERE server = ? LIMIT 1`).get(category)
        if (!check) {
            return res.json({
                success: false,
                response: "Invalid category name!",
            })
        }

        const allMaps = sqlite.prepare(
            `SELECT 
            map as name, 
            server as category, 
            points as awardPoints, 
            stars as rating, 
            mapper as mapper, 
            timestamp as release
        FROM maps WHERE server = ?`).all(category)

        return res.json({
            success: true,
            response: allMaps,
        })
    }
)

/* Searching allows you to attach sql LIKE %
 * Example to search for maps beginning with Kobra
 * You can do search for Kobra%

 * This thing is a complete mess, send help. BUT it does work <3 */
mapApi.get(
    '/search',
    async (req, res) => {
        /* Check if a query was provided */
        if (!req.query.q || !req.query.byMapper) {
            return res.json({
                success: false,
                response: "No query ('host/path?q=query') provided!"
            })
        }

        let query = req.query.q

        /* Set defaults */
        let limit = 20
        let offset = 0
        let sortBy = "timestamp"
        let order = "asc"
        let column = "map"
        let startsWith = ""

        if (req.query.limit)
            limit = req.query.limit

        if (req.query.sortBy)
            sortBy = req.query.sortBy

        if (req.query.order)
            order = req.query.order

        if (req.query.byMapper)
            column = "mapper"

        /* TODO: do this in one query? */
        const amount = sqlite.prepare(
            `SELECT COUNT(*) as amount FROM maps WHERE ${column} LIKE "${query}"`).get()

        let pages = Math.floor(amount.amount / limit)

        if (req.query.page)
            offset = (req.query.page * limit)

        const maps = sqlite.prepare(
            `SELECT * FROM maps WHERE ${column} LIKE "${query}" ORDER BY ${sortBy} ${order} LIMIT ? OFFSET ?`).all(limit, offset)

        return res.json({
            success: true,
            response: {
                amount: amount.amount,
                pages,
                maps,
            }
        })
    }
)

export default mapApi