@corlabs-holding/n8n-nodes-bankerize
Version:
N8n community nodes para integração completa com API Bankerize - 4 nodes especializados: FGTS, E-Consignado, Gerenciamento de Propostas e Administração
527 lines • 21.4 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.BankerizeEconsignado = void 0;
const n8n_workflow_1 = require("n8n-workflow");
const BankerizeHelpers_1 = require("./BankerizeHelpers");
class BankerizeEconsignado {
constructor() {
this.description = {
displayName: 'Bankerize - E-Consignado',
name: 'bankerizeEconsignado',
icon: 'file:icon.svg',
group: ['transform'],
version: 1,
subtitle: '={{$parameter.operation}}',
description: 'Gerenciar operações E-Consignado da API Bankerize: vínculos empregatícios, simulações e propostas para consignado privado',
defaults: {
name: 'Bankerize - E-Consignado',
},
inputs: ["main" /* NodeConnectionType.Main */],
outputs: ["main" /* NodeConnectionType.Main */],
usableAsTool: true, // IMPORTANTE: Para funcionar como tool
credentials: [
{
name: 'bankerizeCredentialsApi',
required: true,
},
],
properties: [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
options: [
{
name: 'Get Employment Relationships',
value: 'getEmploymentRelationships',
description: 'Solicitar vínculos empregatícios do cliente',
action: 'Buscar vínculos empregatícios',
},
{
name: 'Get Employment Details',
value: 'getEmploymentDetails',
description: 'Obter detalhamento de vínculo empregatício específico',
action: 'Detalhar vínculo empregatício',
},
{
name: 'Simulate',
value: 'simulate',
description: 'Simular proposta E-Consignado',
action: 'Simular E-Consignado',
},
{
name: 'Create Proposal',
value: 'createProposal',
description: 'Criar proposta E-Consignado',
action: 'Criar proposta E-Consignado',
},
],
default: 'getEmploymentRelationships',
},
// Get Employment Relationships fields
{
displayName: 'CPF',
name: 'cpf',
type: 'string',
displayOptions: {
show: {
operation: ['getEmploymentRelationships'],
},
},
default: '',
required: true,
description: 'CPF do cliente (apenas números)',
},
{
displayName: 'Banco',
name: 'bank',
type: 'options',
displayOptions: {
show: {
operation: ['getEmploymentRelationships'],
},
},
options: [
{
name: 'BMP',
value: 'bmp',
},
],
default: 'bmp',
required: true,
description: 'Banco parceiro para a operação',
},
// Get Employment Details fields
{
displayName: 'Request UUID',
name: 'requestUuid',
type: 'string',
displayOptions: {
show: {
operation: ['getEmploymentDetails'],
},
},
default: '',
required: true,
description: 'UUID da requisição de vínculos obtido na operação anterior',
placeholder: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx',
},
{
displayName: 'Registration',
name: 'registration',
type: 'string',
displayOptions: {
show: {
operation: ['getEmploymentDetails'],
},
},
default: '',
required: true,
description: 'Matrícula do vínculo empregatício',
},
// Simulate fields
{
displayName: 'CPF',
name: 'simulateCpf',
type: 'string',
displayOptions: {
show: {
operation: ['simulate'],
},
},
default: '',
required: true,
description: 'CPF do cliente (apenas números)',
},
{
displayName: 'Valor Desejado',
name: 'desiredValue',
type: 'number',
displayOptions: {
show: {
operation: ['simulate'],
},
},
default: 0,
required: true,
description: 'Valor líquido desejado pelo cliente',
typeOptions: {
minValue: 1,
numberPrecision: 2,
},
},
{
displayName: 'Banco',
name: 'simulateBank',
type: 'options',
displayOptions: {
show: {
operation: ['simulate'],
},
},
options: [
{
name: 'BMP',
value: 'bmp',
},
],
default: 'bmp',
required: true,
description: 'Banco parceiro para a operação',
},
// Create Proposal fields
{
displayName: 'Dados do Cliente',
name: 'customerNotice',
type: 'notice',
displayOptions: {
show: {
operation: ['createProposal'],
},
},
default: '',
description: 'Informações do cliente para criar a proposta E-Consignado',
},
{
displayName: 'Customer Data',
name: 'customerData',
type: 'json',
displayOptions: {
show: {
operation: ['createProposal'],
},
},
default: `{
"pf": {
"name": "João da Silva",
"cpf": "00000000000",
"birth_date": "1990-01-01",
"gender": "M",
"civil_status_id": "CASADO",
"scholarity_id": "SUPERIOR_COMPLETO",
"rg_number": "123456789",
"rg_organ": "SSP",
"rg_uf": "SP"
},
"contacts": {
"email": "joao@email.com",
"celphone": "11999999999"
},
"address": {
"zipcode": "01001000",
"street": "Rua Exemplo",
"district": "Centro",
"uf": "SP",
"number": "123",
"complement": "Apto 456",
"city": "São Paulo"
},
"account": {
"bank_id": "001",
"type": "CCT",
"agency": "1234",
"agency_digit": "5",
"account_number": "12345",
"account_digit": "6"
}
}`,
required: true,
description: 'Dados completos do cliente em formato JSON',
typeOptions: {
rows: 15,
},
},
{
displayName: 'Simulation Data',
name: 'simulationData',
type: 'json',
displayOptions: {
show: {
operation: ['createProposal'],
},
},
default: `{
"id": "simulation-uuid-here"
}`,
required: true,
description: 'Dados da simulação escolhida (ID obtido na simulação)',
typeOptions: {
rows: 3,
},
},
{
displayName: 'Employment Relationship',
name: 'employmentRelationship',
type: 'json',
displayOptions: {
show: {
operation: ['createProposal'],
},
},
default: `{
"request_uuid": "uuid-from-employment-request",
"registration": "matricula-aqui"
}`,
required: true,
description: 'Dados do vínculo empregatício escolhido',
typeOptions: {
rows: 4,
},
},
],
};
}
async execute() {
var _a, _b;
const items = this.getInputData();
const returnData = [];
for (let i = 0; i < items.length; i++) {
try {
const operation = this.getNodeParameter('operation', i);
const credentials = await this.getCredentials('bankerizeCredentialsApi');
const responseData = await handleEconsignadoOperations.call(this, operation, i, credentials);
if (responseData === undefined || responseData === null) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Operação não retornou dados: ${operation}`);
}
// Tratamento da resposta
if (Array.isArray(responseData)) {
if (responseData.length === 0) {
returnData.push({
json: { message: "Nenhum resultado encontrado." },
pairedItem: { item: i }
});
}
else {
const executionData = responseData.map(item => ({
json: item,
pairedItem: { item: i }
}));
returnData.push(...executionData);
}
}
else {
returnData.push({ json: responseData, pairedItem: { item: i } });
}
}
catch (error) {
if (this.continueOnFail()) {
// Se houver resposta de erro da API, preservar a estrutura exata
if (error.response) {
const errorData = {
status: error.response.status,
statusText: error.response.statusText || 'Error',
data: ((_a = error.response.data) === null || _a === void 0 ? void 0 : _a.data) || [],
message: ((_b = error.response.data) === null || _b === void 0 ? void 0 : _b.message) || error.message || 'Unknown error'
};
returnData.push({
json: errorData,
pairedItem: { item: i },
});
continue;
}
// Para outros tipos de erro
returnData.push({
json: {
error: error.message || 'Unknown error',
details: error
},
pairedItem: { item: i },
});
continue;
}
// Se não for para continuar em caso de falha, usar o helper
(0, BankerizeHelpers_1.handleBankerizeError)(error, this.getNode());
}
}
return [returnData];
}
}
exports.BankerizeEconsignado = BankerizeEconsignado;
// Função para obter URLs baseadas no ambiente
function getUrls(credentials) {
const environment = credentials.environment;
if (environment === 'develop') {
return {
authUrl: 'https://develop.auth.bankerize.com.br/realms/bankerize/protocol/openid-connect/token',
apiUrl: 'https://develop.api.bankerize.com.br/v1',
};
}
else {
return {
authUrl: 'https://auth.bankerize.com.br/realms/bankerize/protocol/openid-connect/token',
apiUrl: 'https://api.bankerize.com.br/v1',
};
}
}
// Função para obter token de acesso
async function getAccessToken(credentials) {
const { authUrl } = getUrls(credentials);
const formData = `grant_type=client_credentials&client_id=${encodeURIComponent(credentials.clientId)}&client_secret=${encodeURIComponent(credentials.clientSecret)}`;
try {
const response = await this.helpers.httpRequest({
method: 'POST',
url: authUrl,
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
'Accept': 'application/json',
},
body: formData,
});
if (!response.access_token) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Resposta de autenticação inválida - Token não encontrado');
}
return response.access_token;
}
catch (error) {
(0, BankerizeHelpers_1.handleBankerizeError)(error, this.getNode());
}
}
// Operações E-Consignado
async function handleEconsignadoOperations(operation, itemIndex, credentials) {
const { apiUrl } = getUrls(credentials);
const accessToken = await getAccessToken.call(this, credentials);
const headers = {
'Authorization': `Bearer ${accessToken}`,
'Accept': 'application/json',
'Content-Type': 'application/json',
};
switch (operation) {
case 'getEmploymentRelationships': {
const cpf = this.getNodeParameter('cpf', itemIndex);
const bank = this.getNodeParameter('bank', itemIndex);
// Validações
if (!cpf || cpf.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'CPF é obrigatório');
}
const cleanCpf = cpf.replace(/\D/g, '');
if (cleanCpf.length !== 11) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'CPF deve conter exatamente 11 dígitos');
}
if (!bank || bank.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Banco é obrigatório');
}
const body = {
cpf: cleanCpf,
bank: bank,
};
return await this.helpers.httpRequest({
method: 'POST',
url: `${apiUrl}/proposals/econsignado/employment-relationship`,
headers,
body,
json: true,
});
}
case 'getEmploymentDetails': {
const requestUuid = this.getNodeParameter('requestUuid', itemIndex);
const registration = this.getNodeParameter('registration', itemIndex);
// Validações
if (!requestUuid || requestUuid.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Request UUID é obrigatório');
}
if (!registration || registration.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Matrícula é obrigatória');
}
const body = {
request_uuid: requestUuid.trim(),
registration: registration.trim(),
};
return await this.helpers.httpRequest({
method: 'POST',
url: `${apiUrl}/proposals/econsignado/employment-relationship/details`,
headers,
body,
json: true,
});
}
case 'simulate': {
const cpf = this.getNodeParameter('simulateCpf', itemIndex);
const desiredValue = this.getNodeParameter('desiredValue', itemIndex);
const bank = this.getNodeParameter('simulateBank', itemIndex);
// Validações
if (!cpf || cpf.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'CPF é obrigatório para simulação');
}
const cleanCpf = cpf.replace(/\D/g, '');
if (cleanCpf.length !== 11) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'CPF deve conter exatamente 11 dígitos');
}
if (!desiredValue || desiredValue <= 0) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Valor desejado deve ser maior que zero');
}
if (desiredValue > 999999) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Valor desejado não pode exceder R$ 999.999,00');
}
if (!bank || bank.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Banco é obrigatório');
}
const body = {
cpf: cleanCpf,
desired_value: desiredValue,
bank: bank,
};
return await this.helpers.httpRequest({
method: 'POST',
url: `${apiUrl}/proposals/econsignado/simulate`,
headers,
body,
json: true,
});
}
case 'createProposal': {
const customerDataStr = this.getNodeParameter('customerData', itemIndex);
const simulationDataStr = this.getNodeParameter('simulationData', itemIndex);
const employmentRelationshipStr = this.getNodeParameter('employmentRelationship', itemIndex);
// Parse e validação dos JSONs
let customerData, simulationData, employmentRelationship;
try {
customerData = JSON.parse(customerDataStr);
}
catch (parseError) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Customer Data deve ser um JSON válido');
}
try {
simulationData = JSON.parse(simulationDataStr);
}
catch (parseError) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Simulation Data deve ser um JSON válido');
}
try {
employmentRelationship = JSON.parse(employmentRelationshipStr);
}
catch (parseError) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Employment Relationship deve ser um JSON válido');
}
// Validações básicas
if (!customerData.pf || !customerData.pf.cpf) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'CPF do cliente é obrigatório');
}
if (!simulationData.id) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'ID da simulação é obrigatório');
}
if (!employmentRelationship.request_uuid || !employmentRelationship.registration) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Request UUID e matrícula são obrigatórios');
}
// Limpar CPF
if (customerData.pf.cpf) {
customerData.pf.cpf = customerData.pf.cpf.replace(/\D/g, '');
}
const body = {
customer: customerData,
simulation: simulationData,
employment_relationship: employmentRelationship,
};
return await this.helpers.httpRequest({
method: 'POST',
url: `${apiUrl}/proposals/econsignado`,
headers,
body,
json: true,
});
}
default:
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Operação E-Consignado desconhecida: ${operation}`);
}
}
//# sourceMappingURL=BankerizeEconsignado.node.js.map