Tools::setSignAlgorithm() - Code Metrics - Inspection of "Correção de emissão e cancelamento para o estado d..." - nfephp-org/sped-nfe - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#713)

unknown

created 2019-09-27 17:16 UTC

Tools::setSignAlgorithm() 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	4
ccs	0
cts	3
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';

    /**
     * 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();
        }
        $this->soap = new SoapCurl($certificate);
    }

    /**
     * Sets environment time zone
     * @param string $acronym (ou seja a sigla do estado)
     * @return void
     */
    public function setEnvironmentTimeZone($acronym)
    {
        date_default_timezone_set(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 (substr($cnpj, 0, 1) === 'N') {
            //não é CNPJ, então verificar se é CPF
            $cpf = $this->certificate->getCpf();
            if (substr($cpf, 0, 1) !== 'N') {
                $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('$xml');
        }
        //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();
        return (string) $this->soap->send(
            $this->urlService,
            $this->urlMethod,
            $this->urlAction,
            SOAP_1_2,
            $parameters,
            $this->soapnamespaces,
            $request,
            $this->objHeader
        );
    }

    /**
     * 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);
        }
    }
}


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		/**
175		* Loads configurations and Digital Certificate, map all paths, set timezone and instanciate Contingency::class
176		* @param string $configJson content of config in json format
177		* @param Certificate $certificate
178		* @param Contingency\|null $contingency
179		*/
180	58	public function __construct($configJson, Certificate $certificate, Contingency $contingency = null)
181		{
182	58	$this->pathwsfiles = realpath(__DIR__ . '/../../storage') . '/';
183		//valid config json string
184	58	$this->config = Config::validate($configJson);
185	58	$this->version($this->config->versao);
186	58	$this->setEnvironmentTimeZone($this->config->siglaUF);
187	58	$this->certificate = $certificate;
188	58	$this->typePerson = $this->getTypeOfPersonFromCertificate();
189	58	$this->setEnvironment($this->config->tpAmb);
190	58	if (empty($contingency)) {
191	58	$this->contingency = new Contingency();
192		}
193	58	$this->soap = new SoapCurl($certificate);
194	58	}
195
196		/**
197		* Sets environment time zone
198		* @param string $acronym (ou seja a sigla do estado)
199		* @return void
200		*/
201	58	public function setEnvironmentTimeZone($acronym)
202		{
203	58	date_default_timezone_set(TimeZoneByUF::get($acronym));
204	58	}
205
206		/**
207		* Return J or F from existing type in ASN.1 certificate
208		* J - pessoa juridica (CNPJ)
209		* F - pessoa física (CPF)
210		* @return string
211		*/
212	58	public function getTypeOfPersonFromCertificate()
213		{
214	58	$cnpj = $this->certificate->getCnpj();
215	58	$type = 'J';
216	58	if (substr($cnpj, 0, 1) === 'N') {
217		//não é CNPJ, então verificar se é CPF
218		$cpf = $this->certificate->getCpf();
219		if (substr($cpf, 0, 1) !== 'N') {
220		$type = 'F';
221		} else {
222		//não foi localizado nem CNPJ e nem CPF esse certificado não é usável
223		//throw new RuntimeException('Faltam elementos CNPJ/CPF no certificado digital.');
224		$type = '';
225		}
226		}
227	58	return $type;
228		}
229
230		/**
231		* Set application version
232		* @param string $ver
233		*/
234		public function setVerAplic($ver)
235		{
236		$this->verAplic = $ver;
237		}
238
239		/**
240		* Load Soap Class
241		* Soap Class may be \NFePHP\Common\Soap\SoapNative
242		* or \NFePHP\Common\Soap\SoapCurl
243		* @param SoapInterface $soap
244		* @return void
245		*/
246		public function loadSoapClass(SoapInterface $soap)
247		{
248		$this->soap = $soap;
249		$this->soap->loadCertificate($this->certificate);
250		}
251
252		/**
253		* Set OPENSSL Algorithm using OPENSSL constants
254		* @param int $algorithm
255		* @return void
256		*/
257		public function setSignAlgorithm($algorithm = OPENSSL_ALGO_SHA1)
258		{
259		$this->algorithm = $algorithm;
260		}
261
262		/**
263		* Set or get model of document NFe = 55 or NFCe = 65
264		* @param int $model
265		* @return int modelo class parameter
266		*/
267		public function model($model = null)
268		{
269		if ($model == 55 \|\| $model == 65) {
270		$this->modelo = $model;
271		}
272		return $this->modelo;
273		}
274
275		/**
276		* Set or get parameter layout version
277		* @param string $version
278		* @return string
279		* @throws InvalidArgumentException
280		*/
281	58	public function version($version = null)
282		{
283	58	if (null === $version) {
284		return $this->versao;
285		}
286		//Verify version template is defined
287	58	if (false === isset($this->availableVersions[$version])) {
288		throw new \InvalidArgumentException('Essa versão de layout não está disponível');
289		}
290
291	58	$this->versao = $version;
292	58	$this->config->schemes = $this->availableVersions[$version];
293	58	$this->pathschemes = realpath(
294	58	__DIR__ . '/../../schemes/'. $this->config->schemes
295	58	).'/';
296
297	58	return $this->versao;
298		}
299
300		/**
301		* Recover cUF number from state acronym
302		* @param string $acronym Sigla do estado
303		* @return int number cUF
304		*/
305		public function getcUF($acronym)
306		{
307		return UFlist::getCodeByUF($acronym);
308		}
309
310		/**
311		* Recover state acronym from cUF number
312		* @param int $cUF
313		* @return string acronym sigla
314		*/
315		public function getAcronym($cUF)
316		{
317		return UFlist::getUFByCode($cUF);
318		}
319
320		/**
321		* Validate cUF from the key content and returns the state acronym
322		* @param string $chave
323		* @return string
324		* @throws InvalidArgumentException
325		*/
326		public function validKeyByUF($chave)
327		{
328		$uf = $this->config->siglaUF;
329		if ($uf != UFList::getUFByCode(substr($chave, 0, 2))) {
330		throw new \InvalidArgumentException(
331		"A chave da NFe indicada [$chave] não pertence a [$uf]."
332		);
333		}
334		return $uf;
335		}
336
337		/**
338		* Sign NFe or NFCe
339		* @param string $xml NFe xml content
340		* @return string signed NFe xml
341		* @throws RuntimeException
342		*/
343		public function signNFe($xml)
344		{
345		if (empty($xml)) {
346		throw new InvalidArgumentException('$xml');
347		}
348		//remove all invalid strings
349		$xml = Strings::clearXmlString($xml);
350		if ($this->contingency->type !== '') {
351		$xml = ContingencyNFe::adjust($xml, $this->contingency);
352		}
353		$signed = Signer::sign(
354		$this->certificate,
355		$xml,
356		'infNFe',
357		'Id',
358		$this->algorithm,
359		$this->canonical
360		);
361		$dom = new DOMDocument('1.0', 'UTF-8');
362		$dom->preserveWhiteSpace = false;
363		$dom->formatOutput = false;
364		$dom->loadXML($signed);
365		$modelo = $dom->getElementsByTagName('mod')->item(0)->nodeValue;
366		$isInfNFeSupl = !empty($dom->getElementsByTagName('infNFeSupl')->item(0));
367		if ($modelo == 65 && !$isInfNFeSupl) {
368		$signed = $this->addQRCode($dom);
369		}
370		//exception will be throw if NFe is not valid
371		$this->isValid($this->versao, $signed, 'nfe');
372		return $signed;
373		}
374
375		/**
376		* Corrects NFe fields when in contingency mode
377		* @param string $xml NFe xml content
378		* @return string
379		*/
380		protected function correctNFeForContingencyMode($xml)
381		{
382		return $this->contingency->type == '' ? $xml : $this->signNFe($xml);
383		}
384
385		/**
386		* Performs xml validation with its respective XSD structure definition document
387		* NOTE: if don't exists the XSD file will return true
388		* @param string $version layout version
389		* @param string $body
390		* @param string $method
391		* @return bool
392		*/
393		protected function isValid($version, $body, $method)
394		{
395		$schema = $this->pathschemes.$method."_v$version.xsd";
396		if (!is_file($schema)) {
397		return true;
398		}
399		return Validator::isValid($body, $schema);
400		}
401
402		/**
403		* Verifies the existence of the service
404		* @param string $service
405		* @throws RuntimeException
406		*/
407		protected function checkContingencyForWebServices($service)
408		{
409		$permit = [
410		55 => ['SVCAN', 'SVCRS', 'EPEC', 'FSDA'],
411		65 => ['FSDA', 'EPEC', 'OFFLINE']
412		];
413
414		$type = $this->contingency->type;
415		$mod = $this->modelo;
416		if (!empty($type)) {
417		if (array_search($type, $permit[$mod]) === false) {
418		throw new RuntimeException(
419		"Esse modo de contingência [$type] não é aceito "
420		. "para o modelo [$mod]"
421		);
422		}
423		}
424
425		//se a contingencia é OFFLINE ou FSDA nenhum servidor está disponivel
426		//se a contigencia EPEC está ativa apenas o envio de Lote está ativo,
427		//então gerar um RunTimeException
428		if ($type == 'FSDA'
429		\|\| $type == 'OFFLINE'
430		\|\| ($type == 'EPEC' && $service != 'RecepcaoEvento')
431		) {
432		throw new RuntimeException(
433		"Quando operando em modo de contingência ["
434		. $this->contingency->type
435		. "], este serviço [$service] não está disponível."
436		);
437		}
438		}
439
440		/**
441		* Alter environment from "homologacao" to "producao" and vice-versa
442		* @param int $tpAmb
443		* @return void
444		*/
445	58	public function setEnvironment($tpAmb = 2)
446		{
447	58	if (!empty($tpAmb) && ($tpAmb == 1 \|\| $tpAmb == 2)) {
448	58	$this->tpAmb = $tpAmb;
449	58	$this->ambiente = ($tpAmb == 1) ? 'producao' : 'homologacao';
450		}
451	58	}
452
453		/**
454		* Set option for canonical transformation see C14n
455		* @param array $opt
456		* @return array
457		*/
458		public function canonicalOptions(array $opt = [true, false, null, null])
459		{
460		if (!empty($opt) && is_array($opt)) {
461		$this->canonical = $opt;
462		}
463		return $this->canonical;
464		}
465
466		/**
467		* Assembles all the necessary parameters for soap communication
468		* @param string $service
469		* @param string $uf
470		* @param int $tpAmb 1-Production or 2-Homologation
471		* @param bool $ignoreContingency
472		* @throws RuntimeException
473		* @return void
474		*/
475		protected function servico($service, $uf, $tpAmb, $ignoreContingency = false)
476		{
477		$webs = new Webservices($this->getXmlUrlPath());
478		$sigla = $uf;
479		if (!$ignoreContingency) {
480		$contType = $this->contingency->type;
481		if (!empty($contType) && ($contType == 'SVCRS' \|\| $contType == 'SVCAN')) {
482		$sigla = $contType;
483		}
484		}
485		$stdServ = $webs->get($sigla, $tpAmb, $this->modelo);
486		if (empty($stdServ->$service->url)) {
487		throw new \RuntimeException("Servico [$service] indisponivel UF [$uf] ou modelo [$this->modelo]");
488		}
489		$this->urlcUF = $this->getcUF($uf); //recuperação do cUF
490		if ($this->urlcUF > 91) {
491		$this->urlcUF = $this->getcUF($this->config->siglaUF); //foi solicitado dado de SVCRS ou SVCAN
492		}
493		$this->urlVersion = $stdServ->$service->version; //recuperação da versão
494		$this->urlService = $stdServ->$service->url; //recuperação da url do serviço
495		$this->urlMethod = $stdServ->$service->method; //recuperação do método
496		$this->urlOperation = $stdServ->$service->operation; //recuperação da operação
497		$this->urlNamespace = sprintf("%s/wsdl/%s", $this->urlPortal, $this->urlOperation); //monta namespace
498		//montagem do cabeçalho da comunicação SOAP
499		$this->urlHeader = Header::get($this->urlNamespace, $this->urlcUF, $this->urlVersion);
500		$this->urlAction = "\"$this->urlNamespace/$this->urlMethod\"";
501		}
502
503		/**
504		* Send request message to webservice
505		* @param string $request
506		* @param array $parameters
507		* @return string
508		* @throws RuntimeException
509		*/
510		protected function sendRequest($request, array $parameters = [])
511		{
512		if (in_array($this->contingency->tpEmis, [Contingency::TPEMIS_FSDA, Contingency::TPEMIS_OFFLINE])) {
513		throw new \RuntimeException('Em contingencia FSDA ou OFFLINE não é possivel acessar os webservices.');
514		}
515		$this->checkSoap();
516		return (string) $this->soap->send(
517		$this->urlService,
518		$this->urlMethod,
519		$this->urlAction,
520		SOAP_1_2,
521		$parameters,
522		$this->soapnamespaces,
523		$request,
524		$this->objHeader
525		);
526		}
527
528		/**
529		* Recover path to xml data base with list of soap services
530		* @return string
531		*/
532		protected function getXmlUrlPath()
533		{
534		$file = "wsnfe_" . $this->versao . "_mod55.xml";
535		if ($this->modelo == 65) {
536		$file = str_replace('55', '65', $file);
537		}
538
539		$path = $this->pathwsfiles . $file;
540		if (! file_exists($path)) {
541		return '';
542		}
543		return file_get_contents($path);
544		}
545
546		/**
547		* Add QRCode Tag to signed XML from a NFCe
548		* @param DOMDocument $dom
549		* @return string
550		*/
551		protected function addQRCode(DOMDocument $dom)
552		{
553		if (empty($this->config->CSC) \|\| empty($this->config->CSCid)) {
554		throw new \RuntimeException("O QRCode não pode ser criado pois faltam dados CSC e/ou CSCId");
555		}
556		$memmod = $this->modelo;
557		$this->modelo = 65;
558		$cUF = $dom->getElementsByTagName('cUF')->item(0)->nodeValue;
559		$tpAmb = $dom->getElementsByTagName('tpAmb')->item(0)->nodeValue;
560		$uf = UFList::getUFByCode($cUF);
561		$this->servico('NfeConsultaQR', $uf, $tpAmb);
562		$signed = QRCode::putQRTag(
563		$dom,
564		$this->config->CSC,
565		$this->config->CSCid,
566		$this->urlVersion,
567		$this->urlService,
568		$this->getURIConsultaNFCe($uf, $tpAmb)
569		);
570		$this->modelo = $memmod;
571		return Strings::clearXmlString($signed);
572		}
573
574		/**
575		* Get URI for search NFCe by key (chave)
576		* @param string $uf Abbreviation of the UF
577		* @param string $tpAmb SEFAZ environment, 1-Production or 2-Homologation
578		* @return string
579		*/
580	54	protected function getURIConsultaNFCe($uf, $tpAmb)
581		{
582	54	$arr = json_decode(file_get_contents($this->pathwsfiles . 'uri_consulta_nfce.json'), true);
583	54	$std = json_decode(json_encode($arr[$tpAmb]));
584	54	return $std->$uf;
585		}
586
587		/**
588		* Verify if SOAP class is loaded, if not, force load SoapCurl
589		*/
590		protected function checkSoap()
591		{
592		if (empty($this->soap)) {
593		$this->soap = new SoapCurl($this->certificate);
594		}
595		}
596		}
597

nfephp-org / sped-nfe

Pull Request — master (#713)

Tools::setSignAlgorithm() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like