mjailton - ligando você ao mundo do conhecimento

Passo 1 Salvando o XML

1 Montando o XML

Depois de preencher os campos com os respectivos dados, agora use a função monta para gerar o XML

x

$xml = $nfe->montaNFe();

2 Salvando o XML

Salve o xml gerado, seguindo os passos abaixo:

- De acordo o ambiente crie um pasta armazenar os dados, ou seja, homologação ou produção
- Crie um variável para armazenar o caminho onde os arquivos ficarão
- use um bloco try ... catch
- dentro do bloco chame o método montaNfe()
- pegue a chave,
- pegue o xml
- Salve o conteúdo no caminho definido

x

 if ($ambiente == 1){
            $PastaAmbiente = 'producao';
        }else{
            $PastaAmbiente = 'homologacao';
        }

        /********************* CRIAÇÃO DO XML ****************/
        $path = "arquivos/xml/{$emitente->cnpj}/{$PastaAmbiente}/temporaria";
        try {
            $nfe->montaNFe();
            $chave  = $nfe->getChave();
            $xml    = $nfe->getXML();
            if (!is_dir($path)) {
                mkdir($path, 0777, true);
            }
            $Filename = $path . '/' . $chave . '-nfe.xml';
            $response = file_put_contents($Filename, $xml);           

        } catch (\Throwable $th) {
            if($nfe->getErrors() !=null)
                i($nfe->getErrors());
            else            
                i($th->getMessage());
        }
       /***********************FIM CRIAÇÃO XML */

Passo 2 Assinando o XML

1 Montando o bloco de código

Entre na documentação do sped-nfe em: docs/metodos/SignNFe.md e copie o bloco de assinatura e coloque no seu projeto

x

try {
    $tools = new Tools($configJson, Certificate::readPfx($content, $password));
    $response = $tools->signNFe($xml);
   
} catch (\Exception $e) {
    //aqui você trata possiveis exceptions
    echo $e->getMessage();
}

2 Configuração

Copie o bloco de configuração do arquivo sped-nfe para o seu projeto (coloque no início do código)

x

$config = [
    "atualizacao" => "2015-10-02 06:01:21",
    "tpAmb" => 2,
    "razaosocial" => "Fake Materiais de construção Ltda",
    "siglaUF" => "SP",
    "cnpj" => "00716345000119",
    "schemes" => "PL_008i2",
    "versao" => "3.10",
    "tokenIBPT" => "AAAAAAA",
    "CSC" => "GPB0JBWLUR6HWFTVEAS6RJ69GPCROFPBBB8G",
    "CSCid" => "000002",
    "aProxyConf" => [
        "proxyIp" => "",
        "proxyPort" => "",
        "proxyUser" => "",
        "proxyPass" => ""
    ]
];

$json = json_encode($config);

3 Preenchendo dado da Configuração

Preencha os dados da configuração de acordo com a sua necessidade

x

$config = [
            "atualizacao" => date('Y-m-d h:i:s'),
            "tpAmb"       => $ambiente,
            "razaosocial" => $emitente->razao_social,
            "cnpj"        => $emitente->cnpj,
            "siglaUF"     => $emitente->uf,
            "schemes"     => "PL_009_V4",
            "versao"      => '4.00',
            "tokenIBPT"   => "",
            "CSC"         => "",
            "CSCid"       => "",
            "proxyConf"   => [
                "proxyIp"   => "",
                "proxyPort" => "",
                "proxyUser" => "",
                "proxyPass" => ""
            ]
        ];

4 Certificado Digital

Configure o seu certificado digital seguindo os passos:

- Salve o seu certificado digital em alguma pasta do projeto (no nosso projeto foi em em arquivo/certificado)
- Na classe DadosService procure pelo método certificado e configure o nome do arquivo e a senha do seu certificado
- Voltando para a classe NfeService, logo após o config, leia o certificado salvando os dados em uma variável, use o método file_get_contents para isso

x

$certificadoDigital = file_get_contents(URL_XML."/arquivos/certificado/".$certificado->nome_arquivo);

5 Objeto Tools

Crie um objeto chamado tools, o qual deverá receber como parâmetro o config e o certificado digital, sendo que o certificado digital deverá passar o certificado e a senha

x

$tools = new Tools(
  json_encode($config),
  Certificate::readPfx(
     $certificadoDigital,
     $certificado->senha
       )
   );

6 Assinando o arquivo

Faça a assinatura do arquivo, seguindo os seguintes passos:

- use o metodo signNFe para assinar o arquivo (lembrando que este arquivo será o mesmo que foi gerado anteriormente)
- uma vez assinado o arquivo crie um nova pasta chamada assinadas e nela salve o arquivo que foi assinado

x

