craftlabHttpServer/src/routerUtils.js

const mime = require('mime-types');
const path = require('path');
const fs = require('fs');
const Security = require('./security.js');
const CONFIG = require('./config.js');

function RouterUtils(app) {
    this.app = app;
}

RouterUtils.prototype.httpResponse = function(res, code, response) {
    res.writeHead(code);
    res.end(response);
    return true;
}

RouterUtils.prototype.requireLogin =function(req, res) {
    if (Security.isLoggedUser(req.cookies))
    {
        req.loggedUser = Security.getLoggedUser(req.cookies);
        req.loggedSession = Security.getSessionId(req.cookies);
        return false;
    }
    this.redirect(res, '/login?page='+encodeURIComponent(req.url));
    return true;
};

RouterUtils.prototype.onApiRequest = function(req, res) {
    this.onRequest(req);
    req.sessionObj = Security.getSessionObj(req.cookies);
    if (req.sessionObj === null) {
        const log = Security.createSession(req);
        res.setHeader("Set-Cookie", Security.SESSION_COOKIE +'='+log.key);
        req.sessionObj = log.data;
    }
};

RouterUtils.prototype.apiRequireLogin =function(req, res, validTokens) {
    if (Security.isLoggedUser(req.cookies))
    {
        req.loggedUser = Security.getLoggedUser(req.cookies);
        req.loggedSession = Security.getSessionId(req.cookies);
        return false;
    }
    if (validTokens && req.body?.apiKey && validTokens.indexOf(req.body?.apiKey) >= 0)
    {
        req.loggedUser = req.body.apiKey;
        req.loggedSession = "";
        return false;
    }
    return this.httpResponse(res, 403, "Unauthorized Access");
};

RouterUtils.prototype.redirect = function(res, url) {
    res.writeHead(302, { Location: url });
    res.end();
}

RouterUtils.prototype.prepareCookie = function(req) {
    req.cookies = {};
    let arr = ((req.headers?.cookie || "").split(';').map(i => i.split('=', 2))).forEach(i => { req.cookies[i[0].trim()] = decodeURIComponent(i[1]).trim();});
}

RouterUtils.prototype.onRequest = function(req) {
    this.prepareCookie(req);
}

RouterUtils.prototype.readPostBody = function(req, res) {
    const now = Math.floor(Date.now() / 1000);
    return new Promise((ok, ko) => {
        if (req.headers['content-type'] !== 'application/json') {
            console.error("Unexpected input from query: wrong Content-Type");
            ko();
            return;
        }
        let data = null;
        try {
            data = JSON.parse(req.body.data);
        } catch (e) {
            console.error("Unexpected input from query: invalid JSON");
            ko();
            return;
        }
        if (!data.time || Math.abs(now - data.time) > 3) {
            console.error("Unexpected input from query: Invalid time");
            ko();
            return;
        }
        if (!data.hostname) {
            console.error("Unexpected input from query: missing hostname");
            ko();
            return;
        }
        req.data = data;
        ok();
    });
}

RouterUtils.prototype.apiError = function(res) {
    res.writeHead(400, { "Content-Type": "application/json"});
    res.end();
}

RouterUtils.prototype.jsonResponse = function(res, data) {
    res.writeHead(200, { "Content-Type": "application/json"});
    if (typeof data !== 'string')
        data = JSON.stringify(data);
    res.end(data);
}

RouterUtils.prototype.onPageNotFound = function(res) {
    return this.httpResponse(res, 404, "Page not found...");
}

RouterUtils.prototype.staticServe = async function(res, filePath) {
    return new Promise((ok, ko) => {
        try {
            const stream = fs.createReadStream(filePath);
            let onError = false;
            stream.once('error', err => {
                ko(err);
                onError = true;
            });
            const fileSize = fs.statSync(filePath)?.size || undefined;
            if (!stream || !fileSize || onError) {
                console.error("RouterUtils::staticGet", filePath, err);
                this.httpResponse(res, 500, "Internal Server Error");
                return ko(err);
            }
            res.writeHead(200, {
                "Content-Type": mime.contentType(path.basename(filePath)),
                "Content-Length": fileSize
            });
            stream.pipe(res);
            stream.once('end', () => ok());
        } catch (err) {
            ko(err);
        }
    });
}

RouterUtils.prototype.staticGet = function(app, url, staticResources) {
    app.router.get(url, (req, res) => {
        app.routerUtils.staticServe(res, staticResources).catch(err => {
            app.routerUtils.onPageNotFound(res);
        });
    });
}

RouterUtils.encodeUrlComponent = function(input) {
    return btoa(input).replaceAll('=', '-').replaceAll('+', '_');
}

RouterUtils.prototype.encodeUrlComponent = function(input) {
    return RouterUtils.encodeUrlComponent(input);
}

RouterUtils.decodeUrlComponent = function(input) {
    return atob(input.replaceAll('-', '=').replaceAll('_', '+'));
}

RouterUtils.prototype.decodeUrlComponent = function(input) {
    return RouterUtils.decodeUrlComponent(input);
}

RouterUtils.prototype.commonRenderInfos = function() {
    return {
    };
}

module.exports = { RouterUtils: RouterUtils, encodeUrlComponent: RouterUtils.encodeUrlComponent, decodeUrlComponent: RouterUtils.decodeUrlComponent };