// Importing required packages
const SwaggerParser = require("@apidevtools/swagger-parser");
const { outputFile, readJson, writeJson } = require("fs-extra");
const { join } = require("path");
const { OpenAPIV3 } = require("openapi-types");

const REFERENCE_GROUP_NAME = "Referências";

// Objeto com mapeamento de Nome do grupo para tags
const sidebarGroup = {
  Clientes: ["Clientes", "Funcionários"],
  Empresas: [
    "Empresas",
    "Grupos de empresas",
    "Métodos de pagamento",
    "Operadores",
    "Permissões",
  ],
  Empréstimos: [
    "Produtos",
    "Ofertas",
    "Políticas de crédito",
    "Empréstimos",
    "Parcelas",
    "Esteira",
  ],
  Cobrança: ["Faturas", "Itens da fatura", "Intenções de pagamento"],
  Arquivos: ["Arquivos", "Links de arquivos"],
  Fundos: ["Fundos"],
  Eventos: ["Webhooks externos", "Eventos", "Assinaturas", "Notificações"],
  Configurações: ["Temas", "Chaves da API", "Configurações"],
  Entidades: ["Entidade de dados", "Documentos"],
  Automações: ["Workflows"],
};

// Initialize groupData object
let groupData = {
  group: REFERENCE_GROUP_NAME,
  pages: [],
};

/**
 * Validates the OpenAPI specification and generates Frontmatter files
 * for API endpoints and schema definitions.
 *
 * @param {string} path - File path for the OpenAPI specification
 * @param {string} outDir - Directory to output Frontmatter files
 */
const generateOpenApiPages = async (path, outDir) => {
  let spec;

  // Validate OpenAPI specification
  try {
    spec = await SwaggerParser.validate(path);
  } catch (err) {
    console.error(err);
    throw new Error("Your OpenAPI file is invalid.");
  }

  // Validate existence of API paths in specification
  if (!spec.paths || Object.keys(spec.paths).length === 0) {
    throw new Error("No paths defined.");
  }

  // Loop through API paths to create Frontmatter for each endpoint
  Object.entries(spec.paths).forEach(([path, pathItemObject]) => {
    if (!pathItemObject) return;

    Object.values(OpenAPIV3.HttpMethods).forEach((method) => {
      const operation = pathItemObject[method];
      const operationId = operation?.operationId;
      const tags = operation?.tags || ["Ungrouped"];

      if (operationId) {
        createOpenApiFrontmatter(
          join(outDir, `endpoint/${operationId}.mdx`),
          method,
          path,
        );
        tags.forEach((tag) =>
          addPageToGroup(
            tag,
            `development/api-reference/endpoint/${operationId}`,
          ),
        );
      }
    });
  });

  // Generate schema pages if schemas are defined in specification
  if (spec.components && spec.components.schemas) {
    Object.entries(spec.components.schemas).forEach(([schemaName, schema]) => {
      createOpenApiSchemaFrontmatter(
        join(outDir, `schema/${schemaName}.mdx`),
        schemaName,
      );
      addPageToGroup(
        "Modelos",
        `development/api-reference/schema/${schemaName}`,
      );
    });
  } else {
    throw new Error("No schemas defined.");
  }
};

/**
 * Update navigation in the mint.json file
 *
 * @param {string} mintJsonPath - File path for mint.json
 */
const updateMintJson = async (mintJsonPath) => {
  const existingData = await readJson(mintJsonPath);

  if (existingData && Array.isArray(existingData.navigation)) {
    // Encontrar o índice do objeto com o grupo "Referências"
    const refIndex = existingData.navigation.findIndex(
      (page) => page.group === "Referências",
    );

    if (refIndex !== -1) {
      // Extrair os itens dentro do grupo "Referências"
      const refPages = existingData.navigation[refIndex].pages;

      // Remover o objeto "Referências" do array
      existingData.navigation.splice(refIndex, 1);

      // Adicionar os itens extraídos de "Referências" na raiz do array "pages"
      existingData.navigation = existingData.navigation.concat(refPages);
    }

    await writeJson("mint.json", existingData, { spaces: 2 });
  } else {
    console.error("Formato desconhecido em mint.json");
  }
};

const createOpenApiFrontmatter = async (filename, method, path) => {
  const data = `---
openapi: ${method} ${path}
---`;
  await outputFile(filename, data);
};

const createOpenApiSchemaFrontmatter = async (filename, schemaName) => {
  const data = `---
openapi-schema: ${schemaName}
---`;
  await outputFile(filename, data);
};

const addPageToGroup = (tagName, pagePath) => {
  // Determina o grupo principal com base na tag
  let mainGroupName = null;
  Object.entries(sidebarGroup).forEach(([group, tags]) => {
    if (tags.includes(tagName)) {
      mainGroupName = group;
    }
  });

  if (!mainGroupName) {
    mainGroupName = tagName; // Define um grupo padrão caso a tag não seja encontrada
  }

  // Encontra ou cria o grupo principal
  let mainGroup = groupData.pages.find((g) => g.group === mainGroupName);
  if (!mainGroup) {
    mainGroup = { group: mainGroupName, pages: [] };
    groupData.pages.push(mainGroup);
  }

  // Encontra ou cria o subgrupo específico da tag dentro do grupo principal
  let tagSubGroup = mainGroup.pages.find((sub) => sub.group === tagName);
  if (!tagSubGroup) {
    tagSubGroup = { group: tagName, pages: [] };
    mainGroup.pages.push(tagSubGroup);
  }

  // Adiciona a página ao subgrupo da tag
  tagSubGroup.pages.push(pagePath);
};

/**
 * Sorts the pages within a group based on the HTTP methods in the operationId.
 * Orders: GET, POST, PUT, DELETE.
 *
 * @param {object} group - The group object to sort
 */
const sortGroupPages = (group) => {
  // Iterando sobre cada subgrupo
  group.pages.forEach((subgroup) => {
    // Agora, 'subgroup.pages' deve ser um array de strings (URLs)
    subgroup.pages.sort((a, b) => {
      // Assumindo que 'a' e 'b' são strings das URLs agora
      const aMethod = a.includes("/get")
        ? "A"
        : a.includes("/post")
          ? "B"
          : a.includes("/put")
            ? "C"
            : "D";
      const bMethod = b.includes("/get")
        ? "A"
        : b.includes("/post")
          ? "B"
          : b.includes("/put")
            ? "C"
            : "D";
      return aMethod.localeCompare(bMethod);
    });
  });
};

// Run generateOpenApiPages and update mint.json file
generateOpenApiPages(
  "./development/api-reference/openapi.json",
  "./development/api-reference",
).then(() => {
  groupData.pages.forEach(sortGroupPages);
  console.log(JSON.stringify(groupData, null, 2));
  updateMintJson("mint_with_reference.json");
});


Para esse endpoint a autenticação deve ser passada no query params. Exemplo ?x-api-key=SUA_API-KEY

Receber evento kobana

ExternalWebhooksKobanaCreate

AuthQueryParam

Base39

A API da Base39 utiliza o protocolo OAuth 2.0 para autenticação e autorização. Este documento explica como implementar a autenticação em sua aplicação.

Autenticação

Na Base39, você pode importar dados diretamente para uma tabela usando a opção de Webhook por meio de requisições HTTP.

Webhooks de entrada

Endpoint para recebimento de dados via webhook

Webhook de entrada

Pesquisa linhas na base de dados usando filtros exatos

Pesquisar registros

Introdução

Soluções

Objetos principais

Este guia fornece uma lista abrangente de itens a serem configurados para inicializar o seu ambiente, seja ele de teste ou de produção, na plataforma.

Checklist

Todos

Novidades

Backoffice

Portal RH

Portal Cliente

APIs

Documentação

Visão geral

Configuração de estilos customizados para o Portal do Cliente

Estilos customizados

Configuração de textos customizados para o Portal Cliente

Textos customizados

Status da Base39

Central de Ajuda

Um produto é um conjunto de configurações que definem as regras de negócio de um empréstimo. Por exemplo, empréstimo consignado, antecipação do FGTS, antecipação de salário e etc.

Elegibilidade

Regras de elegibilidade

Oferta

Documentos

Desembolso

Detalhes de como realizar a migração da criação de documentos do empréstimo para as etapas da Esteira

Migração da criação de documentos

Recálculo de oferta

Antecipação de salário

Refinanciamento

Esteira é um conjunto de etapas que definem o ciclo de vida de um empréstimo, desde a originação até o desembolso.

Esteira

Status

Descreve o funcionamento de dependência entre as etapas da esteira.

Dependências

Os passsos configurados em todos os níveis são somados e exibidos na ordem de prioridade.

Hierarquia e exceções

Verificação de documento

Verificação de assinatura

Desembolsar

A etapa do tipo criação de documentos pode ser utilizada para criar documentos referentes ao empréstimo.

Criação de documentos

A etapa da Esteira do tipo UNICO pode ser utilizada para assegurar os dados de biometria de funcionários que solicitam empréstimo.

Unico

Eventos do webhook publicados pelo fluxo de esteira

Eventos do webhook

Hooks

Templates

Visualização das filas

Criando uma Fila

Editando uma Fila

Removendo uma Fila

O registro de vínculo empregatício preserva informações essenciais sobre a remuneração e margem consignável do cliente.

Importação de base de funcionários

Guia de configurações necessárias para realizar o processo de transferência de funcionário entre empresas filiais.

Transferência entre filiais

Regras de transferência de funcionários

Desligamento do funcionário sem proposta

Rescisão do funcionário

Operadores

QITech

API Externa

Objetos mock, objetos simulados ou simplesmente mock são objetos que simulam o comportamento de objetos reais de forma controlada.

Mock

Clientes

Email

Notificação de cobrança via automação

Temas

Configure os domínios das aplicações da Base39

Domínios

Validação de chave PIX

Entidades de dados (registros)

Guia passo a passo sobre como consultar parcelas vencidas e gerar uma fatura.

Vencidas

Pagamento excedente nas parcelas

Estorno e redistribuição automática

Constestação de parcelas

Guia de como criar uma fatura de devolução.

Devolução

Guia de como criar uma fatura de redistribuição entre parcelas.

Redistribuir

Guia de como criar uma fatura recorrente da empresa.

Fatura recorrente da empresa

Fatura de rescisão

Propósitos da fatura

Importação de fatura

Agrupar faturas

Criação automática de faturas recorrentes

Alterar a data de vencimento de um boleto

Integração para desembolso e validação de chave PIX com a QITech.

Infobip

Twilio

SMTP

Sendgrid

Envio de e-mail sem SMTP

Envio de e-mail através da Base39

Kobana

UNICO

180 Seguros

reCAPTCHA

A Base39 fornece ambientes diferentes para testes e produção. Esse guia mostra como usar esses ambientes.

Ambientes

Tipos de erros

Você pode usar esse parâmetro para anexar dados de valor-chave a esses objetos.

Metadata

Paginação

Tolerant reader

Expandindo referências

A sintaxe de pesquisa foi projetada para ser simples e intuitiva, permitindo que você realize buscas complexas com facilidade.

Pesquisa

A funcionalidade de campos solicitados oferece flexibilidade ao permitir a definição de campos específicos a serem incluídos nas respostas das chamadas de API.

Campos solicitados

Chaves de API

Data e hora

Valores percentuais

Valores financeiros

Formato do ID

Saiba mais sobre os limites de requisições da API e como trabalhar com eles

Limite de requisiões

Ambiente de testes

Auditoria

Idempotência

Implemente essas práticas recomendadas ao usar webhooks.

Melhores práticas

Tipos de eventos

Na Base39, adotamos uma abordagem inovadora para garantir a máxima disponibilidade e resiliência dos nossos serviços

Resiliência

Descreve as configurações de rede necessárias para se comunicar com a Base39.

Rede

Obter empréstimo

Retorna todos os empréstimos, ordenados por data de criação, com os mais recentes primeiro.

Listar empréstimos

Pesquise empréstimos que você criou anteriormente usando a linguagem de query.

Pesquisar empréstimos

Lista parcelas de um empréstimo, ordenadas por data (mais recentes primeiro). 
Para quitação antecipada, inclua `payment_for` com a data pretendida para calcular o valor da parcela.

Listar parcelas

Retorna todas as etapas da esteira do empréstimo, ordenadas por data de criação, com as mais recentes primeiro.

Listar passos da esteira de empréstimos

Atualiza o empréstimo com os parâmetros fornecidos, mantendo os não especificados inalterados.
Aceita os mesmos argumentos da criação do empréstimo.

Atualizar empréstimo

Criar empréstimo

Cancelar empréstimo

Anular empréstimo

Marcar empréstimo como expirado

Altera o estado de um empréstimo para aberto.

Alterar o estado de um empréstimo para aberto

Desembolsar empréstimo

Criar transação

Criar parcela

Marcar empréstimo como pendente

Anexar arquivo ao empréstimo

Assinar empréstimo

Exclui permanentemente um empréstimo. Não pode ser desfeito.

Excluir empréstimo

Remove do empréstimo o vínculo de um arquivo (esta operação não deletará o arquivo).

Desanexar arquivo do empréstimo

Retorna todas as políticas de crédito, ordenadas por data de criação, com os itens mais recentes primeiro.

Listar políticas de crédito

Obter política de crédito

Criar política de crédito

Atualizar política de crédito

Deletar uma política de crédito

Retorna todas as etapas do empréstimo, ordenadas por data de criação, com as mais recentes primeiro.

Listar etapas

Atualizar etapa

Reexecuta a validação de uma etapa do empréstimo, mas apenas se o status não for `done`.

Revalidar etapa

Retorna todos os produtos, ordenados por data de criação, com os mais recentes primeiro.

Listar produtos

Listar produtos elegíveis

Obter produto

Criar produto

Atualiza o produto com os parâmetros fornecidos. 
Parâmetros não fornecidos permanecem inalterados. Aceita os mesmos argumentos da criação do produto.

Atualizar produto

Exclui permanentemente um produto. Não pode ser desfeito.

Excluir produto

Obter oferta

Calcular oferta

Obter parcela

Retorna todas as parcelas, ordenadas por data de criação, com as mais recentes primeiro.

Anular parcela

Marcar parcela como incobrável

Exportar parcelas

Retorna todas as empresas. 

Os itens são retornados e ordenados por data de criação, com os itens mais recentes primeiro.

Listar empresas

Obter empresa

Pesquise empresas que você criou anteriormente usando a linguagem de query.

Visão geral

Ingestão de dados

Consulta de dados

Receber evento kobana

Authorizations

Query Parameters

Body

Response