/************ASSINANDO XML ************/
       try {
            $response_assinado = $tools->signNFe(file_get_contents($Filename));
            $path_assinadas = "arquivos/xml/{$emitente->cnpj}/{$PastaAmbiente}/assinadas";
            $caminho = $path_assinadas . '/' . $chave . '-nfe.xml';
            if (!is_dir($path_assinadas)) {
                mkdir($path_assinadas, 0777, true);
            }
            $resp = file_put_contents($caminho, $response_assinado);
            
            } catch (\Exception $e) {
                //aqui você trata possiveis exceptions
                echo $e->getMessage();
            } 

        /**FIM ASSINANDO XML */

7 Validando dados

Valide os dados que foram inserido no seu xml, até que o esquema fique totalmente correto, para isso você pode usar dois site:

- https://www.sefaz.rs.gov.br/nfe/NFE-VAL.aspx
- https://validador.nfe.tecnospeed.com.br/

x

Passo 3 Enviando o XML

1 Montando o bloco de código

Entre na documentação do sped-nfe em: docs/metodos/EnviaLote.md e copie o bloco de envio e coloque no seu projeto e adapte para que se torne funcional

x

try {
    //$content = conteúdo do certificado PFX
    $tools = new Tools($configJson, Certificate::readPfx($content, 'senha'));
    $idLote = str_pad($nfemit->id, 15, '0', STR_PAD_LEFT);
    //envia o xml para pedir autorização ao SEFAZ
    $resp = $this->tools->sefazEnviaLote([$xml], $idLote);
    //transforma o xml de retorno em um stdClass
    $st = new Standardize();
    $std = $st->toStd($resp);
    if ($std->cStat != 103) {
        //erro registrar e voltar
        return "[$std->cStat] $std->xMotivo";
    }
    $recibo = $std->infRec->nRec;
    //esse recibo deve ser guardado para a proxima operação que é a consulta do recibo
    header('Content-type: text/xml; charset=UTF-8');
    echo $resp;
} catch (\Exception $e) {
    echo str_replace("\n", "<br/>", $e->getMessage());
}

2 Enviando o arquivo

configure o bloco de código para o envio do xml, seguindo os seguintes passos:

- Configure o lote que será enviado
- no metodo sefazEnviaLote passe como parâmetro o xml assinado juntamente com o lote
- após o envio do lote a sefaz devolve um recibo, guarde esta informação em uma variável

x

 //**** enviar xml */

        try {
            $idLote = str_pad(100, 15, '0', STR_PAD_LEFT); // Identificador do lote
            //envia o xml para pedir autorização ao SEFAZ
            $resp = $tools->sefazEnviaLote([$response_assinado], $idLote);
            //transforma o xml de retorno em um stdClass
            $st = new Standardize();
            $std = $st->toStd($resp);
            if ($std->cStat != 103) {
                //erro registrar e voltar
                i($std->xMotivo);
            }
            $recibo = $std->infRec->nRec;
            //esse recibo deve ser guardado para a proxima operação que é a consulta do recibo
        
            echo "Recibo: " .$recibo ."<br>";
        } catch (\Exception $e) {
            i($e->getMessage());
        }
       //***** fim envio xml */

3 Consultando pelo recibo

Depois de enviado o xml, vamos verificar o protoculo pelo recibo, para isso seguiremos os passos abaixo

x

Montando o bloco de código

Entre na documentação do sped-nfe em: docs/metodos/ConsultaRecibo.md e copie o bloco de consulta e coloque no seu projeto

x

try {
    //$content = conteúdo do certificado PFX
    $tools = new Tools($configJson, Certificate::readPfx($content, 'senha'));
    
    //consulta número de recibo
    //$numeroRecibo = número do recíbo do envio do lote
    $xmlResp = $tools->sefazConsultaRecibo($numeroRecibo, $tpAmb);
    
    //transforma o xml de retorno em um stdClass
    $st = new Standardize();
    $std = $st->toStd($xmlResp);

    if ($std->cStat=='103') { //lote enviado
        //Lote ainda não foi precessado pela SEFAZ;
    }
    if ($std->cStat=='105') { //lote em processamento
        //tente novamente mais tarde
    }
    
    if ($std->cStat=='104') { //lote processado (tudo ok)
        if ($std->protNFe->infProt->cStat=='100') { //Autorizado o uso da NF-e
            $return = ["situacao"=>"autorizada",
                       "numeroProtocolo"=>$std->protNFe->infProt->nProt,
                       "xmlProtocolo"=>$xmlResp];
        } elseif (in_array($std->protNFe->infProt->cStat,["110", "301", "302"])) { //DENEGADAS
            $return = ["situacao"=>"denegada",
                       "numeroProtocolo"=>$std->protNFe->infProt->nProt,
                       "motivo"=>$std->protNFe->infProt->xMotivo,
                       "cstat"=>$std->protNFe->infProt->cStat,
                       "xmlProtocolo"=>$xmlResp];
        } else { //não autorizada (rejeição)
            $return = ["situacao"=>"rejeitada",
                       "motivo"=>$std->protNFe->infProt->xMotivo,
                       "cstat"=>$std->protNFe->infProt->cStat];
        }
    } else { //outros erros possíveis
        $return = ["situacao"=>"rejeitada",
                   "motivo"=>$std->xMotivo,
                   "cstat"=>$std->cStat];
    }
    
} catch (\Exception $e) {
    echo str_replace("\n", "<br/>", $e->getMessage());
}

