Linha do tempo : Emissão de NFE
Passo 1 Imprimindo Danfe

  • 1 Instalando a biblioteca

    instale a biblioteca sped com o comando: composer require nfephp-org/sped-da

    x

    2 método simularDanfe

    na classe NfeController crie um método chamado simularDanfe passando o nfe_id como parâmetro, o qual deverá:

    - chamar o método prepararNfe da classe NotaFiscalService
    - chamar o métod gerarNfe da classe NfeService
    - chamar o método getConfiguracaoNfe da classe ConfiguracaoService
    - chamar o método gerarXmlTemp da classe NfeService passando a nfe como parametro
    - chamar o método danfe da classe NfeService
    - retornar o resultado

    x 
    public function simularDanfe($nfe_id){
        $retorno    = new \stdClass();
        $notafiscal     = NotaFiscalService::prepararNfe($nfe_id);
        ValidaDadosNfeService::valida($notafiscal);
        $nfe            = NfeService::gerarNfe($notafiscal);
        $configuracao   = ConfiguracaoService::getConfiguracaoNfe($notafiscal->emitente->cnpj,$notafiscal->emitente->xNome, $notafiscal->emitente->UF, $notafiscal->ide->tpAmb );
        $xml            = NfeService::gerarXml($nfe, $configuracao, $nfe_id);

        if($xml->tem_erro){
            $retorno->tem_erro = true;
            $retorno->erro = $xml->erro;
            return response()->json($xml, 201);
        }


        $danfe      = NfeService::simulaDanfe($xml->xml);
        if(!$danfe->tem_erro){
            return response($danfe->pdf)->header("Content-type", "application/pdf");
        }else{
            return response()->json("erro",401);
        }
    }

      • crie a rota simularDanfe da classe NfeController

        x 
        Route::get('/nfe/simularDanfe/{id}',[NfeController::class,'simularDanfe'])->name('nfe.simularDanfe');

      • Na classe NfeService crie um método chamado gerarXmlTemp, o qual deverá receber um objeto nfe como parâmetro e fazer:

        - chamar o método montaNfe
        - retornar o xml
        - retornar a chave

        x

    3 método danfe

    Na classe NfeService crie um método chamado danfe, o qual deverá receber um xml e retornar o danfe

    x 
    public static function danfe($xml){
        $retorno = new \stdClass();
        try {
            $danfe = new Danfe($xml);
            $pdf = $danfe->render();
            $retorno->tem_erro  = false;
            $retorno->titulo    = "Pdf gerado com sucesso";
            $retorno->erro      = "";
            $retorno->pdf       = $pdf;
        } catch (\Exception $e) {
            $retorno->tem_erro  = true;
            $retorno->titulo    = "Erro gerar o PDF";
            $retorno->erro      = $e->getMessage();
        }

        return $retorno;
    }

    4 método imprimirDanfePelaNfe

    no controller NfeController crie um método chamado imprimirDanfePelaNfe que recebe o nfe_id como parâmetro e deverá:

    - buscar a nfe pelo id
    - definir o tipo de pasta onde foi salvo o xml
    - buscar o arquivo xml salvo
    - imprimir o danfe

    x 
    public function imprimirDanfePelaNfe($id_nfe){
        $nfe            = Nfe::where("id", $id_nfe)->first();
        $pastaAmbiente  = ($nfe->tpAmb == "1") ? "producao" : "homologacao";
        $path           = "storage/". $nfe->em_CNPJ."/xml/nfe/".$pastaAmbiente."/autorizadas/".$nfe->chave."-nfe.xml";
        $xml            = file_get_contents($path);

        $danfe = NfeService::danfe($xml);
        if(!$danfe->tem_erro){
            return response($danfe->pdf)->header("Content-type", "application/pdf");
        }else{
            return response()->json("erro",401);
        }
    }

      • Crie a rota para chamar o método imprimirDanfePelaNfe do controller NfeController

        x 
        
Route::get("/nfe/imprimirDanfePelaNfe/{id}", [NfeController::class, "imprimirDanfePelaNfe"])->name("nfe.imprimirDanfePelaNfe");

    5 método imprimirDanfePelaChave

    no controller NfeController crie um método chamado imprimirDanfePelaChave que recebe a chave como parâmetro e deverá:

    - buscar a nfe pela chave
    - definir o tipo de pasta onde foi salvo o xml
    - buscar o arquivo xml salvo
    - imprimir o danfe

    x 
    public function imprimirDanfePelaChave($chave){
        $nfe            = Nfe::where("chave", $chave)->first();
        $pastaAmbiente  = ($nfe->tpAmb == "1") ? "producao" : "homologacao";
        $path           = "storage/". $nfe->em_CNPJ."/xml/nfe/".$pastaAmbiente."/autorizadas/".$chave."-nfe.xml";
        $xml            = file_get_contents($path);

        $danfe = NfeService::danfe($xml);
        if(!$danfe->tem_erro){
            return response($danfe->pdf)->header("Content-type", "application/pdf");
        }else{
            return response()->json("erro",401);
        }
    }

      • Crie a rota para chamar o método imprimirDanfePelaChave do controller NfeController

        x 
        
