imob-sdk/src/middlewares/auth.js

SDK para acessar a API do Imóvel Periciado.

const { authBaseUrl } = require('../settings/config');
const logger = require('../settings/logger');
const unAhorizedError = require('../errors/unAuthorizedError');
const { prepare_data } = require('../utility/utils');
const apiClient = require('../settings/apiClient');
const { DetailType } = require('../client/enums/PostEnum');

class SessionManager {
    constructor() {
        this.session = Symbol("secret_session");
        this.session_object = {
            // Inicializando o 'session' como uma propriedade oculta com valor 'undefined'
            [this.session]: undefined,

            // Método para ler o valor da sessão
            read() {
                return this[this.session];
            },

            // Método para retornar o cabeçalho de autorização com o token
            authorization_header() {
                return `Bearer ${this.token()}`;
            },

            // Método para obter o token de acesso
            token() {
                if (!this[this.session] || !this[this.session].access_token) {
                    return undefined; // Retorna undefined se o access_token não existir
                }
                return this[this.session].access_token;
            },

            // Método para configurar uma nova sessão
            setSession(sessionData) {
                this[this.session] = sessionData; // Atribui os dados da sessão
            }
        };
    }
}

class Auth {
    constructor(client_token, basic_auth = undefined) {
        this.client_token = client_token;
        this.session = new SessionManager();
        this.basic_auth = basic_auth ? `Basic ${btoa(basic_auth)}` : undefined;
    }

    authenticated() {
        return (this.session.session != undefined && this.session.session_object.read() != undefined) && this.client_token != undefined;
    }

    async getAccount(view_type = DetailType.BASIC) {
        if (!this.authenticated()) {
            throw new Error('No authentication token available');
        }

        const response = await apiClient.get(`${authBaseUrl}/api/v1/users/me?scope=${view_type}`, {
            headers: {
                'IP-Authorization': this.session.session_object.authorization_header(),
                ...(this.basic_auth ? { 'Authorization': this.basic_auth } : {}),
            },
        });

        logger.warn(`Sua conta foi encontrada e possui prioridade: ${response.account_type}`);

        return response;
    }

    async login(username, password, type = 'bearer', redirect_to = undefined) {
        const url = `${authBaseUrl}/api/v1/authentication/application`;
        const data = prepare_data(username, password, type, redirect_to);

        try {
            logger.info(`Authenticating with ${username} » ${type}`);
            // Interceptar o redirecionamento manualmente
            const response = await apiClient.post(url, data, {
                maxRedirects: 0, // Desabilita o redirecionamento automático
                validateStatus: (status) => status === 307 || status === 200,
                headers: {
                    ...(this.basic_auth ? { 'Authorization': this.basic_auth } : {}),
                }
            });
            const response_message = response ? 'Acesso autorizado' : response.detail ? response.detail : "Acesso negado";
            const status = response?.access_token ? 200 : 500;
            logger.warn(`API Response » ${status} - ${response_message}`);
            if (response?.access_token)
                logger.info('Sessão gerada com sucesso, tokerizado!');
            else {
                logger.error('Erro ao gerar sessão, não autorizado!');
                throw new unAhorizedError('Erro ao gerar sessão, não autorizado!', 401);
            }
            // Captura o cabeçalho de redirecionamento
            const redirectUrl = response.redirect_to;
            this.session.session_object.setSession(response);

            return { status: status, message: response_message, redirect_to: redirectUrl };
        } catch (error) {
            logger.error('Erro durante o login:', error.message);
            return { status: 'error', message: error.message };
        }
    }

    async renewToken() {
        if (!this.authenticated()) {
            throw new Error('No authentication token available');
        }
        const url = `${authBaseUrl}/api/v1/authentication/application`;
        const response = await apiClient.get(url, {
            type: 'RENEW',
            token: this.session_object.token(),
        });

        const response_message = response ? 'Acesso autorizado' : response.detail ? response.detail : "Acesso negado";
        logger.warn(`API Response » ${status} - ${response_message}`);
        this.session.session_object.setSession(response);
        return { status: response.status, message: (response?.data?.message | response?.data?.detail) };
    }

    getToken() {
        return this.client_token;
    }
}

module.exports = Auth;