Fazendo a Consulta

configure o bloco de código para o consulta da sefaz, seguindo os seguintes passos:

- no metodo sefazConsultaRecibo passe como parâmetro o recibo que foi enviado anteriormente
- Configure os retornos do seu projeto de acordo com o status devolvido
- após a consulta a sefaz devolve um número de protocolo, guarde esta informação em uma variável para ser usada para autorizar o xml

x

//******CONSULTAR O RECIBO *******/     
        try {        
            //
            $xmlResp = $tools->sefazConsultaRecibo($recibo);
            
            //transforma o xml de retorno em um stdClass
            $st = new Standardize();
            $std = $st->toStd($xmlResp);    
            if ($std->cStat=='103') { //lote enviado
                echo  "O lote ainda está sendo processado";
                       }
            if ($std->cStat=='105') { //lote em processamento
                echo "Lote em processamento, tente mais tarde";
               
            }
            
            if ($std->cStat=='104') { //lote processado (tudo ok)
                if ($std->protNFe->infProt->cStat=='100') { //Autorizado o uso da NF-e
                    $protocolo = $std->protNFe->infProt->nProt;
                    echo "Protocolo: " . $protocolo;

                } elseif (in_array($std->protNFe->infProt->cStat,["110", "301", "302"])) { //DENEGADAS
                    echo  "Denegada";
                     i($std->protNFe->infProt->cStat . ":". $std->protNFe->infProt->xMotivo) ;
                } else { //não autorizada (rejeição)
                    echo  "Rejeitada";
                     i($std->protNFe->infProt->cStat . ":". $std->protNFe->infProt->xMotivo) ;
                }
            } else { //outros erros possíveis
                echo  "Nota Rejeitada";
                 i($std->protNFe->infProt->cStat . ":". $std->protNFe->infProt->xMotivo) ;
            }
            
        } catch (\Exception $e) {
            i($e->getMessage());
        }

     
       /*************FIM CONSULTA RECIBO */

Passo 4 Autorizando o XML

1 Montando o bloco de código

Entre na documentação do sped-nfe em: docs/Complements.md e copie o bloco de complements para autorização e coloque no seu projeto

x

$req = "<XML conteudo original do documento que quer protocolar>";
$res = "<XML conteudo do retorno com a resposta da SEFAZ>";

try {
    $xml = Complements::toAuthorize($req, $res);
    header('Content-type: text/xml; charset=UTF-8');
    echo $xml;
} catch (\Exception $e) {
    echo "Erro: " . $e->getMessage();
}

2 Fazendo a autorização

configure o bloco de código para autorização da sefaz, seguindo os seguintes passos:

- no metodo Complements::toAuthorize passe como parâmetro o documento original e retorno devolvido após a consulta pelo recibo
- Caso dê tudo certo na autorização salve o documento dentro de uma pasta chamada autorizadas
- caso queira verificar se tá tudo ok, pegue a chave gerada entre na receita e faça a consulta pela chave

x

/** Transmissão Sefaz */

        $req = $response_assinado;
        $res = $xmlResp;

        try {
            $xml_autorizado = Complements::toAuthorize($req, $res);
            $path_autorizadas = "arquivos/xml/{$emitente->cnpj}/{$PastaAmbiente}/autorizadas";
            $caminho_aut = $path_autorizadas . '/' . $chave . '-nfe.xml';
            if (!is_dir($path_autorizadas)) {
                mkdir($path_autorizadas, 0777, true);
            }
            file_put_contents($caminho_aut, $xml_autorizado);
        } catch (\Exception $e) {
            echo "Erro: " . $e->getMessage();
        }

        echo "<br>Chave: " .$chave;

Passo 5 Gerando o Danfe

1 Montando o XML

2 Salvando o XML

1 Montando o bloco de código

2 Configuração

3 Preenchendo dado da Configuração

4 Certificado Digital

5 Objeto Tools

6 Assinando o arquivo

7 Validando dados

1 Montando o bloco de código

2 Enviando o arquivo

3 Consultando pelo recibo

1 Montando o bloco de código

2 Fazendo a autorização

Cole seu código aqui: