mjailton - ligando você ao mundo do conhecimento

Linha do tempo : Emissão de NFE

Passo 1 Instalando

1 classe NfeService
crie uma classe chamada NfeService
x
<?php namespace App\Service; use stdClass; class NfeService{ }
2 método gerarNfe
Na classe NfeService crie um método chamado gerarNfe, o qual recebe como parâmetro os dados da notafiscal
x
public static function gerarNfe($notafiscal){ }
3 Instalando a biblioteca NfePHP

instale a biblioteca sped-nfe usando o comando: composer require nfephp-org/sped-nfe

x
4 classe MontarXmlService
crie uma classe chamada MontarXmlService
x
<?php namespace App\Service; use stdClass; class MontarXmlService{ }

Passo 2 Método gerarNfe

1 tag infNFe

chame o método infNfe da classe MontarXmlService

MontarXmlService::infNfe($nfe);

metodo infNfe

popule os dados da tag infNfe

public static function infNfe($nfe){
        $std = new \stdClass();
        $std->versao = '4.00'; //versão do layout (string)
        $std->Id = ''; //se o Id de 44 digitos não for passado será gerado automaticamente
        $std->pk_nItem = null; //deixe essa variavel sempre como NULL

        $nfe->taginfNFe($std);
    }

2 tag ide

chame o método ide da classe MontarXmlService

MontarXmlService::infNfe($nfe);

metodo ide

popule os dados da tag ide

 public static function ide($nfe, $dados){
        $std            = new \stdClass();
        $std->cUF       = $dados->cUF;
        $std->nNF       = $dados->nNF;
        $std->cNF       = $dados->cNF ?? rand(11111,99999);;
        $std->natOp     = tiraAcento($dados->natOp);
        //$std->indPag    = 0; //NÃO EXISTE MAIS NA VERSÃO 4.00
        $std->mod       = $dados->mod;
        $std->serie     = $dados->serie;
        $std->dhEmi     = $dados->dhEmi ?? date("Y-m-d\TH:i:sP");
        $std->dhSaiEnt  = null;
        $std->tpNF      = $dados->tpNF;
        $std->idDest    = $dados->idDest;
        $std->cMunFG    = $dados->cMunFG;
        $std->tpImp     = $dados->tpImp;
        $std->tpEmis    = $dados->tpEmis;
        $std->cDV       = null;
        $std->tpAmb     = $dados->tpAmb;
        $std->finNFe    = $dados->finNFe;
        $std->indFinal  = $dados->indFinal;
        $std->indPres   = $dados->indPres;
        $std->indIntermed = $dados->indIntermed ?? null;
        $std->procEmi   = $dados->procEmi;
        $std->verProc   = $dados->verProc;
        $std->dhCont    = $dados->dhCont ?? null;
        $std->xJust     = $dados->xJust ?? null;
        $nfe->tagide($std);
    }

3 tag emitente

chame o método emitente da classe MontarXmlService

MontarXmlService::emitente($nfe, $notafiscal->emitente);

metodo emitente

popule os dados da tag emitente

public static function emitente($nfe, $dados){
        $std = new \stdClass();
        $std->xNome	= tiraAcento(limita_caracteres($dados->xNome,45))	;
        $std->xFant	= tiraAcento($dados->xFant)	;
        $std->IE	= tira_mascara($dados->IE)	    ;
        $std->IEST	= $dados->IEST	;
        $std->IM	= $dados->IM	    ;
        $std->CNAE	= $dados->CNAE	;
        $std->CRT	= $dados->CRT	;

        if($dados->CNPJ):
            $std->CNPJ = tira_mascara($dados->CNPJ);
            $std->CPF = null;
        elseif($dados->CPF):
            $std->CNPJ = NULL;
            $std->CPF  = tira_mascara($dados->CPF);
        else:
            $std->CNPJ = null;
            $std->CPF = null;
        endif;
        $nfe->tagemit($std);

        //endereço do dados
        $std = new \stdClass();
        $std->xLgr		= tiraAcento(limita_caracteres($dados->xLgr,45))	;
        $std->nro		= $dados->nro	    ;
        $std->xCpl		= tiraAcento($dados->xCpl)	;
        $std->xBairro   = tiraAcento(limita_caracteres($dados->xBairro,45))	;
        $std->cMun		= $dados->cMun	;
        $std->xMun		= tiraAcento($dados->xMun)	;
        $std->UF		= $dados->UF		;
        $std->CEP		= tira_mascara($dados->CEP)	    ;
        $std->cPais		= $dados->cPais	;
        $std->xPais		= tiraAcento($dados->xPais)	;
        $std->fone		= $dados->fone    ;
        $nfe->tagenderEmit($std);
    }

4 tag destinatario

chame o método destinatario da classe MontarXmlService

MontarXmlService::destinatario($nfe, $notafiscal->destinatario);

metodo destinatario

popule os dados da tag destinatario

