Tools::checkModelFromXml() - Code Metrics - Inspection of "Merge pull request #789 from robmachado/master" - nfephp-org/sped-nfe - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( eb8237...9d55e5 )

by Roberto

created 2020-11-19 13:02 UTC

Tools::checkModelFromXml() A

↳ Parent: Tools

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	7
ccs	0
cts	5
cp	0
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1
crap	2

<?php

namespace NFePHP\NFe\Common;

/**
 * Class base responsible for communication with SEFAZ
 *
 * @category  NFePHP
 * @package   NFePHP\NFe\Common\Tools
 * @copyright NFePHP Copyright (c) 2008-2019
 * @license   http://www.gnu.org/licenses/lgpl.txt LGPLv3+
 * @license   https://opensource.org/licenses/MIT MIT
 * @license   http://www.gnu.org/licenses/gpl.txt GPLv3+
 * @author    Roberto L. Machado <linux.rlm at gmail dot com>
 * @link      http://github.com/nfephp-org/sped-nfe for the canonical source repository
 */

use DOMDocument;
use InvalidArgumentException;
use RuntimeException;
use NFePHP\Common\Certificate;
use NFePHP\Common\Signer;
use NFePHP\Common\Soap\SoapCurl;
use NFePHP\Common\Soap\SoapInterface;
use NFePHP\Common\Strings;
use NFePHP\Common\TimeZoneByUF;
use NFePHP\Common\UFList;
use NFePHP\Common\Validator;
use NFePHP\NFe\Factories\Contingency;
use NFePHP\NFe\Factories\ContingencyNFe;
use NFePHP\NFe\Factories\Header;
use NFePHP\NFe\Factories\QRCode;

class Tools
{
    /**
     * config class
     * @var \stdClass
     */
    public $config;
    /**
     * Path to storage folder
     * @var string
     */
    public $pathwsfiles = '';
    /**
     * Path to schemes folder
     * @var string
     */
    public $pathschemes = '';
    /**
     * ambiente
     * @var string
     */
    public $ambiente = 'homologacao';
    /**
     * Environment
     * @var int
     */
    public $tpAmb = 2;
    /**
     * contingency class
     * @var Contingency
     */
    public $contingency;
    /**
     * soap class
     * @var SoapInterface
     */
    public $soap;
    /**
     * Application version
     * @var string
     */
    public $verAplic = '';
    /**
     * last soap request
     * @var string
     */
    public $lastRequest = '';
    /**
     * last soap response
     * @var string
     */
    public $lastResponse = '';
    /**
     * certificate class
     * @var Certificate
     */
    protected $certificate;
    /**
     * Sign algorithm from OPENSSL
     * @var int
     */
    protected $algorithm = OPENSSL_ALGO_SHA1;
    /**
     * Canonical conversion options
     * @var array
     */
    protected $canonical = [true,false,null,null];
    /**
     * Model of NFe 55 or 65
     * @var int
     */
    protected $modelo = 55;
    /**
     * Version of layout
     * @var string
     */
    protected $versao = '4.00';
    /**
     * urlPortal
     * Instância do WebService
     *
     * @var string
     */
    protected $urlPortal = 'http://www.portalfiscal.inf.br/nfe';
    /**
     * urlcUF
     * @var int
     */
    protected $urlcUF;
    /**
     * urlVersion
     * @var string
     */
    protected $urlVersion = '';
    /**
     * urlService
     * @var string
     */
    protected $urlService = '';
    /**
     * @var string
     */
    protected $urlMethod = '';
    /**
     * @var string
     */
    protected $urlOperation = '';
    /**
     * @var string
     */
    protected $urlNamespace = '';
    /**
     * @var string
     */
    protected $urlAction = '';
    /**
     * @var \SoapHeader | null
     */
    protected $objHeader = null;
    /**
     * @var string
     */
    protected $urlHeader = '';
    /**
     * @var array
     */
    protected $soapnamespaces = [
        'xmlns:xsi' => "http://www.w3.org/2001/XMLSchema-instance",
        'xmlns:xsd' => "http://www.w3.org/2001/XMLSchema",
        'xmlns:soap' => "http://www.w3.org/2003/05/soap-envelope"
    ];
    /**
     * @var array
     */
    protected $availableVersions = ['4.00' => 'PL_009_V4'];
    /**
     * @var string
     */
    protected $typePerson = 'J';
    /**
     * @var string
     */
    protected $timezone;

