Merge pull request #18 from JurunenseDevInterno/dev

Dev

src/app/DRE/analitico.tsx

@@ -76,6 +76,8 @@ interface AnaliticoProps {
     codigoSubgrupo?: string;
     codigoConta?: string;
     linhaSelecionada?: string;
+    excluirCentroCusto?: string;
+    excluirCodigoConta?: string;
   };
 }
 
@@ -368,6 +370,12 @@ export default function AnaliticoComponent({ filtros }: AnaliticoProps) {
       if (filtrosExternos.codigoConta) {
         params.append('codigoConta', filtrosExternos.codigoConta);
       }
+      if (filtrosExternos.excluirCentroCusto) {
+        params.append('excluirCentroCusto', filtrosExternos.excluirCentroCusto);
+      }
+      if (filtrosExternos.excluirCodigoConta) {
+        params.append('excluirCodigoConta', filtrosExternos.excluirCodigoConta);
+      }
 
       const url = `/api/analitico-oracle?${params.toString()}`;
       console.log('🌐 Fazendo requisição para:', url);

src/app/DRE/teste.tsx

@@ -219,6 +219,8 @@ export default function Teste() {
     codigoSubgrupo: "",
     codigoConta: "",
     linhaSelecionada: "", // Adicionar informação da linha selecionada
+    excluirCentroCusto: "", // Para excluir centro de custo específico quando desmarcado
+    excluirCodigoConta: "", // Para excluir código de conta específico quando desmarcado
   });
   const [linhaSelecionada, setLinhaSelecionada] = useState<string | null>(null);
   const [isAllExpanded, setIsAllExpanded] = useState(false);
@@ -441,6 +443,26 @@ export default function Teste() {
       }
     });
 
+    // Determinar exclusões baseado nos filtros aplicados
+    let excluirCentroCusto = "";
+    let excluirCodigoConta = "";
+    
+    // Se o centro de custo "002.003.017" não está selecionado, excluir da consulta
+    if (!centrosCustoSelecionados.some(centro => {
+      const item = data.find((d: DREItem) => d.centro_custo === centro);
+      return item?.codigo_centro_custo === "002.003.017";
+    })) {
+      excluirCentroCusto = "002.003.017";
+    }
+    
+    // Se a conta "100050" não está selecionada, excluir da consulta
+    if (!contasSelecionadas.some(conta => {
+      const item = data.find((d: DREItem) => d.conta === conta);
+      return item?.codigo_conta?.toString() === "100050";
+    })) {
+      excluirCodigoConta = "100050";
+    }
+
     const novosFiltros = {
       dataInicio: dataInicioFiltro,
       dataFim: dataFimFiltro,
@@ -449,6 +471,8 @@ export default function Teste() {
       codigoSubgrupo,
       codigoConta: codigoContaFiltro,
       linhaSelecionada: row.grupo || row.subgrupo || row.centro_custo || row.conta || "", // Incluir informação da linha selecionada
+      excluirCentroCusto,
+      excluirCodigoConta,
     };
 
     console.log('🎯 Novos filtros para analítico:', novosFiltros);
@@ -661,22 +685,163 @@ export default function Teste() {
       return codigoA.localeCompare(codigoB);
     });
 
