kannon/classes/Api.js

const AudioServer = require("./AudioServer");

class Api {

    constructor() {
        this.get = new Map();
        this.post = new Map();
        this.#setup();
    }

    async handleRequest(request) {
        if (request === undefined) {
            return this.#createRequestResult(500);
        }
        const fn = this.#getFunction(request.url, request.method.toLowerCase());
        if (fn === undefined) {
            return this.#createRequestResult(501);
        }
        await fn(await this.#getRequestArguments(request));
        return this.#createRequestResult();
    }

    #getRequestArguments(request) {
        if (request === undefined) {
            return;
        }
        return new Promise((resolve, reject) => {
            let args = '';
            request.on('data', (data) => {
                args += data;
            });
            request.on('end', () => {
                if (args == undefined || args.length == 0) {
                    return resolve();
                }
                return resolve(new URLSearchParams(args));
            });
        });
    }

    #createRequestResult(code, message) {
        if (code === undefined) {
            code = 200;
        }
        const result = {
            code: code
        };
        if (message !== undefined) {
            result.message = message;
        }
        return result;
    }

    #setup() {
        this.#registerEndpoint(constants.API_PLAY, constants.REQUEST_METHOD_POST, async (args) => {
            const id = args.get('id');
            if (id === undefined) {
                return;
            }
            if (global.audioserver !== undefined) {
                await global.audioserver.destroy();
            }
            let track;
            try {
                track = await database.models.Track.findOne({
                    where: {
                        id: id
                    }
                });
            } catch (err) {
                logger.error('error finding track \'' + id + '\' > ' + err);
            }
            if (track === undefined) {
                return;
            }
            global.audioserver = new AudioServer(track.file);
        });
        this.#registerEndpoint(constants.API_RESUME, constants.REQUEST_METHOD_POST, async (args) => {
            if (global.audioserver === undefined) {
                return;
            }
            await global.audioserver.destroy();
            global.audioserver = new AudioServer('/home/velvettear/mounts/kingston/public/YOU_SUFFER.mp3', global.audioserver.progress);
        });
        this.#registerEndpoint(constants.API_PAUSE, constants.REQUEST_METHOD_POST, async (args) => {
            if (global.audioserver === undefined) {
                return;
            }
            global.audioserver.pausePlayback();
        });
        this.#registerEndpoint(constants.API_STOP, constants.REQUEST_METHOD_POST, async () => {
            if (global.audioserver === undefined) {
                return;
            }
            global.audioserver.stopPlayback();
        });
    }

    #getFunction(url, method) {
        if (url === undefined || method === undefined || this[method] === undefined) {
            return;
        }
        return this[method].get(url);
    }

    #registerEndpoint(url, method, fn) {
        if (url === undefined || method === undefined || fn === undefined || this[method] === undefined) {
            return false;
        }
        this[method].set(url, fn);
        return true;
    }

}

module.exports = Api;