Linha do tempo : Emissão de NFE
Passo 1 Iniciando

  • 1 chamando o método

    No controller NfeController crie o método transmitirPelaNfe, o qual deverá:

    - após preparar os dados da nota chamar o método valida da classe ValidaDadosNfeService

    x 
    public function transmitirPelaNfe($nfe_id){
        $notafiscal     = NotaFiscalService::prepararNfe($nfe_id);
        $dados_validos =  ValidaDadosService::valida($notafiscal);

    }

    2 Classe ValidaDadosService

    crie uma classe chamada ValidaDadosService

    x 
    <?php
namespace App\Service;


class ValidaDadosNfeService{

}

      • na classe ValidaDadosNfeService crie o método valida, o qual deverá receber os dados da nfe e validar cada um dos valores

        x

    3 objeto notafiscal

    Crie dois objetos stdClass um chamado retorno e outro notafiscal e também um bloco try/catch onde iremos validar todos os dados da nota

    x 
    $retorno = new stdClass;
        $notafiscal = new stdClass;
try{
            

$retorno->tem_erro = false;
            $retorno->erro = "";
            $retorno->notafiscal = $notafiscal;
            return $retorno;
} catch (\Throwable $th) {
            $retorno->tem_erro = true;
            $retorno->erro = $th->getMessage();
            $retorno->notafiscal = null;
            return $retorno;
        }
        return $retorno;

    4 Nodes Obrigatórios

    No método valida verifique a existência dos dados obrigatórios da nota, listados abaixo

    x

      • Faça um verificação se existe o node ide, caso não exista gere uma exceção

        x 
        if(!isset($dados->ide)){
                $retorno->titulo =  "Erro ao ler objeto";
                throw new \Exception("É Obrigatório o envio do node Ide para emissão da NFE");
            }

      • Faça um verificação se existe o node emitente, caso não exista gere uma exceção

        x 
        if(!isset($dados->emitente)){
                $retorno->titulo =  "Erro ao ler objeto";
                throw new \Exception("É Obrigatório o envio do node Emitente para emissão da NFE");
            }

      • Faça um verificação se existe o node destinatario, caso não exista gere uma exceção

        x 
        if(!isset($dados->destinatario)){
                $retorno->titulo =  "Erro ao ler objeto";
                throw new \Exception("É Obrigatório o envio do node Destinatario para emissão da NFE");
            }

      • Faça um verificação se existe o node itens, caso não exista gere uma exceção

        x 
        if(!isset($dados->itens)){
                $retorno->titulo =  "Erro ao ler objeto";
                throw new \Exception("É Obrigatório o envio do node Itens para emissão da NFE");
            }

      • Faça um verificação se existe o node pagamentos, caso não exista gere uma exceção

        x 
        if(!isset($dados->pagamentos)){
                $retorno->titulo =  "Erro ao ler objeto";
                throw new \Exception("É Obrigatório o envio do node pagamentos para emissão da NFE");
            }

    5 Validando Nodes

    Após verificar a existência dos nodes, verifique o conteúdo de cada node validando cada campo obrigatório

    x

      • valide os campos do node Ide, crie um método para fazer a validação

        x 
        public static function validaIde($dados, $emitente, $destinatario){

        $dados->cUF             = ConstanteService::getUf($emitente->UF);
        $dados->cMunFG          = $emitente->cMun;

        if(!isset($dados->nNF) || blank($dados->nNF)  || is_null($dados->nNF)) {
            throw new \Exception('O Campo nNF é Obrigatório');
        }

        if(!isset($dados->natOp) || blank($dados->natOp)  || is_null($dados->natOp)) {
            throw new \Exception('O Campo natOp é Obrigatório');
        }

        if(!isset($dados->mod) || blank($dados->mod)  || is_null($dados->mod)) {
            throw new \Exception('O Campo mod é Obrigatório');
        }

        if(!isset($dados->serie) || blank($dados->serie)  || is_null($dados->serie)) {
            throw new \Exception('O Campo serie é Obrigatório');
        }

        if(!isset($dados->dhEmi) || blank($dados->dhEmi)  || is_null($dados->dhEmi)) {
            throw new \Exception('O Campo dhEmi é Obrigatório');
        }

        if(!isset($dados->tpImp) || blank($dados->tpImp)  || is_null($dados->tpImp)) {
            throw new \Exception('O Campo tpImp é Obrigatório');
        }

        if(!isset($dados->tpEmis) || blank($dados->tpEmis)  || is_null($dados->tpEmis)) {
            throw new \Exception('O Campo tpEmis é Obrigatório');
        }

        if(!isset($dados->tpAmb) || blank($dados->tpAmb)  || is_null($dados->tpAmb)) {
            throw new \Exception('O Campo tpAmb é Obrigatório');
        }
        if(!isset($dados->finNFe) || blank($dados->finNFe)  || is_null($dados->finNFe)) {
            throw new \Exception('O Campo finNFe é Obrigatório');
        }
        if(!isset($dados->indFinal) || blank($dados->indFinal)  || is_null($dados->indFinal)) {
            throw new \Exception('O Campo indFinal é Obrigatório');
        }

        if(!isset($dados->procEmi) || blank($dados->procEmi)  || is_null($dados->procEmi)) {
            throw new \Exception('O Campo procEmi é Obrigatório');
        }
        if(!isset($dados->verProc) || blank($dados->verProc)  || is_null($dados->verProc)) {
            throw new \Exception('O Campo verProc é Obrigatório');
        }

        if(!isset($dados->modFrete) || blank($dados->modFrete)  || is_null($dados->modFrete)) {
            throw new \Exception('O Campo modFrete do node Ide é Obrigatório');
        }

        if(!isset($emitente->UF) || blank($emitente->UF)  || is_null($emitente->UF)) {
            throw new \Exception('O Campo UF do node Emitente é Obrigatório');
        }
        if(!isset($destinatario->UF) || blank($destinatario->UF)  || is_null($destinatario->UF)) {
            throw new \Exception('O Campo UF do node Destinatario é Obrigatório');
        }

        if($emitente->UF !="EX"){
            if($emitente->UF == $destinatario->UF){
                $dados->idDest = config("constanteNota.idDest.INTERNA");
            }else{
                $dados->idDest = config("constanteNota.idDest.INTERESTADUAL");
            }
        }else{
            $dados->idDest = config("constanteNota.idDest.EXTERIOR");
        }

    }

      • valide os campos do node Emitente

        x 
        public static function validaEmitente($dados){

        if(!isset($dados->CNPJ) || blank($dados->CNPJ)  || is_null($dados->CNPJ)) {
            throw new \Exception('O Campo CNPJ do node Emitente é Obrigatório');
        }
        if(!isset($dados->xNome) || blank($dados->xNome)  || is_null($dados->xNome)) {
            throw new \Exception('O Campo xNome  do node Emitente é Obrigatório');
        }
        if(!isset($dados->xLgr) || blank($dados->xLgr)  || is_null($dados->xLgr)) {
            throw new \Exception('O Campo xLgr do node Emitente é Obrigatório');
        }
        if(!isset($dados->nro) || blank($dados->nro)  || is_null($dados->nro)) {
            throw new \Exception('O Campo nro do node Emitente é Obrigatório');
        }
        if(!isset($dados->xBairro) || blank($dados->xBairro)  || is_null($dados->xBairro)) {
            throw new \Exception('O Campo xBairro do node Emitente é Obrigatório');
        }
        if(!isset($dados->cMun) || blank($dados->cMun)  || is_null($dados->cMun)) {
            throw new \Exception('O Campo cMun do node Emitente é Obrigatório');
        }
        if(!isset($dados->xMun) || blank($dados->xMun)  || is_null($dados->xMun)) {
            throw new \Exception('O Campo xMun do node Emitente é Obrigatório');
        }
        if(!isset($dados->UF) || blank($dados->UF)  || is_null($dados->UF)) {
            throw new \Exception('O Campo UF do node Emitente é Obrigatório');
        }
        if(!isset($dados->CEP) || blank($dados->CEP)  || is_null($dados->CEP)) {
            throw new \Exception('O Campo CEP do node Emitente é Obrigatório');
        }
        if(!isset($dados->IE) || blank($dados->IE)  || is_null($dados->IE)) {
            throw new \Exception('O Campo IE do node Emitente é Obrigatório');
        }
        if(!isset($dados->CRT) || blank($dados->CRT)  || is_null($dados->CRT)) {
            throw new \Exception('O Campo CRT do node Emitente é Obrigatório');
        }

    }

      • valide os campos do node destinatario

        x 
         public static function validaDestinatario($dados){

        if(!isset($dados->xNome) || blank($dados->xNome)  || is_null($dados->xNome)) {
            throw new \Exception('O Campo xNome do node Destinatário é Obrigatório');
        }
        if(!isset($dados->xLgr) || blank($dados->xLgr)  || is_null($dados->xLgr)) {
            throw new \Exception('O Campo xLgr do node Destinatário  é Obrigatório');
        }
        if(!isset($dados->nro) || blank($dados->nro)  || is_null($dados->nro)) {
            throw new \Exception('O Campo nro do node Destinatário  é Obrigatório');
        }
        if(!isset($dados->xBairro) || blank($dados->xBairro)  || is_null($dados->xBairro)) {
            throw new \Exception('O Campo xBairro é Obrigatório');
        }
        if(!isset($dados->cMun) || blank($dados->cMun)  || is_null($dados->cMun)) {
            throw new \Exception('O Campo cMun do node Destinatário  é Obrigatório');
        }
        if(!isset($dados->xMun) || blank($dados->xMun)  || is_null($dados->xMun)) {
            throw new \Exception('O Campo xMun do node Destinatário  é Obrigatório');
        }
        if(!isset($dados->UF) || blank($dados->UF)  || is_null($dados->UF)) {
            throw new \Exception('O Campo UF do node Destinatário  é Obrigatório');
        }
        if(!isset($dados->CEP) || blank($dados->CEP)  || is_null($dados->CEP)) {
            throw new \Exception('O Campo CEP do node Destinatário  é Obrigatório');
        }

        if((is_null($dados->CNPJ) && is_null($dados->CPF))) {
            throw new \Exception('O Campo CPF ou CNPJ do node Destinatário  é Obrigatório');
        }

        if(!isset($dados->indIEDest) || blank($dados->indIEDest)  || is_null($dados->indIEDest)) {
            throw new \Exception('O Campo indIEDest do node Destinatário  é Obrigatório');
        }

        if($dados->indIEDest!=9){
            if(!isset($dados->IE) || blank($dados->IE)  || is_null($dados->IE)) {
                throw new \Exception('A Incrição Estadual é obrigatória para Contribuintes ICMS');
            }
        }

    }

      • valide os campos do node itens

        x 
        foreach($dados->itens as $item){
                if(!isset($item["produto"])){
                    $retorno->titulo =  "Erro ao ler objeto";
                    throw new \Exception("É Obrigatório o envio do node Produto   para emissão da NFE");
                }

                if(!isset($item["icms"])){
                    throw new \Exception('É obrigatório o envio do node icms para emissão da nota');
                }

                if(!isset($item["pis"])){
                    throw new \Exception('É obrigatório o envio do node pis para emissão da nota');
                }

                if(!isset($item["cofins"])){
                    throw new \Exception('É obrigatório o envio do node cofins para emissão da nota');
                }
                self::validaProduto($item["produto"]);
            }

        • Faça a validação dos campos do node produto

          x 
          public static function validaProduto($array){
        $dados = (object) $array;
        if(!isset($dados->cProd) || blank($dados->cProd)  || is_null($dados->cProd)) {
            throw new \Exception('O Campo cProd do node Produto é Obrigatório');
        }
        if(!isset($dados->xProd) || blank($dados->xProd)  || is_null($dados->xProd)) {
            throw new \Exception('O Campo xProd do node Produto é Obrigatório');
        }
        if(!isset($dados->NCM) || blank($dados->NCM)  || is_null($dados->NCM)) {
            throw new \Exception('O Campo NCM do node Produto é Obrigatório');
        }
        if(!isset($dados->CFOP) || blank($dados->CFOP)  || is_null($dados->CFOP)) {
            throw new \Exception('O Campo CFOP do node Produto é Obrigatório');
        }
        if(!isset($dados->uCom) || blank($dados->uCom)  || is_null($dados->uCom)) {
            throw new \Exception('O Campo uCom do node Produto é Obrigatório');
        }
        if(!isset($dados->qCom) || blank($dados->qCom)  || is_null($dados->qCom)) {
            throw new \Exception('O Campo qCom do node Produto é Obrigatório');
        }
        if(!isset($dados->vUnCom) || blank($dados->vUnCom)  || is_null($dados->vUnCom)) {
            throw new \Exception('O Campo vUnCom do node Produto é Obrigatório');
        }
        if(!isset($dados->vProd) || blank($dados->vProd)  || is_null($dados->vProd)) {
            throw new \Exception('O Campo vProd do node Produto é Obrigatório');
        }
        if(!isset($dados->uTrib) || blank($dados->uTrib)  || is_null($dados->uTrib)) {
            throw new \Exception('O Campo uTrib do node Produto é Obrigatório');
        }

        if(!isset($dados->qTrib) || blank($dados->qTrib)  || is_null($dados->qTrib)) {
            throw new \Exception('O Campo qTrib do node Produto é Obrigatório');
        }
        if(!isset($dados->vUnTrib) || blank($dados->vUnTrib)  || is_null($dados->vUnTrib)) {
            throw new \Exception('O Campo vUnTrib do node Produto é Obrigatório');
        }

        if(!isset($dados->indTot) || blank($dados->indTot)  || is_null($dados->indTot)) {
            throw new \Exception('O Campo indTot do node Produto é Obrigatório');
        }

    }

      • Faça a validação do Node Pagamento

        x 
        public static function validarPagamentos($array){
        if(count($array) <=0) {
            throw new \Exception('É Obrigatório ter pelo menos um pagamento');
        }
        $pagamentos = array();
        foreach($array as $pag){
            $detalhe = $pag["detalhe"] ?? null;
            if(!$detalhe){
                throw new \Exception('É obrigatório informar os detalhes do pagamento');
            }
            if(!isset($detalhe->tPag) || blank($detalhe->tPag)  || is_null($detalhe->tPag)) {
                throw new \Exception('O Campo tPag do Node Pagamento é Obrigatório');
            }
            if(!isset($detalhe->vPag) || blank($detalhe->vPag)  || is_null($detalhe->vPag)) {
                throw new \Exception('O Campo vPag do Node Pagamento é Obrigatório');
            }


            $card = $pag["cartao"] ?? null;
            $cartao = null;
            if($card){
                if(!isset($card->tpIntegra) || blank($card->tpIntegra)  || is_null($card->tpIntegra)) {
                    throw new \Exception('O Campo tpIntegra do Node Pagamento é Obrigatório');
                }
            }

            $pagamentos[] = array(
                "pagamento" => $detalhe,
                "cartao"    => $cartao
            );

        }
        return $pagamentos;
    }

      • Faça a validação do Node Tranporte

        x 
         public static function validarTransporte($dados_transporte){

        $transporte = new stdClass;
        $transporte->transportadora = null;
        $transporte->retencao       = null;
        $transporte->veiculo        = null;
        $transporte->reboque        = null;
        $transporte->volume         = null;



        if(isset($dados_transporte->retencao)){
            $dados      = $dados_transporte->retencao;

            if(!isset($dados->vServ) || blank($dados->vServ)  || is_null($dados->vServ)) {
                throw new \Exception('O Campo vServ do node Retenção Transporte é Obrigatório');
            }
            if(!isset($dados->vBCRet) || blank($dados->vBCRet)  || is_null($dados->vBCRet)) {
                throw new \Exception('O Campo vBCRet do node Retenção Transporte é Obrigatório');
            }
            if(!isset($dados->pICMSRet) || blank($dados->pICMSRet)  || is_null($dados->pICMSRet)) {
                throw new \Exception('O Campo pICMSRet do node Retenção Transporte é Obrigatório');
            }
            if(!isset($dados->vICMSRet) || blank($dados->vICMSRet)  || is_null($dados->vICMSRet)) {
                throw new \Exception('O Campo vICMSRet do node Retenção Transporte é Obrigatório');
            }
            if(!isset($dados->CFOP) || blank($dados->CFOP)  || is_null($dados->CFOP)) {
                throw new \Exception('O Campo CFOP do node Retenção Transporte é Obrigatório');
            }
            if(!isset($dados->cMunFG) || blank($dados->cMunFG)  || is_null($dados->cMunFG)) {
                throw new \Exception('O Campo cMunFG do node Retenção Transporte é Obrigatório');
            }


        }
        if(isset($dados_transporte->veiculo)){
            $dados      = $dados_transporte->veiculo;
            if(!isset($dados->placa) || blank($dados->placa)  || is_null($dados->placa)) {
                throw new \Exception('O Campo placa do Node Veículo é Obrigatório');
            }

            if(!isset($dados->UF) || blank($dados->UF)  || is_null($dados->UF)) {
                throw new \Exception('O Campo UF do Node Veículo é Obrigatório');
            }

        }

        //Dados do Reboque
        if(isset($dados_transporte->reboque)){
            $dados      = $dados_transporte->reboque;
            if(!isset($dados->placa) || blank($dados->placa)  || is_null($dados->placa)) {
                throw new \Exception('O Campo placa do Node Reboque é Obrigatório');
            }

            if(!isset($dados->UF) || blank($dados->UF)  || is_null($dados->UF)) {
                throw new \Exception('O Campo UF do Node Reboque é Obrigatório');
            }
        }

    }

      • Faça a validação do Node Cobrança

        x 
        public static function validarCobranca($array){
        $dados_cobranca = (object) $array;
        $cobranca = new stdClass();
        $cobranca->fatura = null;
        $cobranca->duplicatas = array();

        //Dados da fatura


        //Dados da Duplicata
        if(isset($dados_cobranca->duplicatas)){
            if(count($dados_cobranca->duplicatas) <=0) {
                throw new \Exception('É Obrigatório ter pelo menos uma duplicata');
            }
            $i = 1;
            foreach($dados_cobranca->duplicatas as $dup){
                if(!isset($dup->dVenc) || blank($dup->dVenc)  || is_null($dup->dVenc)) {
                    throw new \Exception('O Campo dVenc do Node Duplicata é Obrigatório');
                }
                if(!isset($dup->vDup) || blank($dup->vDup)  || is_null($dup->vDup)) {
                    throw new \Exception('O Campo vDup do Node Duplicata é Obrigatório');
                }
               /* $dup["nDup"] = zeroEsquerda($i++,3);
                $duplicata = new Duplicata();
                $duplicata->converterArrayParaObjeto($dup);
                $cobranca->duplicatas[] = $duplicata;*/
            }
        }
        return $cobranca;
    }

Passo 2 método valida
Passo 3 Certificado Digital

  • 1 Classe CertificadoDigitalService

    Crie uma classe chamada CertificadoDigitalService

    x 
    <?php

namespace App\Service;

class CertificadoDigitalService{

    }

    2 método buscarPeloCnpj

    na classe CertificadoDigitalService crie um método chamado buscarPeloCnpj que recebe o cnpj e retorne os dados do certificado

    x 
    public static function buscarPeloCnpj($cnpj){
        return CertificadoDigital::where("cnpj", $cnpj)->first();
    }

    3 Verificando o certificado

    Faça a validação se existe um certificado digital cadastrado

    x 
    //Verifica se o certificado digital existe;
            $certificado = CertificadoDigitalService::buscarPeloCnpj($dados->emitente->CNPJ );
            if(!$certificado){
                $retorno->titulo    = "Erro ao ler Cerificado Digital";
                throw new \Exception('Nenhum certificado digital foi encontrado para este CNPJ');
            }

❮ ❯
X Códigos
X Vídeo
X Imagem
mjailton.com.br