    /**
     * Loads configurations and Digital Certificate, map all paths, set timezone and instanciate Contingency::class
     * @param string $configJson content of config in json format
     * @param Certificate $certificate
     * @param Contingency|null $contingency
     */
    public function __construct($configJson, Certificate $certificate, Contingency $contingency = null)
    {
        $this->pathwsfiles = realpath(__DIR__ . '/../../storage') . '/';
        //valid config json string
        $this->config = Config::validate($configJson);
        $this->version($this->config->versao);
        $this->setEnvironmentTimeZone($this->config->siglaUF);
        $this->certificate = $certificate;
        $this->typePerson = $this->getTypeOfPersonFromCertificate();
        $this->setEnvironment($this->config->tpAmb);
        if (empty($contingency)) {
            $this->contingency = new Contingency();
        }
    }

    /**
     * Sets environment time zone
     * @param string $acronym (ou seja a sigla do estado)
     * @return void
     */
    public function setEnvironmentTimeZone($acronym)
    {
        $this->timezone = TimeZoneByUF::get($acronym);
    }

    /**
     * Return J or F from existing type in ASN.1 certificate
     * J - pessoa juridica (CNPJ)
     * F - pessoa física (CPF)
     * @return string
     */
    public function getTypeOfPersonFromCertificate()
    {
        $cnpj = $this->certificate->getCnpj();
        $type = 'J';
        if (empty($cnpj)) {
            //não é CNPJ, então verificar se é CPF
            $cpf = $this->certificate->getCpf();
            if (!empty($cpf)) {
                $type = 'F';
            } else {
                //não foi localizado nem CNPJ e nem CPF esse certificado não é usável
                //throw new RuntimeException('Faltam elementos CNPJ/CPF no certificado digital.');
                $type = '';
            }
        }
        return $type;
    }

    /**
     * Set application version
     * @param string $ver
     */
    public function setVerAplic($ver)
    {
        $this->verAplic = $ver;
    }

    /**
     * Load Soap Class
     * Soap Class may be \NFePHP\Common\Soap\SoapNative
     * or \NFePHP\Common\Soap\SoapCurl
     * @param SoapInterface $soap
     * @return void
     */
    public function loadSoapClass(SoapInterface $soap)
    {
        $this->soap = $soap;
        $this->soap->loadCertificate($this->certificate);
    }

    /**
     * Set OPENSSL Algorithm using OPENSSL constants
     * @param int $algorithm
     * @return void
     */
    public function setSignAlgorithm($algorithm = OPENSSL_ALGO_SHA1)
    {
        $this->algorithm = $algorithm;
    }

    /**
     * Set or get model of document NFe = 55 or NFCe = 65
     * @param int $model
     * @return int modelo class parameter
     */
    public function model($model = null)
    {
        if ($model == 55 || $model == 65) {
            $this->modelo = $model;
        }
        return $this->modelo;
    }

    /**
     * Set or get parameter layout version
     * @param string $version
     * @return string
     * @throws InvalidArgumentException
     */
    public function version($version = null)
    {
        if (null === $version) {
            return $this->versao;
        }
        //Verify version template is defined
        if (false === isset($this->availableVersions[$version])) {
            throw new \InvalidArgumentException('Essa versão de layout não está disponível');
        }

        $this->versao = $version;
        $this->config->schemes = $this->availableVersions[$version];
        $this->pathschemes = realpath(
            __DIR__ . '/../../schemes/'. $this->config->schemes
        ).'/';

        return $this->versao;
    }

    /**
     * Recover cUF number from state acronym
     * @param string $acronym Sigla do estado
     * @return int number cUF
     */
    public function getcUF($acronym)
    {
        return UFlist::getCodeByUF($acronym);
    }

    /**
     * Recover state acronym from cUF number
     * @param int $cUF
     * @return string acronym sigla
     */
    public function getAcronym($cUF)
    {
        return UFlist::getUFByCode($cUF);
    }

    /**
     * Validate cUF from the key content and returns the state acronym
     * @param string $chave
     * @return string
     * @throws InvalidArgumentException
     */
    public function validKeyByUF($chave)
    {
        $uf = $this->config->siglaUF;
        if ($uf != UFList::getUFByCode(substr($chave, 0, 2))) {
            throw new \InvalidArgumentException(
                "A chave da NFe indicada [$chave] não pertence a [$uf]."
            );
        }
        return $uf;
    }

    /**
     * Sign NFe or NFCe
     * @param  string  $xml NFe xml content
     * @return string signed NFe xml
     * @throws RuntimeException
     */
    public function signNFe($xml)
    {
        if (empty($xml)) {
            throw new InvalidArgumentException('O argumento xml passado para ser assinado está vazio.');
        }
        //remove all invalid strings
        $xml = Strings::clearXmlString($xml);
        if ($this->contingency->type !== '') {
            $xml = ContingencyNFe::adjust($xml, $this->contingency);
        }
        $signed = Signer::sign(
            $this->certificate,
            $xml,
            'infNFe',
            'Id',
            $this->algorithm,
            $this->canonical
        );
        $dom = new DOMDocument('1.0', 'UTF-8');
        $dom->preserveWhiteSpace = false;
        $dom->formatOutput = false;
        $dom->loadXML($signed);
        $modelo = $dom->getElementsByTagName('mod')->item(0)->nodeValue;
        $isInfNFeSupl = !empty($dom->getElementsByTagName('infNFeSupl')->item(0));
        if ($modelo == 65 && !$isInfNFeSupl) {
            $signed = $this->addQRCode($dom);
        }
        //exception will be throw if NFe is not valid
        $this->isValid($this->versao, $signed, 'nfe');
        return $signed;
    }

