@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
496 lines • 21.6 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.BankerizeProposals = void 0;
const n8n_workflow_1 = require("n8n-workflow");
const BankerizeHelpers_1 = require("./BankerizeHelpers");
class BankerizeProposals {
constructor() {
this.description = {
displayName: 'Bankerize - Gerenciamento de Propostas',
name: 'bankerizeProposals',
icon: 'file:icon.svg',
group: ['transform'],
version: 1,
subtitle: '={{$parameter.operation}}',
description: 'Gerenciar propostas existentes na API Bankerize: cancelar, consultar, enviar para desembolso, renovar assinatura e atualizar dados',
defaults: {
name: 'Bankerize - Propostas',
},
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: 'Cancel Proposal',
value: 'cancelProposal',
description: 'Cancelar uma proposta específica',
action: 'Cancelar proposta',
},
{
name: 'Get Proposal',
value: 'getProposal',
description: 'Consultar dados de uma proposta',
action: 'Consultar proposta',
},
{
name: 'Send to Disburse',
value: 'sendToDisburse',
description: 'Enviar proposta para desembolso',
action: 'Enviar para desembolso',
},
{
name: 'Renew Signature Link',
value: 'renewSignatureLink',
description: 'Solicitar novo link de assinatura',
action: 'Renovar link assinatura',
},
{
name: 'Update Payment Account',
value: 'updatePaymentAccount',
description: 'Atualizar dados bancários de pagamento',
action: 'Atualizar conta pagamento',
},
{
name: 'Get Proposal Details',
value: 'getProposalDetails',
description: 'Buscar detalhamento completo da proposta',
action: 'Detalhar proposta',
},
{
name: 'Update Antifraud Status',
value: 'updateAntifraudStatus',
description: 'Alterar status do antifraude',
action: 'Atualizar status antifraude',
},
],
default: 'getProposal',
},
// Common field for most operations
{
displayName: 'UUID da Proposta',
name: 'proposalUuid',
type: 'string',
displayOptions: {
show: {
operation: [
'cancelProposal',
'getProposal',
'sendToDisburse',
'renewSignatureLink',
'updatePaymentAccount',
'getProposalDetails',
],
},
},
default: '',
required: true,
description: 'UUID único da proposta',
placeholder: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx',
},
// Cancel Proposal fields
{
displayName: 'Motivo do Cancelamento',
name: 'cancelReason',
type: 'string',
displayOptions: {
show: {
operation: ['cancelProposal'],
},
},
default: '',
description: 'Motivo do cancelamento da proposta (opcional)',
placeholder: 'Cliente desistiu da operação',
},
// Update Payment Account fields
{
displayName: 'Dados Bancários',
name: 'bankAccountNotice',
type: 'notice',
displayOptions: {
show: {
operation: ['updatePaymentAccount'],
},
},
default: '',
description: 'Atualize os dados bancários para pagamento da proposta',
},
{
displayName: 'Código do Banco',
name: 'bankId',
type: 'string',
displayOptions: {
show: {
operation: ['updatePaymentAccount'],
},
},
default: '',
required: true,
description: 'Código do banco (ex: 237 para Bradesco, 001 para BB)',
},
{
displayName: 'Tipo de Conta',
name: 'accountType',
type: 'options',
displayOptions: {
show: {
operation: ['updatePaymentAccount'],
},
},
options: [
{ name: 'Conta Corrente', value: 'CCT' },
{ name: 'Conta Poupança', value: 'CPP' },
{ name: 'Conta Pagamento', value: 'CPG' },
],
default: 'CCT',
required: true,
description: 'Tipo da conta bancária',
},
{
displayName: 'Agência',
name: 'agency',
type: 'string',
displayOptions: {
show: {
operation: ['updatePaymentAccount'],
},
},
default: '',
required: true,
description: 'Número da agência',
},
{
displayName: 'Dígito da Agência',
name: 'agencyDigit',
type: 'string',
displayOptions: {
show: {
operation: ['updatePaymentAccount'],
},
},
default: '',
description: 'Dígito verificador da agência (se houver)',
},
{
displayName: 'Número da Conta',
name: 'accountNumber',
type: 'string',
displayOptions: {
show: {
operation: ['updatePaymentAccount'],
},
},
default: '',
required: true,
description: 'Número da conta bancária',
},
{
displayName: 'Dígito da Conta',
name: 'accountDigit',
type: 'string',
displayOptions: {
show: {
operation: ['updatePaymentAccount'],
},
},
default: '',
required: true,
description: 'Dígito verificador da conta',
},
// Update Antifraud Status fields
{
displayName: 'UUID da Assinatura',
name: 'signatureUuid',
type: 'string',
displayOptions: {
show: {
operation: ['updateAntifraudStatus'],
},
},
default: '',
required: true,
description: 'UUID da assinatura para atualizar status antifraude',
placeholder: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx',
},
{
displayName: 'Novo Status',
name: 'newStatus',
type: 'options',
displayOptions: {
show: {
operation: ['updateAntifraudStatus'],
},
},
options: [
{ name: 'Aprovado', value: 'approved' },
{ name: 'Rejeitado', value: 'rejected' },
],
default: 'approved',
required: true,
description: 'Novo status do antifraude',
},
],
};
}
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 handleProposalOperations.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.BankerizeProposals = BankerizeProposals;
// 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(), 'Token não encontrado na resposta');
}
return response.access_token;
}
catch (error) {
(0, BankerizeHelpers_1.handleBankerizeError)(error, this.getNode());
}
}
// Operações de Gerenciamento de Propostas
async function handleProposalOperations(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 'cancelProposal': {
const proposalUuid = this.getNodeParameter('proposalUuid', itemIndex);
const cancelReason = this.getNodeParameter('cancelReason', itemIndex);
// Validações
if (!proposalUuid || proposalUuid.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'UUID da proposta é obrigatório');
}
const body = {};
if (cancelReason && cancelReason.trim() !== '') {
body.reason = cancelReason.trim();
}
return await this.helpers.httpRequest({
method: 'PUT',
url: `${apiUrl}/proposals/${proposalUuid.trim()}/cancel`,
headers,
body: Object.keys(body).length > 0 ? body : undefined,
json: true,
});
}
case 'getProposal': {
const proposalUuid = this.getNodeParameter('proposalUuid', itemIndex);
// Validações
if (!proposalUuid || proposalUuid.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'UUID da proposta é obrigatório');
}
return await this.helpers.httpRequest({
method: 'GET',
url: `${apiUrl}/proposals/${proposalUuid.trim()}`,
headers,
json: true,
});
}
case 'sendToDisburse': {
const proposalUuid = this.getNodeParameter('proposalUuid', itemIndex);
// Validações
if (!proposalUuid || proposalUuid.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'UUID da proposta é obrigatório');
}
return await this.helpers.httpRequest({
method: 'POST',
url: `${apiUrl}/proposals/${proposalUuid.trim()}/disburse`,
headers,
body: {},
json: true,
});
}
case 'renewSignatureLink': {
const proposalUuid = this.getNodeParameter('proposalUuid', itemIndex);
// Validações
if (!proposalUuid || proposalUuid.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'UUID da proposta é obrigatório');
}
return await this.helpers.httpRequest({
method: 'POST',
url: `${apiUrl}/proposals/${proposalUuid.trim()}/signature-link/renew`,
headers,
body: {},
json: true,
});
}
case 'updatePaymentAccount': {
const proposalUuid = this.getNodeParameter('proposalUuid', itemIndex);
const bankId = this.getNodeParameter('bankId', itemIndex);
const accountType = this.getNodeParameter('accountType', itemIndex);
const agency = this.getNodeParameter('agency', itemIndex);
const agencyDigit = this.getNodeParameter('agencyDigit', itemIndex);
const accountNumber = this.getNodeParameter('accountNumber', itemIndex);
const accountDigit = this.getNodeParameter('accountDigit', itemIndex);
// Validações
if (!proposalUuid || proposalUuid.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'UUID da proposta é obrigatório');
}
if (!bankId || bankId.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Código do banco é obrigatório');
}
if (!agency || agency.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Agência é obrigatória');
}
if (!accountNumber || accountNumber.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Número da conta é obrigatório');
}
if (!accountDigit || accountDigit.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Dígito da conta é obrigatório');
}
const body = {
bank_id: bankId.trim(),
type: accountType,
agency: agency.trim(),
agency_digit: agencyDigit ? agencyDigit.trim() : '',
account_number: accountNumber.trim(),
account_digit: accountDigit.trim(),
};
return await this.helpers.httpRequest({
method: 'PUT',
url: `${apiUrl}/proposals/${proposalUuid.trim()}/account-payment`,
headers,
body,
json: true,
});
}
case 'getProposalDetails': {
const proposalUuid = this.getNodeParameter('proposalUuid', itemIndex);
// Validações
if (!proposalUuid || proposalUuid.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'UUID da proposta é obrigatório');
}
return await this.helpers.httpRequest({
method: 'GET',
url: `${apiUrl}/proposals/${proposalUuid.trim()}/detailing`,
headers,
json: true,
});
}
case 'updateAntifraudStatus': {
const signatureUuid = this.getNodeParameter('signatureUuid', itemIndex);
const newStatus = this.getNodeParameter('newStatus', itemIndex);
// Validações
if (!signatureUuid || signatureUuid.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'UUID da assinatura é obrigatório');
}
if (!newStatus || !['approved', 'rejected'].includes(newStatus)) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Status deve ser "approved" ou "rejected"');
}
return await this.helpers.httpRequest({
method: 'PUT',
url: `${apiUrl}/proposals/signature/${signatureUuid.trim()}/status/${newStatus}`,
headers,
body: {},
json: true,
});
}
default:
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Operação desconhecida: ${operation}`);
}
}
//# sourceMappingURL=BankerizeProposals.node.js.map