Route::get("/nfe/imprimirDanfePelaChave/{id}", [NfeController::class, "imprimirDanfePelaChave"])->name("nfe.imprimirDanfePelaChave");

Passo 2 Cancelando NFE

  • 1 metodo cancelarNfe

    no controller NfeController crie um método chamado cancelarNfe, o qual deverá:

    - buscar a nfe pelo id
    - buscar o método getConfiguracaoNfe da classe ConfiguracaoService
    - chamar o método cancelarNfe da classe NfeService
    - retornar o resultado

    x 
    public function cancelarNfe(Request $request){
        $nfe         = Nfe::find($request->nfe_id);
        $configuracao= ConfiguracaoService::getConfiguracaoNfe($nfe->em_CNPJ, $nfe->em_xNome,$nfe->em_UF, $nfe->tpAmb);
        $retorno     = NfeService::cancelarNfe($request->justificativa, $request->nfe_id, $request->chave, $configuracao);
        return $retorno;
    }

      • crie a rota para o método cancelarNfe do controller NfeController

        x 
        Route::post('/nfe/cancelarNfe',[NfeController::class,'cancelarNfe'])->name('nfe.cancelarNfe');

    2 método cancelarNfe - service

    na classe NfeService crie um método chamado cancelarNfe, o qual deverá receber como parâmetro a justificativa, nfe_id, chave e configuracao e devera:

    - chamar o método tools->sefazConsultaChave para consultar a chave da sefaz
    - chamar o método tools->sefazCancela($chave, $justificativa, $nProt) para fazer o cancelamento
    - salvar o xml cancelado
    - atualizar o status da nfe
    - salvar os dados do log
    - retornar o resultado

    x 
    public static function cancelarNfe($justificativa, $nfe_id, $chave, $configuracao){
        $retorno = new \stdClass();
        try {
            $chave          = $chave;
            $response       = $configuracao->tools->sefazConsultaChave($chave);

            $stdCl          = new Standardize($response);
            $std            = $stdCl->toStd();
            $nProt          = $std->protNFe->infProt->nProt;

            $response       = $configuracao->tools->sefazCancela($chave, $justificativa, $nProt);
            $stdCl          = new Standardize($response);
            $std            = $stdCl->toStd();

            $path           = "storage/". $configuracao->pastaEmpresa."/xml/nfe/". $configuracao->pastaAmbiente."/cancelado/";
            $nome_arquivo   = $chave."-nfe.xml";
            if (!file_exists($path)){
                mkdir($path, 07777, true);
            }

            if ($std->cStat != 128) {
                //erro registrar e voltar
                $retorno->tem_erro  = true;
                $retorno->titulo    = "O lote nem foi processado, houve um problema " ;
                $retorno->erro      = $std->xMotivo;
                NfeLogService::salvar($nfe_id, config("constantes.status.ERRO_CANCELAMENTO_NOTA"), $chave, $retorno->titulo, $retorno->erro);
                return $retorno;
            } else {
                $cStat = $std->retEvento->infEvento->cStat;
                if ($cStat == '101' || $cStat == '135' || $cStat == '155') {
                    $xml_cancelado = Complements::toAuthorize($configuracao->tools->lastRequest, $response);
                    file_put_contents($path.$nome_arquivo, $xml_cancelado);
                    chmod($path, 07777);
                    Nfe::where("id",$nfe_id)->update(["status_id" => config("constantes.status.CANCELADO")]);

                    $retorno->tem_erro  = false;
                    $retorno->titulo    = "Nota cancelada com sucesso";
                    $retorno->erro      = "";

                    $idLote =$std->idLote ?? null;
                    NfeLogService::salvar($nfe_id, config("constantes.status.CANCELADO"), $chave, "Nota Cancelada", "Nota Cancelada com Sucesso", $idLote);
                    return $retorno;
                } else {
                    $motivo = $std->retEvento->infEvento->xMotivo ?? "01: Não foi Possível Fazer o Cancelamento";
                    $retorno->tem_erro  = true;
                    $retorno->titulo    = "01: Não foi Possível Fazer o Cancelamento";
                    $retorno->erro      = $motivo;
                    NfeLogService::salvar($nfe_id, config("constantes.status.ERRO_CANCELAMENTO_NOTA"), $chave, $retorno->titulo, $retorno->erro);
                    return $retorno;
                }
            }
        } catch (\Exception $e) {
            $retorno->tem_erro  = true;
            $retorno->titulo    = "02: Não foi Possível Fazer o Cancelamento";
            $retorno->erro      = $e->getMessage();
            NfeLogService::salvar($nfe_id, config("constantes.status.ERRO_CANCELAMENTO_NOTA"), $chave, $retorno->titulo, $retorno->erro);
            return $retorno;
        }

        return $retorno;
    }

