wa-chat-server/lib/api/auth.js

Watson Assistant powered chat server

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.authentication = void 0;
const express_1 = __importDefault(require("express"));
const Session_1 = require("../class/Session/Session");
const AuthenticationService_1 = require("../lib/Azure/AuthenticationService");
const authentication = (logger, config) => {
    const router = express_1.default.Router();
    router.use(express_1.default.json({ limit: '1mb' }));
    /*
     * `/loginUrl` returns the URL of the external Azure login page where the user should be
     * redirected in order to log in
     */
    router.get('/loginUrl', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
        const request = req.query || {};
        let response = null;
        const redirectUrl = request.redirectUrl;
        if (!redirectUrl) {
            response = { message: "Parameter 'redirectUrl' missing" };
        }
        const session = yield new Session_1.Session(request.sessionId).start();
        const logHeader = `GET ${req.path}, sessionId=${session.sessionId}`;
        if (response) {
            logger.error(logHeader, { request, response });
            res.status(400).json(response);
        }
        else {
            const authService = new AuthenticationService_1.AuthenticationService({ config, logger, session, redirectUrl });
            const loginUrl = yield authService.getLoginUrl();
            const response = { loginUrl, sessionId: session.sessionId };
            yield session.save();
            logger.info(logHeader, { request, response });
            res.json({ response });
        }
    }));
    /*
     * `/loginUrl` Returns information about the logged user
     */
    router.post('/loginWithAuthorizationCode', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
        const authorizationCode = req.body.authorizationCode;
        const securityCode = req.body.securityCode;
        const redirectUrl = req.body.redirectUrl;
        const sessionId = req.body.sessionId;
        let response = null;
        const logHeader = `POST ${req.path}, sessionId=${req.body.sessionId}`;
        Object.entries({ authorizationCode, securityCode, redirectUrl }).forEach(([param, value]) => {
            if (!value) {
                response = { message: `Parameter ${param} is missing` };
            }
        });
        if (response) {
            logger.error(logHeader, { request: req.body, response });
            res.status(400).json(response);
        }
        else {
            const isNewSession = !sessionId;
            const session = yield new Session_1.Session(sessionId).start();
            const authService = new AuthenticationService_1.AuthenticationService({
                config,
                logger,
                authorizationCode,
                securityCode,
                session,
                isNewSession,
                redirectUrl,
            });
            try {
                const response = yield authService.authenticate();
                logger.info(logHeader, { request: req.body, response });
                res.json(response);
            }
            catch (error) {
                logger.error(logHeader, { request: req.body, error });
                response = { message: error.toString() };
                res.status(500);
                res.json(response);
            }
            finally {
                yield session.save();
            }
        }
    }));
    /*
     * `/logout` Logs the user out from Azure; sessionId remains untouched
     */
    router.post('/logout', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
        const sessionId = req.body.sessionId;
        const session = yield new Session_1.Session(sessionId).start();
        const logHeader = `POST ${req.path}, sessionId=${session.sessionId}`;
        const authService = new AuthenticationService_1.AuthenticationService({ config, logger, session });
        const response = yield authService.logout();
        yield session.save();
        logger.info(logHeader, { request: req.body, response });
        res.json(response);
    }));
    return router;
};
exports.authentication = authentication;