    /**
     * Corrects NFe fields when in contingency mode
     * @param string $xml NFe xml content
     * @return string
     */
    protected function correctNFeForContingencyMode($xml)
    {
        return $this->contingency->type == '' ? $xml : $this->signNFe($xml);
    }

    /**
     * Performs xml validation with its respective XSD structure definition document
     * NOTE: if don't exists the XSD file will return true
     * @param string $version layout version
     * @param string $body
     * @param string $method
     * @return bool
     */
    protected function isValid($version, $body, $method)
    {
        $schema = $this->pathschemes.$method."_v$version.xsd";
        if (!is_file($schema)) {
            return true;
        }
        return Validator::isValid($body, $schema);
    }

    /**
     * Verifies the existence of the service
     * @param string $service
     * @throws RuntimeException
     */
    protected function checkContingencyForWebServices($service)
    {
        $permit = [
            55 => ['SVCAN', 'SVCRS', 'EPEC', 'FSDA'],
            65 => ['FSDA', 'EPEC', 'OFFLINE']
        ];

        $type = $this->contingency->type;
        $mod = $this->modelo;
        if (!empty($type)) {
            if (array_search($type, $permit[$mod]) === false) {
                throw new RuntimeException(
                    "Esse modo de contingência [$type] não é aceito "
                    . "para o modelo [$mod]"
                );
            }
        }

        //se a contingencia é OFFLINE ou FSDA nenhum servidor está disponivel
        //se a contigencia EPEC está ativa apenas o envio de Lote está ativo,
        //então gerar um RunTimeException
        if ($type == 'FSDA'
            || $type == 'OFFLINE'
            || ($type == 'EPEC' && $service != 'RecepcaoEvento')
        ) {
            throw new RuntimeException(
                "Quando operando em modo de contingência ["
                . $this->contingency->type
                . "], este serviço [$service] não está disponível."
            );
        }
    }

    /**
     * Alter environment from "homologacao" to "producao" and vice-versa
     * @param int $tpAmb
     * @return void
     */
    public function setEnvironment($tpAmb = 2)
    {
        if (!empty($tpAmb) && ($tpAmb == 1 || $tpAmb == 2)) {
            $this->tpAmb = $tpAmb;
            $this->ambiente = ($tpAmb == 1) ? 'producao' : 'homologacao';
        }
    }

    /**
     * Set option for canonical transformation see C14n
     * @param array $opt
     * @return array
     */
    public function canonicalOptions(array $opt = [true, false, null, null])
    {
        if (!empty($opt) && is_array($opt)) {
            $this->canonical = $opt;
        }
        return $this->canonical;
    }

    /**
     * Assembles all the necessary parameters for soap communication
     * @param string $service
     * @param string $uf
     * @param int $tpAmb 1-Production or 2-Homologation
     * @param bool $ignoreContingency
     * @throws RuntimeException
     * @return void
     */
    protected function servico($service, $uf, $tpAmb, $ignoreContingency = false)
    {
        $webs = new Webservices($this->getXmlUrlPath());
        $sigla = $uf;
        if (!$ignoreContingency) {
            $contType = $this->contingency->type;
            if (!empty($contType) && ($contType == 'SVCRS' || $contType == 'SVCAN')) {
                $sigla = $contType;
            }
        }
        $stdServ = $webs->get($sigla, $tpAmb, $this->modelo);
        if (empty($stdServ->$service->url)) {
            throw new \RuntimeException("Servico [$service] indisponivel UF [$uf] ou modelo [$this->modelo]");
        }
        $this->urlcUF = $this->getcUF($uf); //recuperação do cUF
        if ($this->urlcUF > 91) {
            $this->urlcUF = $this->getcUF($this->config->siglaUF); //foi solicitado dado de SVCRS ou SVCAN
        }
        $this->urlVersion = $stdServ->$service->version; //recuperação da versão
        $this->urlService = $stdServ->$service->url; //recuperação da url do serviço
        $this->urlMethod = $stdServ->$service->method; //recuperação do método
        $this->urlOperation = $stdServ->$service->operation; //recuperação da operação
        $this->urlNamespace = sprintf("%s/wsdl/%s", $this->urlPortal, $this->urlOperation); //monta namespace
        //montagem do cabeçalho da comunicação SOAP
        $this->urlHeader = Header::get($this->urlNamespace, $this->urlcUF, $this->urlVersion);
        $this->urlAction = "\"$this->urlNamespace/$this->urlMethod\"";
    }

