Organization Configuration Service

Gerencia configurações e funcionalidades das organizações, permitindo controlar acessos, definir parâmetros e personalizar comportamentos do sistema.

Visão Geral

O OrganizationConfigurationService é responsável por:

• Buscar configurações da organização
• Consultar contextos de funcionalidades disponíveis
• Controlar acessos a funcionalidades específicas
• Definir valores padrões baseados em configurações
• Gerenciar permissões por organização, grupo ou usuário

As configurações permitem personalizar o comportamento do sistema, bloquear ou liberar funcionalidades e definir parâmetros específicos por contexto.

Localização: services/organization-configuration/organization-configuration.service.ts

Endpoints Utilizados

Base URL

Todos os endpoints são relativos à base URL configurada em services/api.service.ts

Métodos

fetchRemote(params)

Busca configurações da organização com paginação.

Endpoint: GET /configuracaoOrganizacao

Parâmetros:

type FetchOrganizationConfigurationParams = {
  page?: number; // Número da página (padrão: 0)
  size?: number; // Quantidade de itens por página (padrão: 999)
  dataHora?: string;
};

Query Params enviados:

• page: número da página
• size: tamanho da página
• dataHora: timestamp (opcional)

Retorno:

Promise<OrganizationConfiguration[]>;

Exemplo de uso:

import { organizationConfigurationService } from "@/services/organization-configuration/organization-configuration.service.instance";

// Buscar todas as configurações
const configs = await organizationConfigurationService.fetchRemote();

// Buscar com paginação
const configsPage = await organizationConfigurationService.fetchRemote({
  page: 0,
  size: 50,
});

Tratamento de erros:

• Lança Error se o status da resposta não for 2xx
• Mensagem: OrganizationConfigurationService.fetchRemote failed: {status}

---

fetchFeatureContextRemote(params)

Busca contextos de funcionalidades disponíveis por organização, grupo ou usuário.

Endpoint: GET /configuracaoOrganizacao/funcionalidades/context

Parâmetros:

// Por organização
type FetchFeatureContextsByOrganizationParams = {
  type: "organization";
  idSolution: string;
};

// Por grupo
type FetchFeatureContextsByGroupIdParams = {
  type: "group";
  idSolution: string;
  id: string;
};

// Por usuário
type FetchFeatureContextsByUserIdParams = {
  type: "user";
  idSolution: string;
  id: string;
};

Query Params enviados:

• type: tipo de contexto ("organization", "group", "user")
• idSolution: ID da solução
• id: ID do grupo ou usuário (quando aplicável)

Retorno:

Promise<FeatureContext[]>;

Exemplo de uso:

// Buscar funcionalidades da organização
const orgFeatures =
  await organizationConfigurationService.fetchFeatureContextRemote({
    type: "organization",
    idSolution: "sol-001",
  });

// Buscar funcionalidades de um grupo específico
const groupFeatures =
  await organizationConfigurationService.fetchFeatureContextRemote({
    type: "group",
    idSolution: "sol-001",
    id: "group-123",
  });

// Buscar funcionalidades de um usuário
const userFeatures =
  await organizationConfigurationService.fetchFeatureContextRemote({
    type: "user",
    idSolution: "sol-001",
    id: "user-456",
  });

Tratamento de erros:

• Lança Error se o status da resposta não for 2xx
• Mensagem: OrganizationConfigurationService.fetchFeatureContextRemote failed: {status}

---

fetchOrganizationConfigs()

Busca as configurações de contexto da organização (valores e estrutura usados pelo frontend).

Endpoint: GET /configuracaoOrganizacao/configuracoes/context

Parâmetros:

• nenhum

Retorno:

Promise<OrganizationConfigurationContext>;

Exemplo de uso:

import { organizationConfigurationService } from "@/services/organization-configuration/organization-configuration.service.instance";

const context =
  await organizationConfigurationService.fetchOrganizationConfigs();

console.log("Configurações de organização carregadas:", context);

Tratamento de erros:

• Lança Error se o status da resposta não for 2xx
• Mensagem: OrganizationConfigurationService.fetchOrganizationConfigs failed: {status}

---

Estruturas de Dados

Interface OrganizationConfiguration

interface OrganizationConfiguration {
  id: string;
  idOrganizacao: string;
  organizacao: string;
  idConfiguracao: string;
  configuracao: string;
  value: string;
  userId?: string | null;
  nomeUsuario?: string | null;
  sobrenomeUsuario?: string | null;
  idGrupoUsuarios?: string | null;
  nomeGrupoUsuarios?: string | null;
  usuarios: Pick<
    User,
    "id" | "firstname" | "lastname" | "userImageUrl" | "userImageKey"
  >[];
}

