Validação Automática de NFe

import { ValidaNFeSDK } from 'validanfe-sdk';

class ValidadorNFe {
  constructor() {
    this.validanfe = new ValidaNFeSDK({
      apiKey: process.env.VALIDANFE_API_KEY
    });
  }

  async validarNFe(chaveNFe, xmlContent) {
    try {
      // Consulta status na Receita Federal
      const statusReceita = await this.validanfe.nfe.consultar({
        chave: chaveNFe,
        tipo: 'completa'
      });

      // Validações adicionais
      const validacoes = await this.executarValidacoes(statusReceita, xmlContent);
      
      return {
        status: 'validada',
        resultado_receita: statusReceita,
        validacoes: validacoes,
        timestamp: new Date().toISOString()
      };
      
    } catch (error) {
      return {
        status: 'erro',
        erro: error.message,
        timestamp: new Date().toISOString()
      };
    }
  }

  async executarValidacoes(nfeData, xmlContent) {
    const validacoes = [];
    
    // Validação 1: Status na Receita
    if (nfeData.status !== 'autorizada') {
      validacoes.push({
        tipo: 'status_receita',
        resultado: 'reprovado',
        mensagem: `NFe não autorizada: ${nfeData.status}`
      });
    }

    // Validação 2: Integridade do XML
    if (!this.validarIntegridadeXML(xmlContent, nfeData)) {
      validacoes.push({
        tipo: 'integridade_xml',
        resultado: 'reprovado',
        mensagem: 'Dados do XML não conferem com a Receita'
      });
    }

    // Validação 3: CNPJ do Emitente
    if (!await this.validarCNPJEmitente(nfeData.emitente.cnpj)) {
      validacoes.push({
        tipo: 'cnpj_emitente',
        resultado: 'reprovado',
        mensagem: 'CNPJ do emitente inválido ou suspeito'
      });
    }

    return validacoes;
  }
}

class ProcessadorLoteNFe {
  constructor() {
    this.validador = new ValidadorNFe();
    this.filaProcessamento = [];
  }

  async adicionarNFe(nfeData) {
    this.filaProcessamento.push({
      id: nfeData.id,
      chave: nfeData.chave,
      xml: nfeData.xml,
      fornecedor: nfeData.fornecedor,
      adicionado_em: new Date()
    });

    // Processar se fila atingir tamanho limite
    if (this.filaProcessamento.length >= 10) {
      await this.processarLote();
    }
  }

  async processarLote() {
    const lote = this.filaProcessamento.splice(0, 10);
    
    console.log(`Processando lote de ${lote.length} NFe...`);

    // Processar em paralelo para performance
    const promessas = lote.map(async (nfe) => {
      const resultado = await this.validador.validarNFe(nfe.chave, nfe.xml);
      
      return {
        nfe_id: nfe.id,
        chave: nfe.chave,
        fornecedor: nfe.fornecedor,
        resultado: resultado,
        processado_em: new Date()
      };
    });

    const resultados = await Promise.all(promessas);

    // Salvar resultados no banco
    await this.salvarResultados(resultados);
    
    // Notificar equipe sobre reprovações
    await this.notificarReprovacoes(resultados);
  }

  async notificarReprovacoes(resultados) {
    const reprovadas = resultados.filter(r => 
      r.resultado.status === 'erro' || 
      r.resultado.validacoes?.some(v => v.resultado === 'reprovado')
    );

    if (reprovadas.length > 0) {
      await this.enviarAlertaEquipe(reprovadas);
    }
  }
}

// Endpoint para receber webhooks da ValidaNFe
app.post('/webhook/validanfe', async (req, res) => {
  const { evento, dados } = req.body;

  switch (evento) {
    case 'nfe.consulta.concluida':
      await processarConsultaConcluida(dados);
      break;
      
    case 'nfe.consulta.erro':
      await processarErroConsulta(dados);
      break;
  }

  res.status(200).send('OK');
});

async function processarConsultaConcluida(dados) {
  // Atualizar status no banco
  await database.nfe.update({
    chave: dados.chave_nfe
  }, {
    status_receita: dados.status,
    dados_receita: dados,
    validado_em: new Date()
  });

  // Continuar fluxo de validação
  const nfe = await database.nfe.findOne({ chave: dados.chave_nfe });
  const validacoes = await executarValidacoesAdicionais(nfe);
  
  if (validacoes.aprovado) {
    await aprovarNFe(nfe);
  } else {
    await reprovarNFe(nfe, validacoes.motivos);
  }
}

// API para dashboard de validações
app.get('/api/dashboard/validacoes', async (req, res) => {
  const stats = await database.validacoes.aggregate([
    {
      $match: {
        processado_em: {
          $gte: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) // 30 dias
        }
      }
    },
    {
      $group: {
        _id: '$status',
        count: { $sum: 1 },
        valor_total: { $sum: '$valor_nfe' }
      }
    }
  ]);

  const fornecedoresProblematicos = await database.validacoes.aggregate([
    {
      $match: {
        'resultado.status': 'erro',
        processado_em: {
          $gte: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) // 7 dias
        }
      }
    },
    {
      $group: {
        _id: '$fornecedor',
        erros: { $sum: 1 }
      }
    },
    { $sort: { erros: -1 } },
    { $limit: 10 }
  ]);

  res.json({
    estatisticas: stats,
    fornecedores_problematicos: fornecedoresProblematicos,
    ultima_atualizacao: new Date()
  });
});