public static function destinatario($nfe, $dados){
        $std = new \stdClass();
        $std->xNome = tiraAcento(limita_caracteres($dados->xNome,56 )) 	;
        $std->indIEDest	= $dados->indIEDest	;
        $std->IE	= $dados->IE ? tira_mascara($dados->IE) : null		;
        $std->ISUF	= $dados->ISUF		;
        $std->IM	= $dados->IM		;
        $std->email	= $dados->email		;
        $std->idEstrangeiro= $dados->idEstrangeiro;

        if($dados->CNPJ):
            $std->CNPJ = tira_mascara($dados->CNPJ);
            $std->CPF = null;
        elseif($dados->CPF):
            $std->CNPJ = NULL;
            $std->CPF  = tira_mascara($dados->CPF);
        else:
            $std->CNPJ = null;
            $std->CPF = null;
        endif;

        $nfe->tagdest($std);

        //Endereço do destinatário
        $std = new \stdClass();
        $std->xLgr	= tiraAcento($dados->xLgr)		;
        $std->nro	= $dados->nro		;
        $std->xCpl	= tiraAcento($dados->xCpl)		;
        $std->xBairro= tiraAcento($dados->xBairro)	;
        $std->cMun	= $dados->cMun		;
        $std->xMun	= tiraAcento($dados->xMun)		;
        $std->UF	= $dados->UF		;
        $std->CEP	= tira_mascara($dados->CEP)		;
        $std->cPais	= $dados->cPais		;
        $std->xPais	= tiraAcento($dados->xPais)		;
        $std->fone	= $dados->fone		;

        $nfe->tagenderDest($std);
    }

5 itens

faça um loop com o itens da nfe e preecha as tags: produto, ipi, pis, cofins e icms

$cont = 1;
        foreach($notafiscal->itens as $item){
            
            $cont++;
        }

tag imposto

chame o método imposto da classe MontarXmlService
x
```
MontarXmlService::imposto($cont, $nfe, $item);
```

metodo imposto

popule os dados da tag imposto

public function imposto($cont, $nfe, $item){
        $std = new \stdClass();
        $std->item  = $cont; //item da NFe
        $std->vTotTrib = $item->vTotTrib;

        $nfe->tagimposto($std);
    }

tag produto

chame o método produto da classe MontarXmlService

 MontarXmlService::produto($cont, $nfe, $item["produto"]);

metodo produto

popule o método produto

public static function produto($cont, $nfe, $dados){
        $std            = new \stdClass();
        $std->item      = $cont; //item da NFe
        $std->cProd     = $dados->cProd;
        $std->cEAN      = $dados->cEAN;
        $std->xProd     = tiraAcento($dados->xProd);
        $std->NCM       = tira_mascara($dados->NCM);
        $std->cBenef    = $dados->cBenef; //incluido no layout 4.00
        $std->EXTIPI    = $dados->EXTIPI;
        $std->CFOP      = $dados->CFOP;
        $std->uCom      = $dados->uCom;
        $std->qCom      = formataNumero($dados->qCom);
        $std->vUnCom    = formataNumero($dados->vUnCom);
        $std->vProd     = formataNumero($dados->vProd);
        $std->cEANTrib  = $dados->cEANTrib;
        $std->uTrib     = $dados->uTrib;
        $std->qTrib     = formataNumero($dados->qTrib);
        $std->vUnTrib   = formataNumero($dados->vUnTrib);        ;
        $std->vFrete    = ($dados->vOutro > 0) ? formataNumero($dados->vFrete) : null;
        $std->vSeg      = ($dados->vSeg > 0) ? formataNumero($dados->vSeg) : null  ;
        $std->vDesc     = ($dados->vDesc > 0) ? formataNumero($dados->vDesc) : null;
        $std->vOutro    = ($dados->vOutro > 0) ? formataNumero($dados->vOutro) : null ;
        $std->indTot    = $dados->indTot;
        $std->xPed      = $dados->xPed;
        $std->nItemPed  = $dados->nItemPed;
        $std->nFCI      = $dados->nFCI;
        $nfe->tagprod($std);

        if(isset($dados->CEST) ) {
            $std = new \stdClass();
            $std->item = $cont; //item da NFe
            $std->CEST = tira_mascara($dados->CEST);
            $nfe->tagCEST($std);
        }
    }

tag ipi

chame o método ipi da classe MontarXmlService

if(isset($item["ipi"]->CST)){
                MontarXmlService::ipi($cont, $nfe, $item["ipi"]);
            }

metodo ipi

popule o método ipi

public static function ipi($cont,$nfe, $dados){
        $std                = new \stdClass();
        $std->item          = $cont; //item da NFe
        $std->CST           = $dados->CST;
        $std->CNPJProd      = $dados->CNPJProd ? tira_mascara($dados->CNPJProd) : null;
        $std->cSelo         = $dados->cSelo;
        $std->qSelo         = $dados->qSelo ?? rand(11111,99999);;
        $std->cEnq          = $dados->cEnq;
        $std->vBC           = $dados->vBC ? formataNumero($dados->vBC) : null;
        $std->pIPI          = $dados->pIPI ? formataNumero($dados->pIPI) : null;
        $std->vIPI          = $dados->vIPI ? formataNumero($dados->vIPI) : null;
        $std->qUnid         = $dados->qUnid ? formataNumero($dados->qUnid) : null;
        $std->vUnid         = $dados->vUnid ? formataNumero($dados->vUnid) : null;
        $nfe->tagIPI($std);
    }

tag icms

chame o método icms da classe MontarXmlService

MontarXmlService::icms($cont,$nfe, $item["icms"]);

metodo icms

popule os dados da tag icms

