will-core/handlers/AuthorizeHandler.js

core module

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AuthorizeHandler = void 0;
const will_lib_1 = require("will-lib");
const will_api_1 = require("will-api");
const VerifyError_1 = require("../models/VerifyError");
const EnvironmentVariable_1 = require("../utils/EnvironmentVariable");
const SchemeHandler_1 = require("./SchemeHandler");
class AuthorizeHandler extends SchemeHandler_1.SchemeHandler {
    constructor() {
        super(...arguments);
        this.model = { name: "tusertoken", alias: { privateAlias: this.section } };
        //declared addon actions name
        this.handlers = [{ name: "authorize" }];
    }
    async authorize(context) {
        return this.callFunctional(context, { operate: "authorize", raw: false }, this.doAuthorize);
    }
    async doAuthorize(context, model) {
        if (!EnvironmentVariable_1.VALIDATE_TOKEN)
            return Promise.resolve(undefined);
        let token = this.getTokenKey(context);
        this.logger.debug(this.constructor.name + ".doAuthorize: token=" + token);
        if (token != undefined) {
            let db = this.getPrivateConnector(model);
            try {
                let ut = await this.getAuthorizeTokenInfo(db, token);
                //this.logger.debug(this.constructor.name+".doAuthorize: info",ut);
                return Promise.resolve(ut);
            }
            catch (ex) {
                this.logger.error(this.constructor.name, ex);
                return Promise.reject(this.getDBError(ex));
            }
            finally {
                if (db)
                    db.close();
            }
        }
        if (!EnvironmentVariable_1.ALWAYS_VALIDATE_TOKEN)
            return Promise.resolve(undefined);
        return Promise.reject(new VerifyError_1.VerifyError("Token undefined", will_api_1.HTTP.UNAUTHORIZED, -16002));
    }
    async getAuthorizeTokenInfo(db, token) {
        const atoken = will_lib_1.AuthenToken.verifyAuthenToken(token, false);
        if (atoken.identifier == undefined) {
            return Promise.reject(new VerifyError_1.VerifyError("Token is invalid", will_api_1.HTTP.UNAUTHORIZED, -16001));
        }
        let ut = await this.getAuthorizeToken(db, atoken, EnvironmentVariable_1.VALIDATE_TOKEN_NOT_FOUND, EnvironmentVariable_1.VALIDATE_ANOMYMOUS_TOKEN);
        return Promise.resolve(ut);
    }
    async getAuthorizeToken(db, atoken, verifyTokenNotFound = true, verifyAnonymousToken = true) {
        let plib = new will_lib_1.PasswordLibrary();
        let ut = await plib.getUserTokenInfo(db, atoken.identifier);
        if (verifyTokenNotFound && !ut.userid) {
            return Promise.reject(new VerifyError_1.VerifyError("Token not found", will_api_1.HTTP.UNAUTHORIZED, -16003));
        }
        if (verifyAnonymousToken && "A" == ut.tokentype) {
            return Promise.reject(new VerifyError_1.VerifyError("Token is anonymous", will_api_1.HTTP.UNAUTHORIZED, -16007));
        }
        return Promise.resolve(ut);
    }
}
exports.AuthorizeHandler = AuthorizeHandler;