+    // Função para calcular valores de grupos calculados usando códigos dos grupos (mesma lógica da função principal)
+    const calcularGrupoCalculadoCompleta = (codigoGrupo: string, gruposData: Record<string, DREItem[]>): Record<string, number> => {
+      const valoresPorMes: Record<string, number> = {};
+      
+      // Inicializar valores para todos os meses disponíveis
+      mesesDisponiveis.forEach(mes => {
+        valoresPorMes[mes] = 0;
+      });
+
+      // Função auxiliar para obter valor de um grupo por código e mês
+      const obterValorGrupo = (codigoGrupo: string, mes: string): number => {
+        const grupoEncontrado = Object.values(gruposData).find(items => 
+          items.length > 0 && items[0].codgrupo === codigoGrupo
+        );
+        if (!grupoEncontrado) return 0;
+        
+        const itemsMes = grupoEncontrado.filter(item => item.data_competencia === mes);
+        return itemsMes.reduce((sum, item) => sum + parseFloat(item.valor), 0);
+      };
+
+      switch (codigoGrupo) {
+        case "03": // Faturamento Líquido = Grupo 01 + 02
+          mesesDisponiveis.forEach(mes => {
+            const valor01 = obterValorGrupo("01", mes);
+            const valor02 = obterValorGrupo("02", mes);
+            valoresPorMes[mes] = valor01 + valor02;
+          });
+          break;
+          
+        case "05": // Lucro Bruto = Grupo 03 + 04
+          mesesDisponiveis.forEach(mes => {
+            const valor03 = obterValorGrupo("03", mes);
+            const valor04 = obterValorGrupo("04", mes);
+            valoresPorMes[mes] = valor03 + valor04;
+          });
+          break;
+          
+        case "07": // Margem Loja = Grupo 05 + 06
+          mesesDisponiveis.forEach(mes => {
+            const valor05 = obterValorGrupo("05", mes);
+            const valor06 = obterValorGrupo("06", mes);
+            valoresPorMes[mes] = valor05 + valor06;
+          });
+          break;
+          
+        case "10": // Resultado Operacional = Grupo 07 + 08 + 09
+          mesesDisponiveis.forEach(mes => {
+            const valor07 = obterValorGrupo("07", mes);
+            const valor08 = obterValorGrupo("08", mes);
+            const valor09 = obterValorGrupo("09", mes);
+            valoresPorMes[mes] = valor07 + valor08 + valor09;
+          });
+          break;
+          
+        case "13": // Resultado Financeiro = Grupo 11 + 12
+          mesesDisponiveis.forEach(mes => {
+            const valor11 = obterValorGrupo("11", mes);
+            const valor12 = obterValorGrupo("12", mes);
+            valoresPorMes[mes] = valor11 + valor12;
+          });
+          break;
+          
+        case "18": // Outras Receitas/Despesas = Grupo 14 + 15 + 16 + 17
+          mesesDisponiveis.forEach(mes => {
+            const valor14 = obterValorGrupo("14", mes);
+            const valor15 = obterValorGrupo("15", mes);
+            const valor16 = obterValorGrupo("16", mes);
+            const valor17 = obterValorGrupo("17", mes);
+            valoresPorMes[mes] = valor14 + valor15 + valor16 + valor17;
+          });
+          break;
+          
+        case "19": // LAIR = Grupo 10 + 13 + 18
+          mesesDisponiveis.forEach(mes => {
+            const valor10 = obterValorGrupo("10", mes);
+            const valor13 = obterValorGrupo("13", mes);
+            const valor18 = obterValorGrupo("18", mes);
+            valoresPorMes[mes] = valor10 + valor13 + valor18;
+          });
+          break;
+          
+        case "20": // IR = Se LAIR > 0 calcular 20% e resultado negativo (*-1), se não 0
+          mesesDisponiveis.forEach(mes => {
+            const valor19 = obterValorGrupo("19", mes);
+            if (valor19 > 0) {
+              valoresPorMes[mes] = (valor19 * 0.20) * -1;
+            } else {
+              valoresPorMes[mes] = 0;
+            }
+          });
+          break;
+          
+        case "21": // CSLL = Se LAIR > 0 calcular 9% e resultado negativo (*-1), se não 0
+          mesesDisponiveis.forEach(mes => {
+            const valor19 = obterValorGrupo("19", mes);
+            if (valor19 > 0) {
+              valoresPorMes[mes] = (valor19 * 0.09) * -1;
+            } else {
+              valoresPorMes[mes] = 0;
+            }
+          });
+          break;
+          
+        case "22": // Lucro Líquido = Grupo 19 + 20 + 21
+          mesesDisponiveis.forEach(mes => {
+            const valor19 = obterValorGrupo("19", mes);
+            const valor20 = obterValorGrupo("20", mes);
+            const valor21 = obterValorGrupo("21", mes);
+            valoresPorMes[mes] = valor19 + valor20 + valor21;
+          });
+          break;
+          
+        case "24": // EBITDA = Grupo 19 - (13 + 18 + 23)
+          mesesDisponiveis.forEach(mes => {
+            const valor19 = obterValorGrupo("19", mes);
+            const valor13 = obterValorGrupo("13", mes);
+            const valor18 = obterValorGrupo("18", mes);
+            const valor23 = obterValorGrupo("23", mes);
+            valoresPorMes[mes] = valor19 - (valor13 + valor18 + valor23);
+          });
+          break;
+      }
+      
+      return valoresPorMes;
+    };
+
     sortedGrupos.forEach(([grupo, items]) => {
       const totalGrupo = items.reduce(
         (sum, item) => sum + parseFloat(item.valor),
         0
       );
 
+      // Verificar se é um grupo calculado
+      const codigoGrupo = items[0]?.codgrupo || "";
+      const isCalculado = ["03", "05", "07", "10", "13", "18", "19", "20", "21", "22", "24"].includes(codigoGrupo);
+      
+      let valoresGrupoPorMes;
+      if (isCalculado) {
+        // Usar cálculo específico para grupos calculados
+        valoresGrupoPorMes = calcularGrupoCalculadoCompleta(codigoGrupo, grupos);
+      } else {
+        // Usar cálculo normal para grupos não calculados
+        valoresGrupoPorMes = calcularValoresPorMes(items);
+      }
+
+      // Calcular total do grupo
+      const totalCalculado = Object.values(valoresGrupoPorMes).reduce((sum, valor) => sum + valor, 0);
+
       // Linha do grupo (Level 0)
-      const valoresGrupoPorMes = calcularValoresPorMes(items);
       rows.push({
         type: "grupo",
         level: 0,
         grupo,
-        total: totalGrupo,
+        total: isCalculado ? totalCalculado : totalGrupo,
         valoresPorMes: valoresGrupoPorMes,
         percentuaisPorMes: calcularPercentuaisPorMes(valoresGrupoPorMes, grupo),
-        isCalculado: items[0]?.isCalculado || false,
+        isCalculado: isCalculado,
       });
 
       if (ordemHierarquiaContasPrimeiro) {
@@ -1091,23 +1256,164 @@ export default function Teste() {
       return grupoA.localeCompare(grupoB);
     });
 
+    // Função para calcular valores de grupos calculados usando códigos dos grupos
+    const calcularGrupoCalculado = (codigoGrupo: string, gruposData: Record<string, DREItem[]>): Record<string, number> => {
+      const valoresPorMes: Record<string, number> = {};
+      
+      // Inicializar valores para todos os meses disponíveis
+      mesesDisponiveis.forEach(mes => {
+        valoresPorMes[mes] = 0;
+      });
+
+      // Função auxiliar para obter valor de um grupo por código e mês
+      const obterValorGrupo = (codigoGrupo: string, mes: string): number => {
+        const grupoEncontrado = Object.values(gruposData).find(items => 
+          items.length > 0 && items[0].codgrupo === codigoGrupo
+        );
+        if (!grupoEncontrado) return 0;
+        
+        const itemsMes = grupoEncontrado.filter(item => item.data_competencia === mes);
+        return itemsMes.reduce((sum, item) => sum + parseFloat(item.valor), 0);
+      };
+
+      switch (codigoGrupo) {
+        case "03": // Faturamento Líquido = Grupo 01 + 02
+          mesesDisponiveis.forEach(mes => {
+            const valor01 = obterValorGrupo("01", mes);
+            const valor02 = obterValorGrupo("02", mes);
+            valoresPorMes[mes] = valor01 + valor02;
+          });
+          break;
+          
+        case "05": // Lucro Bruto = Grupo 03 + 04
+          mesesDisponiveis.forEach(mes => {
+            const valor03 = obterValorGrupo("03", mes);
+            const valor04 = obterValorGrupo("04", mes);
+            valoresPorMes[mes] = valor03 + valor04;
+          });
+          break;
+          
+        case "07": // Margem Loja = Grupo 05 + 06
+          mesesDisponiveis.forEach(mes => {
+            const valor05 = obterValorGrupo("05", mes);
+            const valor06 = obterValorGrupo("06", mes);
+            valoresPorMes[mes] = valor05 + valor06;
+          });
+          break;
+          
+        case "10": // Resultado Operacional = Grupo 07 + 08 + 09
+          mesesDisponiveis.forEach(mes => {
+            const valor07 = obterValorGrupo("07", mes);
+            const valor08 = obterValorGrupo("08", mes);
+            const valor09 = obterValorGrupo("09", mes);
+            valoresPorMes[mes] = valor07 + valor08 + valor09;
+          });
+          break;
+          
+        case "13": // Resultado Financeiro = Grupo 11 + 12
+          mesesDisponiveis.forEach(mes => {
+            const valor11 = obterValorGrupo("11", mes);
+            const valor12 = obterValorGrupo("12", mes);
+            valoresPorMes[mes] = valor11 + valor12;
+          });
+          break;
+          
+        case "18": // Outras Receitas/Despesas = Grupo 14 + 15 + 16 + 17
+          mesesDisponiveis.forEach(mes => {
+            const valor14 = obterValorGrupo("14", mes);
+            const valor15 = obterValorGrupo("15", mes);
+            const valor16 = obterValorGrupo("16", mes);
+            const valor17 = obterValorGrupo("17", mes);
+            valoresPorMes[mes] = valor14 + valor15 + valor16 + valor17;
+          });
+          break;
+          
+        case "19": // LAIR = Grupo 10 + 13 + 18
+          mesesDisponiveis.forEach(mes => {
+            const valor10 = obterValorGrupo("10", mes);
+            const valor13 = obterValorGrupo("13", mes);
+            const valor18 = obterValorGrupo("18", mes);
+            valoresPorMes[mes] = valor10 + valor13 + valor18;
+          });
+          break;
+          
+        case "20": // IR = Se LAIR > 0 calcular 20% e resultado negativo (*-1), se não 0
+          mesesDisponiveis.forEach(mes => {
+            const valor19 = obterValorGrupo("19", mes);
+            if (valor19 > 0) {
+              valoresPorMes[mes] = (valor19 * 0.20) * -1;
+            } else {
+              valoresPorMes[mes] = 0;
+            }
+          });
+          break;
+          
+        case "21": // CSLL = Se LAIR > 0 calcular 9% e resultado negativo (*-1), se não 0
+          mesesDisponiveis.forEach(mes => {
+            const valor19 = obterValorGrupo("19", mes);
+            if (valor19 > 0) {
+              valoresPorMes[mes] = (valor19 * 0.09) * -1;
+            } else {
+              valoresPorMes[mes] = 0;
+            }
+          });
+          break;
+          
+        case "22": // Lucro Líquido = Grupo 19 + 20 + 21
+          mesesDisponiveis.forEach(mes => {
+            const valor19 = obterValorGrupo("19", mes);
+            const valor20 = obterValorGrupo("20", mes);
+            const valor21 = obterValorGrupo("21", mes);
+            valoresPorMes[mes] = valor19 + valor20 + valor21;
+          });
+          break;
+          
+        case "24": // EBITDA = Grupo 19 - (13 + 18 + 23)
+          mesesDisponiveis.forEach(mes => {
+            const valor19 = obterValorGrupo("19", mes);
+            const valor13 = obterValorGrupo("13", mes);
+            const valor18 = obterValorGrupo("18", mes);
+            const valor23 = obterValorGrupo("23", mes);
+            valoresPorMes[mes] = valor19 - (valor13 + valor18 + valor23);
+          });
+          break;
+      }
+      
+      return valoresPorMes;
+    };
+
     sortedGrupos.forEach(([grupo, items]) => {
       const totalGrupo = items.reduce(
         (sum, item) => sum + parseFloat(item.valor),
         0
       );
 
+      // Verificar se é um grupo calculado
+      const codigoGrupo = items[0]?.codgrupo || "";
+      const isCalculado = ["03", "05", "07", "10", "13", "18", "19", "20", "21", "22", "24"].includes(codigoGrupo);
+      
+      let valoresPorMes;
+      if (isCalculado) {
+        // Usar cálculo específico para grupos calculados
+        valoresPorMes = calcularGrupoCalculado(codigoGrupo, grupos);
+      } else {
+        // Usar cálculo normal para grupos não calculados
+        valoresPorMes = calcularValoresPorMes(items);
+      }
+
+      // Calcular total do grupo
+      const totalCalculado = Object.values(valoresPorMes).reduce((sum, valor) => sum + valor, 0);
+
       // Linha do grupo
-      const valoresPorMes = calcularValoresPorMes(items);
       rows.push({
         type: "grupo",
         level: 0,
         grupo,
-        total: totalGrupo,
+        total: isCalculado ? totalCalculado : totalGrupo,
         isExpanded: expandedGroups.has(grupo),
         valoresPorMes,
         percentuaisPorMes: calcularPercentuaisPorMes(valoresPorMes, grupo),
-        isCalculado: items[0]?.isCalculado || false, // Usar a propriedade isCalculado do primeiro item
+        isCalculado: isCalculado,
       });
 
       if (expandedGroups.has(grupo)) {

src/app/api/analitico-oracle/route.ts

@@ -16,12 +16,18 @@ export async function GET(request: NextRequest) {
     const codigoGrupo = searchParams.get('codigoGrupo');
     const codigoConta = searchParams.get('codigoConta');
     
+    // Parâmetros para exclusão de valores específicos
+    const excluirCentroCusto = searchParams.get('excluirCentroCusto');
+    const excluirCodigoConta = searchParams.get('excluirCodigoConta');
+
     console.log('🎯 Filtros recebidos:', {
       dataInicio,
       dataFim,
       centroCusto,
       codigoGrupo,
-      codigoConta
+      codigoConta,
+      excluirCentroCusto,
+      excluirCodigoConta
     });
 
     // Construir query SQL com filtros
@@ -61,6 +67,22 @@ export async function GET(request: NextRequest) {
       console.log('💰 Adicionando filtro de conta:', codigoConta);
     }
 
+    // Exclusão de centro de custo específico (quando desmarcado)
+    if (excluirCentroCusto) {
+      sql += ` AND CODIGOCENTROCUSTO != :${paramIndex}`;
+      params.push(excluirCentroCusto);
+      paramIndex++;
+      console.log('🚫 Excluindo centro de custo:', excluirCentroCusto);
+    }
+
+    // Exclusão de código de conta específico (quando desmarcado)
+    if (excluirCodigoConta) {
+      sql += ` AND CODCONTA != :${paramIndex}`;
+      params.push(excluirCodigoConta);
+      paramIndex++;
+      console.log('🚫 Excluindo código de conta:', excluirCodigoConta);
+    }
+
     sql += ` ORDER BY DTVENC, CODFORNEC, CODCONTA`;
 
     console.log('🗄️ Query SQL final:', sql);