public static function icms($cont, $nfe, $dados){
        $std                    = new \stdClass();
        $std->item              = $cont; //item da NFe
        $std->orig              = $dados->orig;

        if(intval($dados->CST) < 99){
            $std->CST           = $dados->CST ;
            $cst                = $std->CST;
        }else{
            $std->CSOSN          = $dados->CSOSN;
            $cst                 = $std->CSOSN;
        }

        if($cst=="00"){
            $std->modBC             = $dados->modBC;
            $std->vBC               = $dados->vBC ? formataNumero($dados->vBC) : null;
            $std->pICMS             = $dados->pICMS ? formataNumero($dados->pICMS) : null;
            $std->vICMS             = $dados->vICMS ? formataNumero($dados->vICMS) : null;

            if($dados->vFCP){
                $std->vBCFCP            = $dados->vBCFCP ? formataNumero($dados->vBCFCP) : null;
                $std->pFCP              = $dados->pFCP ? formataNumero($dados->pFCP) : null;
                $std->vFCP              = $dados->vFCP ? formataNumero($dados->vFCP) : null;
            }

        }elseif($cst=="10"){
            $std->modBC             = $dados->modBC;
            $std->vBC               = $dados->vBC ? formataNumero($dados->vBC) : null;
            $std->pICMS             = $dados->pICMS ? formataNumero($dados->pICMS) : null;
            $std->vICMS             = $dados->vICMS ? formataNumero($dados->vICMS) : null;

            if($dados->vFCP){
                $std->vBCFCP            = $dados->vBCFCP ? formataNumero($dados->vBCFCP) : null;
                $std->pFCP              = $dados->pFCP ? formataNumero($dados->pFCP) : null;
                $std->vFCP              = $dados->vFCP ? formataNumero($dados->vFCP) : null;
            }

        if($dados->vFCPST){
            $std->vBCFCPST          = $dados->vBCFCPST ? formataNumero($dados->vBCFCPST) : null;
            $std->pFCPST            = $dados->pFCPST ? formataNumero($dados->pFCPST) : null;
            $std->vFCPST            = $dados->vFCPST ? formataNumero($dados->vFCPST) : null;
        }
            $std->modBCST           = $dados->modBCST ;
            $std->pMVAST            = $dados->pMVAST ? formataNumero($dados->pMVAST) : null;
            $std->pRedBCST          = $dados->pRedBCST ? formataNumero($dados->pRedBCST) : null;
            $std->vBCST             = $dados->vBCST ? formataNumero($dados->vBCST) : null;
            $std->pICMSST           = $dados->pICMSST ? formataNumero($dados->pICMSST) : null;
            $std->vICMSST           = $dados->vICMSST ? formataNumero($dados->vICMSST) : null;

        }elseif($cst=="20"){
            $std->modBC             = $dados->modBC;
            $std->pRedBC            = $dados->pRedBC ? formataNumero($dados->pRedBC) : null;
            $std->vBC               = $dados->vBC ? formataNumero($dados->vBC) : null;
            $std->pICMS             = $dados->pICMS ? formataNumero($dados->pICMS) : null;
            $std->vICMS             = $dados->vICMS ? formataNumero($dados->vICMS) : null;

            if($dados->vFCP){
                $std->vBCFCP        = $dados->vBCFCP ? formataNumero($dados->vBCFCP) : null;
                $std->pFCP          = $dados->pFCP ? formataNumero($dados->pFCP) : null;
                $std->vFCP          = $dados->vFCP ? formataNumero($dados->vFCP) : null;
            }

            $std->vICMSDeson        = $dados->vICMSDeson ? formataNumero($dados->vICMSDeson) : null;
            $std->motDesICMS        = $dados->motDesICMS;

        }elseif($cst=="30"){
            $std->modBCST             = $dados->modBCST;
            $std->pMVAST            = $dados->pMVAST ? formataNumero($dados->pMVAST) : null;
            $std->pRedBCST          = $dados->pRedBCST ? formataNumero($dados->pRedBCST) : null;
            $std->vBCST             = $dados->vBCST ? formataNumero($dados->vBCST) : null;
            $std->pICMSST           = $dados->pICMSST ? formataNumero($dados->pICMSST) : null;
            $std->vICMSST           = $dados->vICMSST ? formataNumero($dados->vICMSST) : null;

            if($dados->vFCPST){
                $std->vBCFCPST          = $dados->vBCFCPST ? formataNumero($dados->vBCFCPST) : null;
                $std->pFCPST            = $dados->pFCPST ? formataNumero($dados->pFCPST) : null;
                $std->vFCPST            = $dados->vFCPST ? formataNumero($dados->vFCPST) : null;
            }

            $std->vICMSDeson           = $dados->vICMSDeson ? formataNumero($dados->vICMSDeson) : null;
            $std->motDesICMS           = $dados->motDesICMS;

        }elseif($cst=="40" || $cst=="41" || $cst=="50" ){
            $std->vICMSDeson             = $dados->vICMSDeson ? formataNumero($dados->vICMSDeson) : null;
            $std->motDesICMS             = $dados->motDesICMS;

        }elseif($cst=="51"){
            $std->modBC             = $dados->modBC;
            $std->pRedBC            = $dados->pRedBC ? formataNumero($dados->pRedBC) : null;
            $std->vBC               = $dados->vBC ? formataNumero($dados->vBC) : null;
            $std->pICMS             = $dados->pICMS ? formataNumero($dados->pICMS) : null;
            $std->vICMSOp           = $dados->vICMSOp ? formataNumero($dados->vICMSOp) : null;
            $std->pDif              = $dados->pDif ? formataNumero($dados->pDif) : null;
            $std->vICMSDif          = $dados->vICMSDif ? formataNumero($dados->vICMSDif) : null;
            $std->vICMS             = $dados->vICMS ? formataNumero($dados->vICMS) : null;

            if($dados->vFCP){
                $std->vBCFCP        = $dados->vBCFCP ? formataNumero($dados->vBCFCP) : null;
                $std->pFCP          = $dados->pFCP ? formataNumero($dados->pFCP) : null;
                $std->vFCP          = $dados->vFCP ? formataNumero($dados->vFCP) : null;
            }
        }elseif($cst=="60"){
            $std->vBCSTRet           = $dados->vBCSTRet ? formataNumero($dados->vBCSTRet) : null;
            $std->pST                = $dados->pST ? formataNumero($dados->pST) : null;
            $std->vICMSSubstituto    = $dados->vICMSSubstituto ? formataNumero($dados->vICMSSubstituto) : null;
            $std->vICMSSTRet         = $dados->vICMSSTRet ? formataNumero($dados->vICMSSTRet) : null;

            $std->vBCFCPSTRet        = $dados->vBCFCPSTRet ? formataNumero($dados->vBCFCPSTRet) : null;
            $std->pFCPSTRet          = $dados->pFCPSTRet ? formataNumero($dados->pFCPSTRet) : null;
            $std->vFCPSTRet          = $dados->vFCPSTRet ? formataNumero($dados->vFCPSTRet) : null;

            $std->pRedBCEfet         = $dados->pRedBCEfet ? formataNumero($dados->pRedBCEfet) : null;
            $std->vBCEfet            = $dados->vBCEfet ? formataNumero($dados->vBCEfet) : null;
            $std->pICMSEfet          = $dados->pICMSEfet ? formataNumero($dados->pICMSEfet) : null;
            $std->vICMSEfet          = $dados->vICMSEfet ? formataNumero($dados->vICMSEfet) : null;

        }elseif($cst=="70"){
            $std->modBC             = $dados->modBC;
            $std->pRedBC            = $dados->pRedBC ? formataNumero($dados->pRedBC) : null;
            $std->vBC               = $dados->vBC ? formataNumero($dados->vBC) : null;
            $std->pICMS             = $dados->pICMS ? formataNumero($dados->pICMS) : null;
            $std->vICMS             = $dados->vICMS ? formataNumero($dados->vICMS) : null;

            if($dados->vFCP){
                $std->vBCFCP            = $dados->vBCFCP ? formataNumero($dados->vBCFCP) : null;
                $std->pFCP              = $dados->pFCP ? formataNumero($dados->pFCP) : null;
                $std->vFCP              = $dados->vFCP ? formataNumero($dados->vFCP) : null;
            }


            $std->modBCST           = $dados->modBCST ;
            $std->pMVAST            = $dados->pMVAST ? formataNumero($dados->pMVAST) : null;
            $std->pRedBCST          = $dados->pRedBCST ? formataNumero($dados->pRedBCST) : null;
            $std->vBCST             = $dados->vBCST ? formataNumero($dados->vBCST) : null;
            $std->pICMSST           = $dados->pICMSST ? formataNumero($dados->pICMSST) : null;
            $std->vICMSST           = $dados->vICMSST ? formataNumero($dados->vICMSST) : null;

            if($dados->vFCPST){
                $std->vBCFCPST          = $dados->vBCFCPST ? formataNumero($dados->vBCFCPST) : null;
                $std->pFCPST            = $dados->pFCPST ? formataNumero($dados->pFCPST) : null;
                $std->vFCPST            = $dados->vFCPST ? formataNumero($dados->vFCPST) : null;
            }

            $std->vICMSDeson         = $dados->vICMSDeson ? formataNumero($dados->vICMSDeson) : null;
            $std->motDesICMS         = $dados->motDesICMS;

        }elseif($cst=="90"){
            $std->modBC             = $dados->modBC;
            $std->pRedBC            = $dados->pRedBC ? formataNumero($dados->pRedBC) : null;
            $std->vBC               = $dados->vBC ? formataNumero($dados->vBC) : null;
            $std->pICMS             = $dados->pICMS ? formataNumero($dados->pICMS) : null;
            $std->vICMS             = $dados->vICMS ? formataNumero($dados->vICMS) : null;

            if($dados->vFCP){
                $std->vBCFCP        = $dados->vBCFCP ? formataNumero($dados->vBCFCP) : null;
                $std->pFCP          = $dados->pFCP ? formataNumero($dados->pFCP) : null;
                $std->vFCP          = $dados->vFCP ? formataNumero($dados->vFCP) : null;
            }

            $std->modBCST           = $dados->modBCST ;
            $std->pMVAST            = $dados->pMVAST ? formataNumero($dados->pMVAST) : null;
            $std->pRedBCST          = $dados->pRedBCST ? formataNumero($dados->pRedBCST) : null;
            $std->vBCST             = $dados->vBCST ? formataNumero($dados->vBCST) : null;
            $std->pICMSST           = $dados->pICMSST ? formataNumero($dados->pICMSST) : null;
            $std->vICMSST           = $dados->vICMSST ? formataNumero($dados->vICMSST) : null;

            if($dados->vFCPST){
                $std->vBCFCPST          = $dados->vBCFCPST ? formataNumero($dados->vBCFCPST) : null;
                $std->pFCPST            = $dados->pFCPST ? formataNumero($dados->pFCPST) : null;
                $std->vFCPST            = $dados->vFCPST ? formataNumero($dados->vFCPST) : null;
            }

            $std->vICMSDeson            = $dados->vICMSDeson ? formataNumero($dados->vICMSDeson) : null;
            $std->motDesICMS            = $dados->motDesICMS;
        }elseif($cst=="101"){
            $std->pCredSN               = $dados->pCredSN ? formataNumero($dados->pCredSN) : null;
            $std->vCredICMSSN           = $dados->vCredICMSSN ? formataNumero($dados->vCredICMSSN) : null;
        }elseif($cst=="201"){
            $std->modBCST           = $dados->modBCST;
            $std->pMVAST            = $dados->pMVAST ? formataNumero($dados->pMVAST) : null;
            $std->pRedBCST          = $dados->pRedBCST ? formataNumero($dados->pRedBCST) : null;
            $std->vBCST             = $dados->vBCST ? formataNumero($dados->vBCST) : null;
            $std->pICMSST           = $dados->pICMSST ? formataNumero($dados->pICMSST) : null;
            $std->vICMSST           = $dados->vICMSST ? formataNumero($dados->vICMSST) : null;

            if($dados->vFCPST){
                $std->vBCFCPST          = $dados->vBCFCPST ? formataNumero($dados->vBCFCPST) : null;
                $std->pFCPST            = $dados->pFCPST ? formataNumero($dados->pFCPST) : null;
                $std->vFCPST            = $dados->vFCPST ? formataNumero($dados->vFCPST) : null;
            }

            if($std->pCredSN){
                $std->pCredSN               = $dados->pCredSN ? formataNumero($dados->pCredSN) : null;
                $std->vCredICMSSN           = $dados->vCredICMSSN ? formataNumero($dados->vCredICMSSN) : null;
            }
        }elseif($cst=="202" || $cst=="203"){
            $std->modBCST               = $dados->modBCST;
            $std->pMVAST            = $dados->pMVAST ? formataNumero($dados->pMVAST) : null;
            $std->pRedBCST          = $dados->pRedBCST ? formataNumero($dados->pRedBCST) : null;
            $std->vBCST             = $dados->vBCST ? formataNumero($dados->vBCST) : null;
            $std->pICMSST           = $dados->pICMSST ? formataNumero($dados->pICMSST) : null;
            $std->vICMSST           = $dados->vICMSST ? formataNumero($dados->vICMSST) : null;

            if($dados->vFCPST){
                $std->vBCFCPST          = $dados->vBCFCPST ? formataNumero($dados->vBCFCPST) : null;
                $std->pFCPST            = $dados->pFCPST ? formataNumero($dados->pFCPST) : null;
                $std->vFCPST            = $dados->vFCPST ? formataNumero($dados->vFCPST) : null;
            }

        }elseif($cst=="500"){
            /*$std->vBCSTRet              = $item->vBCSTRet;
            $std->pST               	= $item->pST;
            $std->vICMSSubstituto       = $item->vICMSSubstituto;
            $std->vICMSSTRet            = $item->vICMSSTRet;

            $std->vBCFCPSTRet           = $item->vBCFCPSTRet;
            $std->pFCPSTRet             = $item->pFCPSTRet;
            $std->vFCPSTRet             = $item->vFCPSTRet;

            $std->pRedBCEfet           = $item->pRedBCEfet;
            $std->vBCEfet              = $item->vBCEfet;
            $std->pICMSEfet              = $item->pICMSEfet;
            $std->vICMSEfet              = $item->vICMSEfet;*/
        }elseif($cst=="900"){
            $std->modBC                 = $dados->modBC;
            $std->pRedBC            = $dados->pRedBC ? formataNumero($dados->pRedBC) : null;
            $std->vBC               = $dados->vBC ? formataNumero($dados->vBC) : null;
            $std->pICMS             = $dados->pICMS ? formataNumero($dados->pICMS) : null;
            $std->vICMS             = $dados->vICMS ? formataNumero($dados->vICMS) : null;


            $std->modBCST               = $dados->modBCST;
            $std->pMVAST            = $dados->pMVAST ? formataNumero($dados->pMVAST) : null;
            $std->pRedBCST          = $dados->pRedBCST ? formataNumero($dados->pRedBCST) : null;
            $std->vBCST             = $dados->vBCST ? formataNumero($dados->vBCST) : null;
            $std->pICMSST           = $dados->pICMSST ? formataNumero($dados->pICMSST) : null;
            $std->vICMSST           = $dados->vICMSST ? formataNumero($dados->vICMSST) : null;

            if($dados->vFCPST){
                $std->vBCFCPST          = $dados->vBCFCPST ? formataNumero($dados->vBCFCPST) : null;
                $std->pFCPST            = $dados->pFCPST ? formataNumero($dados->pFCPST) : null;
                $std->vFCPST            = $dados->vFCPST ? formataNumero($dados->vFCPST) : null;
            }

            if($std->pCredSN){
                $std->pCredSN               = $dados->pCredSN ? formataNumero($dados->pCredSN) : null;
                $std->vCredICMSSN           = $dados->vCredICMSSN ? formataNumero($dados->vCredICMSSN) : null;
            }

        }
        if(intval($dados->CST) < 99){
            $nfe->tagICMS($std);
        }else
            $nfe->tagICMSSN($std);
    }