    /**
     * Send request message to webservice
     * @param string $request
     * @param array $parameters
     * @return string
     * @throws RuntimeException
     */
    protected function sendRequest($request, array $parameters = [])
    {
        if (in_array($this->contingency->tpEmis, [Contingency::TPEMIS_FSDA, Contingency::TPEMIS_OFFLINE])) {
            throw new \RuntimeException('Em contingencia FSDA ou OFFLINE não é possivel acessar os webservices.');
        }
        $this->checkSoap();
        $response = (string) $this->soap->send(
            $this->urlService,
            $this->urlMethod,
            $this->urlAction,
            SOAP_1_2,
            $parameters,
            $this->soapnamespaces,
            $request,
            $this->objHeader
        );
        return Strings::normalize($response);
    }

    /**
     * Recover path to xml data base with list of soap services
     * @return string
     */
    protected function getXmlUrlPath()
    {
        $file = "wsnfe_" . $this->versao . "_mod55.xml";
        if ($this->modelo == 65) {
            $file = str_replace('55', '65', $file);
        }
        
        $path = $this->pathwsfiles . $file;
        if (! file_exists($path)) {
            return '';
        }
        return file_get_contents($path);
    }

    /**
     * Add QRCode Tag to signed XML from a NFCe
     * @param DOMDocument $dom
     * @return string
     */
    protected function addQRCode(DOMDocument $dom)
    {
        if (empty($this->config->CSC) || empty($this->config->CSCid)) {
            throw new \RuntimeException("O QRCode não pode ser criado pois faltam dados CSC e/ou CSCId");
        }
        $memmod = $this->modelo;
        $this->modelo = 65;
        $cUF = $dom->getElementsByTagName('cUF')->item(0)->nodeValue;
        $tpAmb = $dom->getElementsByTagName('tpAmb')->item(0)->nodeValue;
        $uf = UFList::getUFByCode($cUF);
        $this->servico('NfeConsultaQR', $uf, $tpAmb);
        $signed = QRCode::putQRTag(
            $dom,
            $this->config->CSC,
            $this->config->CSCid,
            $this->urlVersion,
            $this->urlService,
            $this->getURIConsultaNFCe($uf, $tpAmb)
        );
        $this->modelo = $memmod;
        return Strings::clearXmlString($signed);
    }

    /**
     * Get URI for search NFCe by key (chave)
     * @param string $uf Abbreviation of the UF
     * @param string $tpAmb SEFAZ environment, 1-Production or 2-Homologation
     * @return string
     */
    protected function getURIConsultaNFCe($uf, $tpAmb)
    {
        $arr = json_decode(file_get_contents($this->pathwsfiles . 'uri_consulta_nfce.json'), true);
        $std = json_decode(json_encode($arr[$tpAmb]));
        return $std->$uf;
    }

    /**
     * Verify if SOAP class is loaded, if not, force load SoapCurl
     */
    protected function checkSoap()
    {
        if (empty($this->soap)) {
            $this->soap = new SoapCurl($this->certificate);

        }
    }
    
    /**
     * Verify if xml model is equal as modelo property
     * @param string $xml
     * @return bool
     */
    protected function checkModelFromXml($xml)
    {
        $dom = new \DOMDocument();
        $dom->loadXML($xml);
        $model = $dom->getElementsByTagName('mod')->item(0)->nodeValue;
        return $model == $this->modelo;
    }
}


