will-core/routers/BaseRouter.js

core module

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.BaseRouter = void 0;
const AuthorizeHandler_1 = require("../handlers/AuthorizeHandler");
const SystemHandler_1 = require("../handlers/SystemHandler");
const BaseHandler_1 = require("../handlers/BaseHandler");
const Responser_1 = require("../utils/Responser");
class BaseRouter {
    constructor(service, dir) {
        this.dir = process.cwd();
        this.service = service;
        this.logger = service.logger;
        if (dir)
            this.dir = dir;
    }
    buildContext(req, pid) {
        let params = {};
        const body = (req.body) ? req.body : {};
        Object.assign(params, body, req.query, req.params);
        let user = undefined;
        let session = req.session;
        if (session && session.user)
            user = session.user;
        return { params: params, meta: { headers: req.headers, session: session, user: user, req: req, pid: pid } };
    }
    async createContext(req, pid) {
        return this.buildContext(req, pid);
        //let handler = new SystemHandler();
        //return await handler.exposeContext(ctx);
    }
    async cipherData(context, data, verifyHandShaked = false) {
        let handler = new SystemHandler_1.SystemHandler();
        return handler.cipherData(context, data, verifyHandShaked);
    }
    async cipherText(context, data, verifyHandShaked = false) {
        let handler = new SystemHandler_1.SystemHandler();
        return handler.cipherText(context, data, verifyHandShaked);
    }
    async createCipherData(context, method, data, verifyHandShaked = true, model) {
        let handler = new SystemHandler_1.SystemHandler();
        return handler.createCipherData(context, method, data, verifyHandShaked, model ? model : this.constructor.name);
    }
    async call(serviceName, req) {
        let ctx = await this.createContext(req);
        return this.service.broker.call(serviceName, ctx.params, { meta: ctx.meta });
    }
    async authorize(req) {
        let ctx = await this.createContext(req);
        if (ctx.meta.user) {
            return Promise.resolve(ctx);
        }
        if (ctx.meta.session && ctx.meta.session.user) {
            ctx.meta.user = ctx.meta.session.user;
            return Promise.resolve(ctx);
        }
        let handler = new AuthorizeHandler_1.AuthorizeHandler();
        let ut = await handler.authorize(ctx);
        if (ut) {
            if (ctx.meta.session)
                ctx.meta.session.user = ut;
            ctx.meta.user = ut;
        }
        return Promise.resolve(ctx);
    }
    async verifyToken(req, res) {
        try {
            return await this.verifyAuthenToken(req);
        }
        catch (err) {
            Responser_1.Responser.responseError(res, err, "route", "verify");
            return false;
        }
    }
    async verifyAuthenToken(req) {
        let token = this.getAuthorizeToken(req);
        try {
            let handler = new BaseHandler_1.BaseHandler();
            await handler.verifyAuthenToken(token);
        }
        catch (err) {
            return Promise.reject(err);
        }
        return true;
    }
    getAuthorizeToken(req) {
        return req.headers["authtoken"] || req.headers["tokenkey"];
    }
}
exports.BaseRouter = BaseRouter;