tag pis

chame o método pis da classe MontarXmlService

MontarXmlService::pis($cont,$nfe, $item["pis"]);

método pis

popule os dados da tag pis

public static function pis($cont,$nfe, $dados){
        $std = new \stdClass();
        $std->item              = $cont; //item da NFe
        $std->CST 				= $dados->CST;
        $std->vBC 				= $dados->vBC ? formataNumero($dados->vBC) : null;
        $std->pPIS 				= $dados->pPIS ? formataNumero($dados->pPIS) : null;
        $std->vPIS 				= $dados->vPIS ? formataNumero($dados->vPIS) : null;
        $std->qBCProd 			= $dados->qBCProd ? formataNumero($dados->qBCProd) : null;
        $std->vAliqProd 		= $dados->vAliqProd ? formataNumero($dados->vAliqProd) : null;
        $nfe->tagPIS($std);
    }

tag cofins

chame o método cofins da classe MontarXmlService

MontarXmlService::cofins($cont,$nfe, $item["cofins"]);

método cofins

popule os dados da tag cofins

public static function cofins($cont,$nfe, $dados){
        $std = new \stdClass();
        $std->item              = $cont; //item da NFe
        $std->CST 				= $dados->CST;
        $std->vBC 				= $dados->vBC ? formataNumero($dados->vBC) : null;
        $std->pCOFINS 			= $dados->pCOFINS ? formataNumero($dados->pCOFINS) : null;
        $std->vCOFINS 			= $dados->vCOFINS ? formataNumero($dados->vCOFINS) : null;
        $std->qBCProd 			= $dados->qBCProd ? formataNumero($dados->qBCProd) : null;
        $std->vAliqProd 		= $dados->vAliqProd ? formataNumero($dados->vAliqProd) : null;
        $nfe->tagCOFINS($std);
    }