1		<?php
2
3		namespace NFePHP\NFe\Common;
4
5		/**
6		* Class base responsible for communication with SEFAZ
7		*
8		* @category NFePHP
9		* @package NFePHP\NFe\Common\Tools
10		* @copyright NFePHP Copyright (c) 2008-2019
11		* @license http://www.gnu.org/licenses/lgpl.txt LGPLv3+
12		* @license https://opensource.org/licenses/MIT MIT
13		* @license http://www.gnu.org/licenses/gpl.txt GPLv3+
14		* @author Roberto L. Machado <linux.rlm at gmail dot com>
15		* @link http://github.com/nfephp-org/sped-nfe for the canonical source repository
16		*/
17
18		use DOMDocument;
19		use InvalidArgumentException;
20		use RuntimeException;
21		use NFePHP\Common\Certificate;
22		use NFePHP\Common\Signer;
23		use NFePHP\Common\Soap\SoapCurl;
24		use NFePHP\Common\Soap\SoapInterface;
25		use NFePHP\Common\Strings;
26		use NFePHP\Common\TimeZoneByUF;
27		use NFePHP\Common\UFList;
28		use NFePHP\Common\Validator;
29		use NFePHP\NFe\Factories\Contingency;
30		use NFePHP\NFe\Factories\ContingencyNFe;
31		use NFePHP\NFe\Factories\Header;
32		use NFePHP\NFe\Factories\QRCode;
33
34		class Tools
35		{
36		/**
37		* config class
38		* @var \stdClass
39		*/
40		public $config;
41		/**
42		* Path to storage folder
43		* @var string
44		*/
45		public $pathwsfiles = '';
46		/**
47		* Path to schemes folder
48		* @var string
49		*/
50		public $pathschemes = '';
51		/**
52		* ambiente
53		* @var string
54		*/
55		public $ambiente = 'homologacao';
56		/**
57		* Environment
58		* @var int
59		*/
60		public $tpAmb = 2;
61		/**
62		* contingency class
63		* @var Contingency
64		*/
65		public $contingency;
66		/**
67		* soap class
68		* @var SoapInterface
69		*/
70		public $soap;
71		/**
72		* Application version
73		* @var string
74		*/
75		public $verAplic = '';
76		/**
77		* last soap request
78		* @var string
79		*/
80		public $lastRequest = '';
81		/**
82		* last soap response
83		* @var string
84		*/
85		public $lastResponse = '';
86		/**
87		* certificate class
88		* @var Certificate
89		*/
90		protected $certificate;
91		/**
92		* Sign algorithm from OPENSSL
93		* @var int
94		*/
95		protected $algorithm = OPENSSL_ALGO_SHA1;
96		/**
97		* Canonical conversion options
98		* @var array
99		*/
100		protected $canonical = [true,false,null,null];
101		/**
102		* Model of NFe 55 or 65
103		* @var int
104		*/
105		protected $modelo = 55;
106		/**
107		* Version of layout
108		* @var string
109		*/
110		protected $versao = '4.00';
111		/**
112		* urlPortal
113		* Instância do WebService
114		*
115		* @var string
116		*/
117		protected $urlPortal = 'http://www.portalfiscal.inf.br/nfe';
118		/**
119		* urlcUF
120		* @var int
121		*/
122		protected $urlcUF;
123		/**
124		* urlVersion
125		* @var string
126		*/
127		protected $urlVersion = '';
128		/**
129		* urlService
130		* @var string
131		*/
132		protected $urlService = '';
133		/**
134		* @var string
135		*/
136		protected $urlMethod = '';
137		/**
138		* @var string
139		*/
140		protected $urlOperation = '';
141		/**
142		* @var string
143		*/
144		protected $urlNamespace = '';
145		/**
146		* @var string
147		*/
148		protected $urlAction = '';
149		/**
150		* @var \SoapHeader \| null
151		*/
152		protected $objHeader = null;
153		/**
154		* @var string
155		*/
156		protected $urlHeader = '';
157		/**
158		* @var array
159		*/
160		protected $soapnamespaces = [
161		'xmlns:xsi' => "http://www.w3.org/2001/XMLSchema-instance",
162		'xmlns:xsd' => "http://www.w3.org/2001/XMLSchema",
163		'xmlns:soap' => "http://www.w3.org/2003/05/soap-envelope"
164		];
165		/**
166		* @var array
167		*/
168		protected $availableVersions = ['4.00' => 'PL_009_V4'];
169		/**
170		* @var string
171		*/
172		protected $typePerson = 'J';
173		/**
174		* @var string
175		*/
176		protected $timezone;
177
178		/**
179		* Loads configurations and Digital Certificate, map all paths, set timezone and instanciate Contingency::class
180		* @param string $configJson content of config in json format
181		* @param Certificate $certificate
182		* @param Contingency\|null $contingency
183		*/
184	58	public function __construct($configJson, Certificate $certificate, Contingency $contingency = null)
185		{
186	58	$this->pathwsfiles = realpath(__DIR__ . '/../../storage') . '/';
187		//valid config json string
188	58	$this->config = Config::validate($configJson);
189	58	$this->version($this->config->versao);
190	58	$this->setEnvironmentTimeZone($this->config->siglaUF);
191	58	$this->certificate = $certificate;
192	58	$this->typePerson = $this->getTypeOfPersonFromCertificate();
193	58	$this->setEnvironment($this->config->tpAmb);
194	58	if (empty($contingency)) {
195	58	$this->contingency = new Contingency();
196		}
197	58	}
198
199		/**
200		* Sets environment time zone
201		* @param string $acronym (ou seja a sigla do estado)
202		* @return void
203		*/
204	58	public function setEnvironmentTimeZone($acronym)
205		{
206	58	$this->timezone = TimeZoneByUF::get($acronym);
207	58	}
208
209		/**
210		* Return J or F from existing type in ASN.1 certificate
211		* J - pessoa juridica (CNPJ)
212		* F - pessoa física (CPF)
213		* @return string
214		*/
215	58	public function getTypeOfPersonFromCertificate()
216		{
217	58	$cnpj = $this->certificate->getCnpj();
218	58	$type = 'J';
219	58	if (empty($cnpj)) {
220		//não é CNPJ, então verificar se é CPF
221	58	$cpf = $this->certificate->getCpf();
222	58	if (!empty($cpf)) {
223		$type = 'F';
224		} else {
225		//não foi localizado nem CNPJ e nem CPF esse certificado não é usável
226		//throw new RuntimeException('Faltam elementos CNPJ/CPF no certificado digital.');
227	58	$type = '';
228		}
229		}
230	58	return $type;
231		}
232
233		/**
234		* Set application version
235		* @param string $ver
236		*/
237		public function setVerAplic($ver)
238		{
239		$this->verAplic = $ver;
240		}
241
242		/**
243		* Load Soap Class
244		* Soap Class may be \NFePHP\Common\Soap\SoapNative
245		* or \NFePHP\Common\Soap\SoapCurl
246		* @param SoapInterface $soap
247		* @return void
248		*/
249		public function loadSoapClass(SoapInterface $soap)
250		{
251		$this->soap = $soap;
252		$this->soap->loadCertificate($this->certificate);
253		}
254
255		/**
256		* Set OPENSSL Algorithm using OPENSSL constants
257		* @param int $algorithm
258		* @return void
259		*/
260		public function setSignAlgorithm($algorithm = OPENSSL_ALGO_SHA1)
261		{
262		$this->algorithm = $algorithm;
263		}
264
265		/**
266		* Set or get model of document NFe = 55 or NFCe = 65
267		* @param int $model
268		* @return int modelo class parameter
269		*/
270		public function model($model = null)
271		{
272		if ($model == 55 \|\| $model == 65) {
273		$this->modelo = $model;
274		}
275		return $this->modelo;
276		}
277
278		/**
279		* Set or get parameter layout version
280		* @param string $version
281		* @return string
282		* @throws InvalidArgumentException
283		*/
284	58	public function version($version = null)
285		{
286	58	if (null === $version) {
287		return $this->versao;
288		}
289		//Verify version template is defined
290	58	if (false === isset($this->availableVersions[$version])) {
291		throw new \InvalidArgumentException('Essa versão de layout não está disponível');
292		}
293
294	58	$this->versao = $version;
295	58	$this->config->schemes = $this->availableVersions[$version];
296	58	$this->pathschemes = realpath(
297	58	__DIR__ . '/../../schemes/'. $this->config->schemes
298	58	).'/';
299
300	58	return $this->versao;
301		}
302
303		/**
304		* Recover cUF number from state acronym
305		* @param string $acronym Sigla do estado
306		* @return int number cUF
307		*/
308		public function getcUF($acronym)
309		{
310		return UFlist::getCodeByUF($acronym);
311		}
312
313		/**
314		* Recover state acronym from cUF number
315		* @param int $cUF
316		* @return string acronym sigla
317		*/
318		public function getAcronym($cUF)
319		{
320		return UFlist::getUFByCode($cUF);
321		}
322
323		/**
324		* Validate cUF from the key content and returns the state acronym
325		* @param string $chave
326		* @return string
327		* @throws InvalidArgumentException
328		*/
329		public function validKeyByUF($chave)
330		{
331		$uf = $this->config->siglaUF;
332		if ($uf != UFList::getUFByCode(substr($chave, 0, 2))) {
333		throw new \InvalidArgumentException(
334		"A chave da NFe indicada [$chave] não pertence a [$uf]."
335		);
336		}
337		return $uf;
338		}
339
340		/**
341		* Sign NFe or NFCe
342		* @param string $xml NFe xml content
343		* @return string signed NFe xml
344		* @throws RuntimeException
345		*/
346		public function signNFe($xml)
347		{
348		if (empty($xml)) {
349		throw new InvalidArgumentException('O argumento xml passado para ser assinado está vazio.');
350		}
351		//remove all invalid strings
352		$xml = Strings::clearXmlString($xml);
353		if ($this->contingency->type !== '') {
354		$xml = ContingencyNFe::adjust($xml, $this->contingency);
355		}
356		$signed = Signer::sign(
357		$this->certificate,
358		$xml,
359		'infNFe',
360		'Id',
361		$this->algorithm,
362		$this->canonical
363		);
364		$dom = new DOMDocument('1.0', 'UTF-8');
365		$dom->preserveWhiteSpace = false;
366		$dom->formatOutput = false;
367		$dom->loadXML($signed);
368		$modelo = $dom->getElementsByTagName('mod')->item(0)->nodeValue;
369		$isInfNFeSupl = !empty($dom->getElementsByTagName('infNFeSupl')->item(0));
370		if ($modelo == 65 && !$isInfNFeSupl) {
371		$signed = $this->addQRCode($dom);
372		}
373		//exception will be throw if NFe is not valid
374		$this->isValid($this->versao, $signed, 'nfe');
375		return $signed;
376		}
377
378		/**
379		* Corrects NFe fields when in contingency mode
380		* @param string $xml NFe xml content
381		* @return string
382		*/
383		protected function correctNFeForContingencyMode($xml)
384		{
385		return $this->contingency->type == '' ? $xml : $this->signNFe($xml);
386		}
387
388		/**
389		* Performs xml validation with its respective XSD structure definition document
390		* NOTE: if don't exists the XSD file will return true
391		* @param string $version layout version
392		* @param string $body
393		* @param string $method
394		* @return bool
395		*/
396		protected function isValid($version, $body, $method)
397		{
398		$schema = $this->pathschemes.$method."_v$version.xsd";
399		if (!is_file($schema)) {
400		return true;
401		}
402		return Validator::isValid($body, $schema);
403		}
404
405		/**
406		* Verifies the existence of the service
407		* @param string $service
408		* @throws RuntimeException
409		*/
410		protected function checkContingencyForWebServices($service)
411		{
412		$permit = [
413		55 => ['SVCAN', 'SVCRS', 'EPEC', 'FSDA'],
414		65 => ['FSDA', 'EPEC', 'OFFLINE']
415		];
416
417		$type = $this->contingency->type;
418		$mod = $this->modelo;
419		if (!empty($type)) {
420		if (array_search($type, $permit[$mod]) === false) {
421		throw new RuntimeException(
422		"Esse modo de contingência [$type] não é aceito "
423		. "para o modelo [$mod]"
424		);
425		}
426		}
427
428		//se a contingencia é OFFLINE ou FSDA nenhum servidor está disponivel
429		//se a contigencia EPEC está ativa apenas o envio de Lote está ativo,
430		//então gerar um RunTimeException
431		if ($type == 'FSDA'
432		\|\| $type == 'OFFLINE'
433		\|\| ($type == 'EPEC' && $service != 'RecepcaoEvento')
434		) {
435		throw new RuntimeException(
436		"Quando operando em modo de contingência ["
437		. $this->contingency->type
438		. "], este serviço [$service] não está disponível."
439		);
440		}
441		}
442
443		/**
444		* Alter environment from "homologacao" to "producao" and vice-versa
445		* @param int $tpAmb
446		* @return void
447		*/
448	58	public function setEnvironment($tpAmb = 2)
449		{
450	58	if (!empty($tpAmb) && ($tpAmb == 1 \|\| $tpAmb == 2)) {
451	58	$this->tpAmb = $tpAmb;
452	58	$this->ambiente = ($tpAmb == 1) ? 'producao' : 'homologacao';
453		}
454	58	}
455
456		/**
457		* Set option for canonical transformation see C14n
458		* @param array $opt
459		* @return array
460		*/
461		public function canonicalOptions(array $opt = [true, false, null, null])
462		{
463		if (!empty($opt) && is_array($opt)) {
464		$this->canonical = $opt;
465		}
466		return $this->canonical;
467		}
468
469		/**
470		* Assembles all the necessary parameters for soap communication
471		* @param string $service
472		* @param string $uf
473		* @param int $tpAmb 1-Production or 2-Homologation
474		* @param bool $ignoreContingency
475		* @throws RuntimeException
476		* @return void
477		*/
478		protected function servico($service, $uf, $tpAmb, $ignoreContingency = false)
479		{
480		$webs = new Webservices($this->getXmlUrlPath());
481		$sigla = $uf;
482		if (!$ignoreContingency) {
483		$contType = $this->contingency->type;
484		if (!empty($contType) && ($contType == 'SVCRS' \|\| $contType == 'SVCAN')) {
485		$sigla = $contType;
486		}
487		}
488		$stdServ = $webs->get($sigla, $tpAmb, $this->modelo);
489		if (empty($stdServ->$service->url)) {
490		throw new \RuntimeException("Servico [$service] indisponivel UF [$uf] ou modelo [$this->modelo]");
491		}
492		$this->urlcUF = $this->getcUF($uf); //recuperação do cUF
493		if ($this->urlcUF > 91) {
494		$this->urlcUF = $this->getcUF($this->config->siglaUF); //foi solicitado dado de SVCRS ou SVCAN
495		}
496		$this->urlVersion = $stdServ->$service->version; //recuperação da versão
497		$this->urlService = $stdServ->$service->url; //recuperação da url do serviço
498		$this->urlMethod = $stdServ->$service->method; //recuperação do método
499		$this->urlOperation = $stdServ->$service->operation; //recuperação da operação
500		$this->urlNamespace = sprintf("%s/wsdl/%s", $this->urlPortal, $this->urlOperation); //monta namespace
501		//montagem do cabeçalho da comunicação SOAP
502		$this->urlHeader = Header::get($this->urlNamespace, $this->urlcUF, $this->urlVersion);
503		$this->urlAction = "\"$this->urlNamespace/$this->urlMethod\"";
504		}
505
506		/**
507		* Send request message to webservice
508		* @param string $request
509		* @param array $parameters
510		* @return string
511		* @throws RuntimeException
512		*/
513		protected function sendRequest($request, array $parameters = [])
514		{
515		if (in_array($this->contingency->tpEmis, [Contingency::TPEMIS_FSDA, Contingency::TPEMIS_OFFLINE])) {
516		throw new \RuntimeException('Em contingencia FSDA ou OFFLINE não é possivel acessar os webservices.');
517		}
518		$this->checkSoap();
519		$response = (string) $this->soap->send(
520		$this->urlService,
521		$this->urlMethod,
522		$this->urlAction,
523		SOAP_1_2,
524		$parameters,
525		$this->soapnamespaces,
526		$request,
527		$this->objHeader
528		);
529		return Strings::normalize($response);
530		}
531
532		/**
533		* Recover path to xml data base with list of soap services
534		* @return string
535		*/
536		protected function getXmlUrlPath()
537		{
538		$file = "wsnfe_" . $this->versao . "_mod55.xml";
539		if ($this->modelo == 65) {
540		$file = str_replace('55', '65', $file);
541		}
542
543		$path = $this->pathwsfiles . $file;
544		if (! file_exists($path)) {
545		return '';
546		}
547		return file_get_contents($path);
548		}
549
550		/**
551		* Add QRCode Tag to signed XML from a NFCe
552		* @param DOMDocument $dom
553		* @return string
554		*/
555		protected function addQRCode(DOMDocument $dom)
556		{
557		if (empty($this->config->CSC) \|\| empty($this->config->CSCid)) {
558		throw new \RuntimeException("O QRCode não pode ser criado pois faltam dados CSC e/ou CSCId");
559		}
560		$memmod = $this->modelo;
561		$this->modelo = 65;
562		$cUF = $dom->getElementsByTagName('cUF')->item(0)->nodeValue;
563		$tpAmb = $dom->getElementsByTagName('tpAmb')->item(0)->nodeValue;
564		$uf = UFList::getUFByCode($cUF);
565		$this->servico('NfeConsultaQR', $uf, $tpAmb);
566		$signed = QRCode::putQRTag(
567		$dom,
568		$this->config->CSC,
569		$this->config->CSCid,
570		$this->urlVersion,
571		$this->urlService,
572		$this->getURIConsultaNFCe($uf, $tpAmb)
573		);
574		$this->modelo = $memmod;
575		return Strings::clearXmlString($signed);
576		}
577
578		/**
579		* Get URI for search NFCe by key (chave)
580		* @param string $uf Abbreviation of the UF
581		* @param string $tpAmb SEFAZ environment, 1-Production or 2-Homologation
582		* @return string
583		*/
584	54	protected function getURIConsultaNFCe($uf, $tpAmb)
585		{
586	54	$arr = json_decode(file_get_contents($this->pathwsfiles . 'uri_consulta_nfce.json'), true);
587	54	$std = json_decode(json_encode($arr[$tpAmb]));
588	54	return $std->$uf;
589		}
590
591		/**
592		* Verify if SOAP class is loaded, if not, force load SoapCurl
593		*/
594		protected function checkSoap()
595		{
596		if (empty($this->soap)) {
597		$this->soap = new SoapCurl($this->certificate);
		0 ignored issues – show Documentation Bug introduced 2018-10-03 12:19 UTC by Report Bug Copy Issue Report It seems like `new \NFePHP\Common\Soap\...url($this->certificate)` of type `object<NFePHP\Common\Soap\SoapCurl>` is incompatible with the declared type `object<NFePHP\Common\Soap\SoapInterface>` of property `$soap`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
598		}
599		}
600
601		/**
602		* Verify if xml model is equal as modelo property
603		* @param string $xml
604		* @return bool
605		*/
606		protected function checkModelFromXml($xml)
607		{
608		$dom = new \DOMDocument();
609		$dom->loadXML($xml);
610		$model = $dom->getElementsByTagName('mod')->item(0)->nodeValue;
611		return $model == $this->modelo;
612		}
613		}
614

nfephp-org / sped-nfe

Push — master ( eb8237...9d55e5 )

Tools::checkModelFromXml() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like