@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
811 lines • 32.8 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.BankerizeAdmin = void 0;
const n8n_workflow_1 = require("n8n-workflow");
const BankerizeHelpers_1 = require("./BankerizeHelpers");
class BankerizeAdmin {
constructor() {
this.description = {
displayName: 'Bankerize - Admin',
name: 'bankerizeAdmin',
icon: 'file:icon.svg',
group: ['transform'],
version: 1,
subtitle: '={{$parameter.operation}}',
description: 'Gerenciar operações administrativas da API Bankerize: usuários, parceiros e perfis',
defaults: {
name: 'Bankerize - Admin',
},
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: 'Create User',
value: 'createUser',
description: 'Cadastrar novo usuário no sistema',
action: 'Criar usuário',
},
{
name: 'Create Partner',
value: 'createPartner',
description: 'Cadastrar novo parceiro (PF ou PJ)',
action: 'Criar parceiro',
},
{
name: 'List Profiles',
value: 'listProfiles',
description: 'Listar perfis disponíveis no sistema',
action: 'Listar perfis',
},
],
default: 'listProfiles',
},
// Create User fields
{
displayName: 'Dados do Usuário',
name: 'userNotice',
type: 'notice',
displayOptions: {
show: {
operation: ['createUser'],
},
},
default: '',
description: 'Informações do novo usuário a ser cadastrado',
},
{
displayName: 'Nome Completo',
name: 'userName',
type: 'string',
displayOptions: {
show: {
operation: ['createUser'],
},
},
default: '',
required: true,
description: 'Nome completo do usuário',
placeholder: 'João da Silva',
},
{
displayName: 'Email',
name: 'userEmail',
type: 'string',
displayOptions: {
show: {
operation: ['createUser'],
},
},
default: '',
required: true,
description: 'Email do usuário (será usado para login)',
placeholder: 'usuario@empresa.com',
},
{
displayName: 'Telefone',
name: 'userPhone',
type: 'string',
displayOptions: {
show: {
operation: ['createUser'],
},
},
default: '',
required: true,
description: 'Telefone com DDD',
placeholder: '11999999999',
},
{
displayName: 'CPF',
name: 'userCpf',
type: 'string',
displayOptions: {
show: {
operation: ['createUser'],
},
},
default: '',
required: true,
description: 'CPF do usuário (apenas números)',
placeholder: '00000000000',
},
{
displayName: 'Profile ID',
name: 'profileId',
type: 'string',
displayOptions: {
show: {
operation: ['createUser'],
},
},
default: '',
required: true,
description: 'ID do perfil (obtenha usando List Profiles)',
placeholder: 'profile-uuid',
},
{
displayName: 'Partner ID',
name: 'partnerId',
type: 'string',
displayOptions: {
show: {
operation: ['createUser'],
},
},
default: '',
required: true,
description: 'ID do parceiro ao qual o usuário será vinculado',
placeholder: 'partner-uuid',
},
{
displayName: 'Type ID',
name: 'typeId',
type: 'string',
displayOptions: {
show: {
operation: ['createUser'],
},
},
default: '',
required: true,
description: 'ID do tipo de usuário',
placeholder: 'type-uuid',
},
{
displayName: 'Senha',
name: 'userPassword',
type: 'string',
displayOptions: {
show: {
operation: ['createUser'],
},
},
default: '',
required: true,
description: 'Senha do usuário (mínimo 8 caracteres)',
typeOptions: {
password: true,
},
},
// Create Partner fields
{
displayName: 'Tipo de Parceiro',
name: 'partnerType',
type: 'options',
displayOptions: {
show: {
operation: ['createPartner'],
},
},
options: [
{
name: 'Pessoa Física',
value: 'PF',
},
{
name: 'Pessoa Jurídica',
value: 'PJ',
},
],
default: 'PJ',
required: true,
description: 'Tipo de parceiro a ser cadastrado',
},
// Partner PF fields
{
displayName: 'Dados Pessoa Física',
name: 'pfNotice',
type: 'notice',
displayOptions: {
show: {
operation: ['createPartner'],
partnerType: ['PF'],
},
},
default: '',
description: 'Informações do parceiro pessoa física',
},
{
displayName: 'Nome Completo',
name: 'pfName',
type: 'string',
displayOptions: {
show: {
operation: ['createPartner'],
partnerType: ['PF'],
},
},
default: '',
required: true,
description: 'Nome completo do parceiro PF',
},
{
displayName: 'CPF',
name: 'pfCpf',
type: 'string',
displayOptions: {
show: {
operation: ['createPartner'],
partnerType: ['PF'],
},
},
default: '',
required: true,
description: 'CPF do parceiro (apenas números)',
},
// Partner PJ fields
{
displayName: 'Dados Pessoa Jurídica',
name: 'pjNotice',
type: 'notice',
displayOptions: {
show: {
operation: ['createPartner'],
partnerType: ['PJ'],
},
},
default: '',
description: 'Informações do parceiro pessoa jurídica',
},
{
displayName: 'CNPJ',
name: 'pjCnpj',
type: 'string',
displayOptions: {
show: {
operation: ['createPartner'],
partnerType: ['PJ'],
},
},
default: '',
required: true,
description: 'CNPJ da empresa (apenas números)',
},
{
displayName: 'Razão Social',
name: 'pjRazaoSocial',
type: 'string',
displayOptions: {
show: {
operation: ['createPartner'],
partnerType: ['PJ'],
},
},
default: '',
required: true,
description: 'Razão social da empresa',
},
{
displayName: 'Nome Fantasia',
name: 'pjNomeFantasia',
type: 'string',
displayOptions: {
show: {
operation: ['createPartner'],
partnerType: ['PJ'],
},
},
default: '',
description: 'Nome fantasia da empresa (opcional)',
},
// Common Partner fields
{
displayName: 'Email',
name: 'partnerEmail',
type: 'string',
displayOptions: {
show: {
operation: ['createPartner'],
},
},
default: '',
required: true,
description: 'Email do parceiro',
placeholder: 'parceiro@empresa.com',
},
{
displayName: 'Telefone',
name: 'partnerPhone',
type: 'string',
displayOptions: {
show: {
operation: ['createPartner'],
},
},
default: '',
required: true,
description: 'Telefone com DDD',
placeholder: '11999999999',
},
// Bank Account fields
{
displayName: 'Dados Bancários',
name: 'bankNotice',
type: 'notice',
displayOptions: {
show: {
operation: ['createPartner'],
},
},
default: '',
description: 'Conta bancária do parceiro',
},
{
displayName: 'Banco',
name: 'bankCode',
type: 'string',
displayOptions: {
show: {
operation: ['createPartner'],
},
},
default: '',
required: true,
description: 'Código do banco (ex: 237, 001)',
},
{
displayName: 'Agência',
name: 'bankAgency',
type: 'string',
displayOptions: {
show: {
operation: ['createPartner'],
},
},
default: '',
required: true,
description: 'Número da agência',
},
{
displayName: 'Dígito Agência',
name: 'bankAgencyDigit',
type: 'string',
displayOptions: {
show: {
operation: ['createPartner'],
},
},
default: '',
description: 'Dígito da agência (se houver)',
},
{
displayName: 'Conta',
name: 'bankAccountNumber',
type: 'string',
displayOptions: {
show: {
operation: ['createPartner'],
},
},
default: '',
required: true,
description: 'Número da conta',
},
{
displayName: 'Dígito Conta',
name: 'bankAccountDigit',
type: 'string',
displayOptions: {
show: {
operation: ['createPartner'],
},
},
default: '',
required: true,
description: 'Dígito da conta',
},
{
displayName: 'Tipo de Conta',
name: 'bankAccountType',
type: 'options',
displayOptions: {
show: {
operation: ['createPartner'],
},
},
options: [
{ name: 'Conta Corrente', value: 'CORRENTE' },
{ name: 'Conta Poupança', value: 'POUPANCA' },
],
default: 'CORRENTE',
required: true,
description: 'Tipo da conta bancária',
},
// Address fields
{
displayName: 'Endereço',
name: 'addressNotice',
type: 'notice',
displayOptions: {
show: {
operation: ['createPartner'],
},
},
default: '',
description: 'Endereço completo do parceiro',
},
{
displayName: 'CEP',
name: 'addressCep',
type: 'string',
displayOptions: {
show: {
operation: ['createPartner'],
},
},
default: '',
required: true,
description: 'CEP do endereço (apenas números)',
placeholder: '00000000',
},
{
displayName: 'Logradouro',
name: 'addressStreet',
type: 'string',
displayOptions: {
show: {
operation: ['createPartner'],
},
},
default: '',
required: true,
description: 'Nome da rua, avenida, etc.',
},
{
displayName: 'Número',
name: 'addressNumber',
type: 'string',
displayOptions: {
show: {
operation: ['createPartner'],
},
},
default: '',
required: true,
description: 'Número do endereço',
},
{
displayName: 'Complemento',
name: 'addressComplement',
type: 'string',
displayOptions: {
show: {
operation: ['createPartner'],
},
},
default: '',
description: 'Complemento do endereço (opcional)',
},
{
displayName: 'Bairro',
name: 'addressDistrict',
type: 'string',
displayOptions: {
show: {
operation: ['createPartner'],
},
},
default: '',
required: true,
description: 'Bairro',
},
{
displayName: 'Cidade',
name: 'addressCity',
type: 'string',
displayOptions: {
show: {
operation: ['createPartner'],
},
},
default: '',
required: true,
description: 'Cidade',
},
{
displayName: 'Estado',
name: 'addressState',
type: 'string',
displayOptions: {
show: {
operation: ['createPartner'],
},
},
default: '',
required: true,
description: 'Estado (UF)',
placeholder: 'SP',
},
],
};
}
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 handleAdminOperations.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.BankerizeAdmin = BankerizeAdmin;
// 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 Administrativas
async function handleAdminOperations(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 'createUser': {
const name = this.getNodeParameter('userName', itemIndex);
const email = this.getNodeParameter('userEmail', itemIndex);
const phone = this.getNodeParameter('userPhone', itemIndex);
const cpf = this.getNodeParameter('userCpf', itemIndex);
const profileId = this.getNodeParameter('profileId', itemIndex);
const partnerId = this.getNodeParameter('partnerId', itemIndex);
const typeId = this.getNodeParameter('typeId', itemIndex);
const password = this.getNodeParameter('userPassword', itemIndex);
// Validações
if (!name || name.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Nome é obrigatório');
}
if (!email || !email.includes('@')) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Email válido é obrigatório');
}
const cleanPhone = phone.replace(/\D/g, '');
if (cleanPhone.length < 10) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Telefone deve ter pelo menos 10 dígitos');
}
const cleanCpf = cpf.replace(/\D/g, '');
if (cleanCpf.length !== 11) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'CPF deve ter 11 dígitos');
}
if (!password || password.length < 8) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Senha deve ter pelo menos 8 caracteres');
}
const body = {
name: name.trim(),
email: email.trim().toLowerCase(),
phone: cleanPhone,
cpf: cleanCpf,
profile_id: profileId.trim(),
partner_id: partnerId.trim(),
type_id: typeId.trim(),
password: password,
};
return await this.helpers.httpRequest({
method: 'POST',
url: `${apiUrl}/admin/users`,
headers,
body,
json: true,
});
}
case 'createPartner': {
const partnerType = this.getNodeParameter('partnerType', itemIndex);
const email = this.getNodeParameter('partnerEmail', itemIndex);
const phone = this.getNodeParameter('partnerPhone', itemIndex);
// Validações comuns
if (!email || !email.includes('@')) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Email válido é obrigatório');
}
const cleanPhone = phone.replace(/\D/g, '');
if (cleanPhone.length < 10) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Telefone deve ter pelo menos 10 dígitos');
}
// Construir objeto partner baseado no tipo
let partnerData = {};
if (partnerType === 'PF') {
const name = this.getNodeParameter('pfName', itemIndex);
const cpf = this.getNodeParameter('pfCpf', itemIndex);
if (!name || name.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Nome é obrigatório para PF');
}
const cleanCpf = cpf.replace(/\D/g, '');
if (cleanCpf.length !== 11) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'CPF deve ter 11 dígitos');
}
partnerData = {
type: 'PF',
name: name.trim(),
cpf: cleanCpf,
email: email.trim().toLowerCase(),
phone: cleanPhone,
};
}
else {
const cnpj = this.getNodeParameter('pjCnpj', itemIndex);
const razaoSocial = this.getNodeParameter('pjRazaoSocial', itemIndex);
const nomeFantasia = this.getNodeParameter('pjNomeFantasia', itemIndex);
const cleanCnpj = cnpj.replace(/\D/g, '');
if (cleanCnpj.length !== 14) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'CNPJ deve ter 14 dígitos');
}
if (!razaoSocial || razaoSocial.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Razão social é obrigatória para PJ');
}
partnerData = {
type: 'PJ',
cnpj: cleanCnpj,
razao_social: razaoSocial.trim(),
nome_fantasia: nomeFantasia ? nomeFantasia.trim() : '',
email: email.trim().toLowerCase(),
phone: cleanPhone,
};
}
// Dados bancários
const bankCode = this.getNodeParameter('bankCode', itemIndex);
const agency = this.getNodeParameter('bankAgency', itemIndex);
const agencyDigit = this.getNodeParameter('bankAgencyDigit', itemIndex);
const accountNumber = this.getNodeParameter('bankAccountNumber', itemIndex);
const accountDigit = this.getNodeParameter('bankAccountDigit', itemIndex);
const accountType = this.getNodeParameter('bankAccountType', itemIndex);
if (!bankCode || !agency || !accountNumber || !accountDigit) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Dados bancários completos são obrigatórios');
}
const bankAccount = {
bank_code: bankCode.trim(),
agency: agency.trim(),
agency_digit: agencyDigit ? agencyDigit.trim() : '',
account_number: accountNumber.trim(),
account_digit: accountDigit.trim(),
account_type: accountType,
};
// Endereço
const cep = this.getNodeParameter('addressCep', itemIndex);
const street = this.getNodeParameter('addressStreet', itemIndex);
const number = this.getNodeParameter('addressNumber', itemIndex);
const complement = this.getNodeParameter('addressComplement', itemIndex);
const district = this.getNodeParameter('addressDistrict', itemIndex);
const city = this.getNodeParameter('addressCity', itemIndex);
const state = this.getNodeParameter('addressState', itemIndex);
const cleanCep = cep.replace(/\D/g, '');
if (cleanCep.length !== 8) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'CEP deve ter 8 dígitos');
}
const address = {
cep: cleanCep,
street: street.trim(),
number: number.trim(),
complement: complement ? complement.trim() : '',
district: district.trim(),
city: city.trim(),
state: state.trim().toUpperCase(),
};
const body = {
partner: partnerData,
bank_account: bankAccount,
address: address,
};
return await this.helpers.httpRequest({
method: 'POST',
url: `${apiUrl}/admin/partners`,
headers,
body,
json: true,
});
}
case 'listProfiles': {
return await this.helpers.httpRequest({
method: 'GET',
url: `${apiUrl}/admin/profiles`,
headers,
json: true,
});
}
default:
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Operação administrativa desconhecida: ${operation}`);
}
}
//# sourceMappingURL=BankerizeAdmin.node.js.map