6 tag total

chame o método total da classe MontarXmlService

MontarXmlService::total($nfe, $notafiscal->total);

método total

Popule os dados tag total

public static function total($nfe, $dados){
        $std = new \stdClass();
        $std->vBC           = ($dados->vBC)		   ? formataNumero($dados->vBC)	      : 0.00;
        $std->vICMS         = ($dados->vICMS)      ? formataNumero($dados->vICMS)     : 0.00;
        $std->vICMSDeson    = ($dados->vICMSDeson) ? formataNumero($dados->vICMSDeson): 0.00;
        $std->vFCP          = ($dados->vFCP)       ? formataNumero($dados->vFCP)      : 0.00;
        $std->vBCST         = ($dados->vBCST)      ? formataNumero($dados->vBCST)     : 0.00;
        $std->vST           = ($dados->vST)        ? formataNumero($dados->vST)       : 0.00;
        $std->vFCPST        = ($dados->vFCPST)     ? formataNumero($dados->vFCPST)    : 0.00;
        $std->vFCPSTRet     = ($dados->vFCPSTRet)  ? formataNumero($dados->vFCPSTRet) : 0.00;
        $std->vProd         = ($dados->vProd )     ? formataNumero($dados->vProd)     : 0.00;
        $std->vFrete        = ($dados->vFrete )    ? formataNumero($dados->vFrete)    : 0.00;
        $std->vSeg          = ($dados->vSeg  )     ? formataNumero($dados->vSeg)      : 0.00;
        $std->vDesc         = ($dados->vDesc )     ? formataNumero($dados->vDesc)     : 0.00;
        $std->vII           = ($dados->vII)        ? formataNumero($dados->vII)       : 0.00;
        $std->vIPI          = ($dados->vIPI)       ? formataNumero($dados->vIPI)      : 0.00;
        $std->vIPIDevol     = ($dados->vIPIDevol)  ? formataNumero($dados->vIPIDevol) : 0.00;
        $std->vPIS          = ($dados->vPIS)       ? formataNumero($dados->vPIS)      : 0.00;
        $std->vCOFINS       = ($dados->vCOFINS)    ? formataNumero($dados->vCOFINS)   : 0.00;
        $std->vOutro        = ($dados->vOutro)     ? formataNumero($dados->vOutro)    : 0.00;
        $std->vNF           = ($dados->vNF)        ? formataNumero($dados->vNF)       : 0.00;
        $std->vTotTrib      = ($dados->vTotTrib)   ? formataNumero($dados->vTotTrib)  : 0.00;


        $nfe->tagICMSTot($std);
    }