Passo 3 Carta Correção

  • 1 metodo cartaCorrecao

    No controller NfeController crie um método chamado CartaCorrecao, o qual deverá

    - buscar a nfe pelo id
    - buscar a configuracao
    - chamar o método cartaCorrecao da classe NfeService

    x 
    public function cartaCorrecao(Request $request){
        $nfe            = Nfe::find($request->nfe_id);
        $configuracao   = ConfiguracaoService::getConfiguracaoNfe($nfe->em_CNPJ, $nfe->em_xNome,$nfe->em_UF, $nfe->tpAmb);
        $correcao       =  NfeService::cartaCorrecao($request->sequencia, $request->justificativa, $nfe->id, $nfe->chave, $configuracao);
        return $correcao;
    }

      • cria a rota para chamar o método cartaCorrecao

        x 
        Route::post('/nfe/cartaCorrecao',[NfeController::class,'cartaCorrecao'])->name('nfe.cartaCorrecao');

    2 método cartaCorrecao - service

    crie o método chamado cartaCorrecao no controller NfeService

    x 
     public static function cartaCorrecao($nSeqEvento, $justificativa, $nfe_id, $chave, $configuracao){
        $retorno            = new \stdClass();
        try {
            $path           = "storage/". $configuracao->pastaEmpresa."/xml/nfe/". $configuracao->pastaAmbiente."/correcao/";
            $nome_arquivo   = $chave."-nfe.xml";
            if (!file_exists($path)){
                mkdir($path, 07777, true);
            }
            $response = $configuracao->tools->sefazCCe($chave, $justificativa, $nSeqEvento);
            sleep(1);
            $stdCl = new Standardize($response);

            $std = $stdCl->toStd();
            $arr = $stdCl->toArray();
            $json = $stdCl->toJson();
            sleep(1);
            if ($std->cStat != 128) {
                $retorno->tem_erro  = true;
                $retorno->titulo    = "Erro gerar o Carta de Correção";
                $retorno->erro      = $std->xMotivo;
                $retorno->retorno   = NULL;
                return $retorno;
            }else {
                $cStat = $std->retEvento->infEvento->cStat;
                if ($cStat == '135' || $cStat == '136') {

                    $xml = Complements::toAuthorize($configuracao->tools->lastRequest, $response);
                    file_put_contents($path.$nome_arquivo, $xml);
                    chmod($path, 07777);
                    Nfe::where("id",$nfe_id)->update(["sequencia_cce" => $nSeqEvento]);


                    $retorno->tem_erro  = false;
                    $retorno->titulo    = "Carta de Correção gerada com sucesso";
                    $retorno->erro      = "";

                    $idLote =$std->idLote ?? null;
                    NfeLogService::salvar($nfe_id, config("constantes.status.CARTA_CORRECAO_ENVIADA"), $chave, "Carta Correção Enviada", "Carta de Correção gerada com sucesso", $idLote);
                    return $retorno;
                } else {
                    $retorno->tem_erro  = true;
                    $retorno->titulo    = "Erro gerar o Carta de Correção";
                    $retorno->erro      = $json;
                    $retorno->retorno   = NULL;
                    NfeLogService::salvar($nfe_id, config("constantes.status.EROO_ENVIO_CARTA_CORRECAO"), $chave, $retorno->titulo, $retorno->erro);
                    return $retorno;
                }
            }
        } catch (\Exception $e) {
            $retorno->tem_erro  = true;
            $retorno->titulo    = "Erro gerar o Carta de Correção";
            $retorno->erro      = $e->getMessage();
            $retorno->retorno   = NULL;
            NfeLogService::salvar($nfe_id, config("constantes.status.EROO_ENVIO_CARTA_CORRECAO"), $chave, $retorno->titulo, $retorno->erro);
            return $retorno;
        }
        return $retorno;
    }

Passo 4 Inutilizar Numeração

  • 1 método inutilizar

    x

      • x

    2 metodo inutilizar - service

    x
Passo 5 Enviando Email

  • 1 Enviando email

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