n8n-nodes-efibank/dist/nodes/EfiBankCobrancas/Services.js

Nó personalizado para integração com as APIs Cobranças e Pix do Efibank, permitindo operações de pagamentos, recebimentos e gerenciamento de transações financeiras.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.execute = void 0;
const boletoService_1 = require("./services/boletoService");
const cartaoService_1 = require("./services/cartaoService");
const carneService_1 = require("./services/carneService");
const assinaturaService_1 = require("./services/assinaturaService");
const linkService_1 = require("./services/linkService");
const splitService_1 = require("./services/splitService");
const notificacaoService_1 = require("./services/notificacaoService");
const auth_1 = require("./endpoints/Auth/auth");
async function execute(endpoint, i) {
    const returnData = [];
    const credentials = await this.getCredentials('EfiBankCobApi');
    const isProd = credentials.environment === 'prod';
    const clientId = isProd ? credentials.clientIdProd : credentials.clientIdHomolog;
    const clientSecret = isProd ? credentials.clientSecretProd : credentials.clientSecretHomolog;
    const baseURL = credentials.environment === 'homolog'
        ? 'https://cobrancas-h.api.efipay.com.br'
        : 'https://cobrancas.api.efipay.com.br';
    const access_token = await (0, auth_1.auth)({ clientId: String(clientId), clientSecret: String(clientSecret) }, baseURL, this.helpers.httpRequest);
    const transactionType = this.getNodeParameter('transactionType', i);
    try {
        let requestOptions;
        switch (transactionType) {
            case 'boleto':
                requestOptions = await boletoService_1.boletoService.call(this, endpoint, i, baseURL, access_token);
                break;
            case 'cartao':
                requestOptions = await cartaoService_1.cartaoService.call(this, endpoint, i, baseURL, access_token);
                break;
            case 'carne':
                requestOptions = await carneService_1.carneService.call(this, endpoint, i, baseURL, access_token);
                break;
            case 'assinatura':
                requestOptions = await assinaturaService_1.assinaturaService.call(this, endpoint, i, baseURL, access_token);
                break;
            case 'link':
                requestOptions = await linkService_1.linkService.call(this, endpoint, i, baseURL, access_token);
                break;
            case 'split':
                requestOptions = await splitService_1.splitService.call(this, endpoint, i, baseURL, access_token);
                break;
            case 'notificacao':
                requestOptions = await notificacaoService_1.notificacaoService.call(this, endpoint, i, baseURL, access_token);
                break;
            default:
                throw new Error(`Erro: '${transactionType}' não é um tipo de transação válida.`);
        }
        const response = await this.helpers.httpRequest(requestOptions);
        returnData.push({ json: response });
    }
    catch (error) {
        this.logger.error('Erro ao executar a requisição:', error);
        if (error.isAxiosError) {
            if (error.response) {
                const responseData = error.response.data;
                let errorMessage = 'Erro na API';
                let errorDetails = {};
                if (typeof responseData === 'object') {
                    errorMessage = responseData.message ||
                        responseData.error_description ||
                        responseData.error ||
                        `Error ${error.response.status}: ${error.response.statusText}`;
                    errorDetails = responseData;
                }
                else if (typeof responseData === 'string') {
                    errorMessage = responseData;
                    try {
                        errorDetails = JSON.parse(responseData);
                    }
                    catch (e) {
                        errorDetails = { rawResponse: responseData };
                    }
                }
                this.logger.error('Erro detalhado da API:', {
                    statusCode: error.response.status,
                    message: errorMessage,
                    details: JSON.stringify(errorDetails, null, 2)
                });
                returnData.push({
                    json: {
                        success: false,
                        status: error.response.status,
                        statusText: error.response.statusText,
                        message: errorMessage,
                        details: errorDetails
                    },
                });
            }
            else if (error.request) {
                this.logger.error('Sem resposta da API:', { message: error.message });
                returnData.push({
                    json: {
                        success: false,
                        message: 'Sem resposta da API',
                        error: error.message
                    }
                });
            }
            else {
                this.logger.error('Erro na configuração da requisição:', { message: error.message });
                returnData.push({
                    json: {
                        success: false,
                        message: 'Erro na configuração da requisição',
                        error: error.message
                    }
                });
            }
        }
        else {
            this.logger.error('Erro desconhecido:', { message: error.message });
            returnData.push({
                json: {
                    success: false,
                    message: 'Erro desconhecido',
                    error: error.message
                }
            });
        }
        if (this.continueOnFail()) {
            return returnData;
        }
        else {
            if (error.isAxiosError && error.response && error.response.data) {
                const apiError = new Error(`API Error: ${JSON.stringify(error.response.data)}`);
                throw apiError;
            }
            throw error;
        }
    }
    return returnData;
}
exports.execute = execute;
//# sourceMappingURL=Services.js.map