7 tag transp

chame o método transp da classe MontarXmlService

MontarXmlService::transp($nfe,$notafiscal->ide->modFrete);

método transp

popule os dados do método transp

public static function transp($nfe,$modFrete){
        $std           = new \stdClass();
        $std->modFrete = $modFrete ;

        $nfe->tagtransp($std);
    }

8 tag transporte

faça a verificação se existe a tag transporte e se existe preencha os dados de acordo com os dados recebido

if($notafiscal->ide->modFrete!="9"){
            if(isset($notafiscal->transporte)){
                $transporte = $notafiscal->transporte;                
               //aqui ficará as tags: transportadora, retencao, veiculo, reboque, volume
            }
        }

tag transporta

chame o método transportadora da classe MontarXmlService

if($transporte->transportadora){
                    MontarXmlService::transportadora($nfe, $transporte->transportadora);
                }

método transportadora

popule os dados da tag transportadora

public static function transportadora($nfe, $dados){
        $std = new \stdClass();
        $std->xNome 		= $dados->xNome ? tiraAcento($dados->xNome) : null;
        $std->IE 			= $dados->IE ? tira_mascara($dados->IE) : null;
        $std->xEnder 		= $dados->xEnder ? tiraAcento($dados->xEnder) : null;
        $std->xMun 			= $dados->xMun ? tiraAcento($dados->xMun) : null;
        $std->UF 		    = $dados->UF;
        $std->CNPJ 		    = $dados->CNPJ ? tira_mascara($dados->CNPJ) : null;
        $nfe->tagtransporta($std);
    }

tag retTransp

chame o método retencao da classe MontarXmlService

if(isset($transporte->retencao) && !is_null($transporte->retencao)) {
                    MontarXmlService::retencao($nfe, $transporte->retencao);
                }

método retencao

popule os dados da tag retencao