Interface FeatureContext

interface FeatureContext {
  id: string;
  nome: string;
  descricao: string;
  idSolucao: string;
  nomeSolucao: string;
  idVersao: string;
  versao: string;
  idPlano: string;
  plano: string;
  funcionalidadesFilhas: Feature[];
}

Interface Feature

interface Feature {
  id: string;
  nome: string;
  descricao: string;
  idSolucao: string;
  nomeSolucao: string;
  idVersao: string;
  versao: string;
  idPlano: string;
  plano: string;
  idFuncionalidadePai: string;
  funcionalidadePai: string;
  configuracoes: Configuration[];
}

Interface Configuration

interface Configuration {
  id: string;
  nome: string;
  descricao: string;
  pergunta?: string | null;
  tipo: string;
  valorPadrao: string;
  sequencia: number;
  categoria: string;
  categoriaId: string;
  solucaoId: string;
  solucaoNome: string;
  funcionalidadeId: string;
  funcionalidadeNome: string;
  opcoes: Option[];
}

---

Componentes Relacionados

buildQueryParams Helper

Função utilitária que converte objeto de parâmetros em URLSearchParams.

Localização: helpers/buildQueryParams.ts

PageResponse Interface

Interface compartilhada para respostas paginadas.

Localização: services/client/client.service.ts

---

Casos de Uso

Verificar se Funcionalidade está Habilitada

async function isFeatureEnabled(configName: string): Promise<boolean> {
  const configs = await organizationConfigurationService.fetchRemote();

  const config = configs.find((c) => c.configuracao === configName);

  return config?.value === "true" || config?.value === "enabled";
}

// Exemplo de uso
const canExport = await isFeatureEnabled("featureX.enabled");
if (canExport) {
  console.log("Exportação habilitada");
}

Obter Valor de Configuração

async function getConfigValue(
  configName: string,
  defaultValue: string = "",
): Promise<string> {
  const configs = await organizationConfigurationService.fetchRemote();

  const config = configs.find((c) => c.configuracao === configName);

  return config?.value ?? defaultValue;
}

// Exemplo de uso
const theme = await getConfigValue("theme", "light");
const maxAttempts = await getConfigValue("maxLoginAttempts", "3");

Listar Funcionalidades Disponíveis

async function getUserFeatures(userId: string, solutionId: string) {
  const features =
    await organizationConfigurationService.fetchFeatureContextRemote({
      type: "user",
      idSolution: solutionId,
      id: userId,
    });

  console.log("Funcionalidades disponíveis:");
  features.forEach((context) => {
    console.log(`\n${context.nome}:`);
    context.funcionalidadesFilhas.forEach((feature) => {
      console.log(`  - ${feature.nome} (${feature.plano})`);
    });
  });

  return features;
}

// Exemplo de uso
await getUserFeatures("user-123", "sol-001");

Verificar Permissões de Usuário

async function hasFeatureAccess(
  userId: string,
  featureName: string,
  solutionId: string,
): Promise<boolean> {
  const features =
    await organizationConfigurationService.fetchFeatureContextRemote({
      type: "user",
      idSolution: solutionId,
      id: userId,
    });

  for (const context of features) {
    const hasFeature = context.funcionalidadesFilhas.some(
      (f) => f.nome === featureName,
    );
    if (hasFeature) return true;
  }

  return false;
}

// Exemplo de uso
const canUseMFA = await hasFeatureAccess("user-123", "MFA", "sol-001");

---

Mocks

Localização

__mocks__/organization-configuration.mock.ts

Dados Disponíveis

Mock com 10 configurações de organizações:

• Configurações de tema, notificações, localização
• Valores padrões para diferentes organizações
• Usuários e grupos associados
• Contextos de funcionalidades com features e configurações
• Diferentes tipos de configurações (boolean, string, select, multiselect)

Exemplo de uso em testes:

import {
  organizationConfigurationResponseMock,
  featureContextsResponseMock,
} from "@/__mocks__/organization-configuration.mock";

// Mock fetchRemote
const apiWithoutAccessToken: any = {
  get: jest.fn(async () => ({
    status: 200,
    data: organizationConfigurationResponseMock,
  })),
};

const service = new OrganizationConfigurationService({
  apiWithoutAccessToken,
});
const result = await service.fetchRemote();

expect(result).toEqual(organizationConfigurationResponseMock.content);

---