public static function retencao($nfe, $dados){
        $std                = new \stdClass();
        $std->vServ 		= $dados->vServ   ? formataNumero($dados->vServ)  : null;
        $std->vBCRet 		= $dados->vBCRet  ? formataNumero($dados->vBCRet)  : null;
        $std->pICMSRet 		= $dados->pICMSRet  ? formataNumero($dados->pICMSRet)  : null;
        $std->vICMSRet 		= $dados->vICMSRet  ? formataNumero($dados->vICMSRet)  : null;
        $std->CFOP 		    = $dados->CFOP;
        $std->cMunFG 		= $dados->cMunFG;
        $nfe->tagretTransp($std);
    }

tag veicTransp

chame o método veiculo da classe MontarXmlService

if(isset($transporte->veiculo) && !is_null($transporte->veiculo)) {
                    MontarXmlService::veiculo($nfe, $transporte->veiculo);
                }

metodo veiculo

popule os dados da tag veiculo

public static function veiculo($nfe, $dados){
        $std = new \stdClass();
        $std->placa  		= $dados->placa ;
        $std->UF 			= $dados->UF;
        $std->RNTC 		    = $dados->RNTC;
        $nfe->tagveicTransp($std);
    }

tag reboque

chame o método reboque da classe MontarXmlService

if(isset($transporte->reboque) && !is_null($transporte->reboque)) {
                    MontarXmlService::reboque($nfe, $transporte->reboque);
                }

metodo reboque

popule a tag reboque, vagao e balsa

public static function reboque($nfe, $dados){
        $std = new \stdClass();
        $std->placa  		= $dados->placa ;
        $std->UF 			= $dados->UF;
        $std->RNTC 		    = $dados->RNTC;
        $nfe->tagreboque($std);

        if($dados->vagao){
            $std = new \stdClass();
            $std->vagao = $dados->vagao;
            $nfe->tagvagao($std);
        }
        if($dados->balsa){
            $std = new \stdClass();
            $std->balsa = $dados->balsa;

            $nfe->tagbalsa($std);
        }
    }

tag vol

chame o método volume da classe MontarXmlService

if(isset($transporte->volume) && !is_null($transporte->volume)) {
                    MontarXmlService::volume($nfe, $transporte->volume);
                }

metodo volume

popule a tag vol e lacres

public static function volume($nfe, $dados){
        $std                = new \stdClass();
        $std->item          = 1; //indicativo do numero do volume
        $std->qVol  		= $dados->qVol ;
        $std->esp 			= $dados->esp  ? tira_mascara($dados->esp)  : null;
        $std->marca		    = $dados->marca;
        $std->nVol 		    = $dados->nVol;
        $std->pesoL		    = $dados->pesoL  ? formataNumero($dados->pesoL)  : null;
        $std->pesoB		    = $dados->pesoB  ? formataNumero($dados->pesoB)  : null;
        $nfe->tagvol($std);

        if($dados->nLacre){
            $std = new \stdClass();
            $std->item = 1; //indicativo do numero do volume
            $std->nLacre = $dados->nLacre;
            $nfe->taglacres($std);
        }
    }

9 tag pag

popule a tag pag

 //Pagamentos
        $std                 = new \stdClass();
        $std->vTroco         = $notafiscal->ide->vTroco ?? null ;
        $nfe->tagpag($std);

10 tag tagdetPag

chame o método pagamento da classe MontarXmlService

foreach($notafiscal->pagamentos as $pagamento){
            MontarXmlService::pagamento($nfe,$pagamento["detalhe"], $pagamento["cartao"]);
        }

método pagamento

popule os dados da tag pagamento

public static function pagamento($nfe, $dadosPagamento, $dadosCartao){
        $std = new \stdClass();
        $std->tPag 			= zeroEsquerda($dadosPagamento->tPag,2);
        $std->vPag 		    = $dadosPagamento->vPag  ? formataNumero($dadosPagamento->vPag)  : null;
        $std->indPag 		= $dadosPagamento->indPag;
        if($dadosCartao){
            $std->CNPJ 			= $dadosCartao->CNPJ  ? tira_mascara($dadosCartao->CNPJ)  : null;
            $std->tBand 		= $dadosCartao->tBand;
            $std->cAut 		    = $dadosCartao->cAut;
            $std->tpIntegra 	= $dadosCartao->tpIntegra;
            $std->vTroco 		= $dadosCartao->vTroco  ? formataNumero($dadosCartao->vTroco)  : null;
        }
        $nfe->tagdetPag($std);
    }

11 tag fat e tag dup

chame o método fatura e duplicata da classe MontarXmlService de acordo com os dados da nota

 if(isset($notafiscal->cobranca)){
            MontarXmlService::fatura($nfe, $notafiscal->cobranca->fatura);
            foreach($notafiscal->cobranca->duplicatas as $dup){
                MontarXmlService::duplicata($nfe, $dup);
            }
         }

metodo fatura

popule os dados da tag fat

 public static function fatura($nfe, $dados){
        $std = new \stdClass();
        $std->nFat 		    = $dados->nFat;
        $std->vOrig 		= $dados->vOrig ? formataNumero($dados->vOrig)  : null;
        $std->vDesc 		= $dados->vDesc ? formataNumero($dados->vDesc)  : null;
        $std->vLiq 			= $dados->vLiq ? formataNumero($dados->vLiq)  : null;
        $nfe->tagfat($std);
    }

método duplicata

popule os dados da tag duplicata

 public static function duplicata($nfe, $dados){
        $std = new \stdClass();
        $std->nDup 		= $dados->nDup;
        $std->dVenc 	= $dados->dVenc;
        $std->vDup 		= $dados->vDup ? formataNumero($dados->vDup)  : null;
        $nfe->tagdup($std);
    }

Passo 3 Método gerarXml

1 classe ConfiguracaoService

Crie uma classe chamada ConfiguracaoService

<?php
namespace App\Service;


class ConfiguracaoService
{

}

metodo getConfiguracaoNfe

Crie um método chamadado getConfiguracaoNfe, o qual deverá receber como parâmentro, o cnpj, nome, uf e tpAmb e deverá:

- buscar o certificado digital pelo cnpj
- criar um objeto tools da classe NFePHP\NFe\Tools
- retorna a pasta do ambiente, ou seja ,producao ou homologacao

public static function getConfiguracaoNfe($cnpj, $xNome, $uf, $tpAmb){
        $retorno = new stdClass;
        $arr = [
            "atualizacao" => date('Y-m-d h:i:s'),
            "tpAmb"       => intVal($tpAmb),
            "razaosocial" => $xNome,
            "cnpj"        => $cnpj,
            "siglaUF"     => $uf,
            "schemes"     => "PL_009_V4",
            "versao"      => '4.00',
            "tokenIBPT"   => "",
            "CSC"         => "",
            "CSCid"       => "",
            "proxyConf"   => [
                "proxyIp"   => "",
                "proxyPort" => "",
                "proxyUser" => "",
                "proxyPass" => ""
            ]
        ];
        $configJson                 = json_encode($arr);
        try {
            //Verifica se o certificado digital existe;
            $certificado = CertificadoService::buscarPeloCnpj($cnpj );
            if(!$certificado){
                $retorno->titulo    = "Erro ao ler Cerificado Digital";
                throw new \Exception('Nenhum certificado digital foi encontrado para este CNPJ');
            }

            $retorno->tem_erro          = false;
            $retorno->cnpj              = $cnpj;
            $retorno->tpAmb             = $tpAmb;
            $retorno->tools             = new Tools($configJson, Certificate::readPfx($certificado->arquivo_binario, $certificado->senha));
            $retorno->pastaAmbiente     = ($tpAmb == "1") ? "producao" : "homologacao";
            $retorno->pastaEmpresa      = $cnpj;
            $retorno->certificado       = $certificado;
            $retorno->tools->model(55);

        } catch (\Throwable $th) {
            $retorno->tem_erro = true;
            $retorno->erro = $th->getMessage();
        }

        return $retorno;
    }

2 classe NfeLogService

crie uma classe chamada NfeLogService, que deverá salvar o log de todas as operações da nfe

<?php
namespace App\Service;

class NfeLogService
{
}

método salvar

crie um método salvar na classe NfeLogService, a qual deverá salvar os dados da tabel NfeLogService

public static function salvar($nfe_id, $status_id, $chave, $titulo, $msg, $idLote=null){
        $log = new stdClass;
        $log->nfe_id = $nfe_id;
        $log->status_id = $status_id;
        $log->data = hoje();
        $log->chave = $chave;
        $log->titulo = $titulo;
        $log->msg = $msg;
        $log->idLote = $idLote;
        NfeLog::Create(objToArray($log));
    }

3 método gerarXml

Na classe NfeService crie um método chamado gerarXml, o qual deverá receber como parâmetro um objeto nfe, a configuracao e o nfe_id e deverá:

- chamar o método montaNfe() da do objeto nfe e salvar na variável resultado , caso apresente algum erro deverá retornar o erro
- salvar o xml em uma pasta do sistema
- salvar a chave gerado na tabela nfe
- salvar o log da operação na tabela nfeLog
- retornar o objeto gerado

 public static function gerarXml($nfe, $configuracao, $nfe_id){

        $retorno = new stdClass;
        try {
            $resultado = $nfe->montaNFe();
            if($resultado){
                $xml    = $nfe->getXML();
                $chave  = $nfe->getChave();

                $path ="storage/". $configuracao->pastaEmpresa."/xml/nfe/".$configuracao->pastaAmbiente."/temporarias/";
                $nome_arquivo = $chave."-nfe.xml";

                if (!file_exists($path)){
                    mkdir($path, 07777, true);
                }

                file_put_contents($path.$nome_arquivo, $xml);
                chmod($path, 07777);
                Nfe::where("id",$nfe_id)->update(["chave"=> $chave]);
                NfeLogService::salvar($nfe_id, config("constantes.status.INICIADO"), $chave, "XML Criado", "Xml Criado com Sucesso");
                $retorno->tem_erro  = false;
                $retorno->titulo    = "arquivo XML gerado com Sucesso";
                $retorno->erro      = "";
                $retorno->chave     = $chave;
                $retorno->xml       = $xml;
            }else{
                $retorno->tem_erro  = true;
                $retorno->titulo    = "Não foi possível gerar o XML";
                $retorno->erro      = $nfe->getErrors();
                NfeLogService::salvar($nfe_id, config("constantes.status.ERRO_AO_GERAR_XML"), null, "Erro ao gerar XML", $retorno->erro[0]);
            }
        } catch (\Throwable $th) {
            $retorno->tem_erro = true;
            $retorno->titulo = "Não foi possível gerar o XML";
            if($nfe->getErrors() !=null){
                $retorno->erro = $nfe->getErrors();
                NfeLogService::salvar($nfe_id, config("constantes.status.ERRO_AO_GERAR_XML"), null, "Erro ao gerar XML", $retorno->erro[0]);
            }else{
                $retorno->erro = $th->getMessage();
                NfeLogService::salvar($nfe_id, config("constantes.status.ERRO_AO_GERAR_XML"), null, "Erro ao gerar XML", $retorno->erro);
            }
        }
        return $retorno;
    }

❮ ❯

1 classe NfeService

2 método gerarNfe

3 Instalando a biblioteca NfePHP

4 classe MontarXmlService