SoapBase::mountEnvelopString() - Code Metrics - Inspection of "Melhorias e limpeza de código, metodologia @tavinu..." - nfephp-org/sped-common - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#144)

by Sebastiao

created 2017-12-04 15:38 UTC

SoapBase::mountEnvelopString() A

↳ Parent: SoapBase

Complexity

Conditions	1
Paths	1

Size

Total Lines	16
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	16
ccs	0
cts	3
cp	0
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	13
nc	1
nop	4
crap	2

<?php
namespace NFePHP\Common\Soap;

use NFePHP\Common\Certificate;
use NFePHP\Common\Exception\RuntimeException;
use NFePHP\Common\Strings;
use League\Flysystem\Filesystem;
use League\Flysystem\Adapter\Local;
use Psr\Log\LoggerInterface;

/**
 * Soap base class
 *
 * @category  NFePHP
 * @package   NFePHP\Common\Soap\SoapBase
 * @copyright NFePHP Copyright (c) 2017
 * @author    Roberto L. Machado <linux.rlm at gmail dot com>
 * @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+
 * @link      http://github.com/nfephp-org/sped-nfse for the canonical source repository
 */
abstract class SoapBase implements SoapInterface
{
    /**
     * @var int
     */
    protected $soapprotocol = self::SSL_DEFAULT;
    /**
     * @var int
     */
    protected $soaptimeout = 20;
    /**
     * @var string
     */
    protected $proxyIP;
    /**
     * @var int
     */
    protected $proxyPort;
    /**
     * @var string
     */
    protected $proxyUser;
    /**
     * @var string
     */
    protected $proxyPass;
    /**
     * @var array
     */
    protected $prefixes = [1 => 'soapenv', 2 => 'soap'];
    /**
     * @var Certificate
     */
    protected $certificate;
    /**
     * @var LoggerInterface
     */
    protected $logger;
     /**
     * @var string
     */
    protected $tempdir;
    /**
     * @var string
     */
    protected $certsdir;
    /**
     * @var string
     */
    protected $debugdir;
    /**
     * @var string
     */
    protected $prifile;
    /**
     * @var string
     */
    protected $pubfile;
    /**
     * @var string
     */
    protected $certfile;
    /**
     * @var string
     */
    protected $casefaz;
    /**
     * @var bool
     */
    protected $disablesec = false;
    /**
     * @var bool
     */
    protected $disableCertValidation = false;
    /**
     * @var \League\Flysystem\Adapter\Local
     */
    protected $adapter;
    /**
     * @var \League\Flysystem\Filesystem
     */
    protected $filesystem;
    /**
     * @var string
     */
    protected $temppass = '';
    /**
     * @var bool
     */
    protected $encriptPrivateKey = true;
    /**
     * @var bool
     */
    protected $debugmode = false;
    /**
     * @var string
     */
    public $responseHead;
    /**
     * @var string
     */
    public $responseBody;
    /**
     * @var string
     */
    public $requestHead;
    /**
     * @var string
     */
    public $requestBody;
    /**
     * @var string
     */
    public $soaperror;
    /**
     * @var array
     */
    public $soapinfo = [];
    /**
     * @var int
     */
    public $waitingTime = 45;

    /**
     * SoapBase constructor.
     * @param Certificate|null     $certificate Certificate from client
     * @param LoggerInterface|null $logger      Logger object for logger
     */
    public function __construct(
        Certificate $certificate = null,
        LoggerInterface $logger = null
    ) {
        $this->logger = $logger;
        $this->certificate = $this->certIsExpired($certificate);
        $this->setTemporaryFolder(sys_get_temp_dir() . '/sped/');

        if (null !== $certificate) {
            $this->saveTemporarilyKeyFiles();
        }
    }

    /**
     * Check if certificate is valid to currently used date
     * @param Certificate $certificate
     * @return Certificate
     * @throws RuntimeException
     */
    private function certIsExpired(Certificate $certificate = null)
    {
        if (false === $this->disableCertValidation
            && null !== $certificate
            && $certificate->isExpired()
        ) {
            throw new RuntimeException(
                'The validity of the certificate has expired.'
            );
        }

        return $certificate;
    }
    
    /**
     * Destructor
     * Clean temporary files
     */
    public function __destruct()
    {
        $this->removeTemporarilyFiles();
    }

    /**
     * Disables the security checking of host and peer certificates
     * @param bool $flag
     * @return bool
     */
    public function disableSecurity($flag = false)
    {
        return $this->disablesec = $flag;
    }
    
    /**
     * ONlY for tests
     * @param bool $flag
     * @return bool
     */
    public function disableCertValidation($flag = true)
    {
        return $this->disableCertValidation = $flag;
    }

    /**
     * Load path to CA and enable to use on SOAP
     * @param string $capath
     * @return void
     */
    public function loadCA($capath)
    {
        if (is_file($capath)) {
            $this->casefaz = $capath;
        }
    }
    
    /**
     * Set option to encrypt private key before save in filesystem
     * for an additional layer of protection
     * @param bool $encript
     * @return bool
     */
    public function setEncriptPrivateKey($encript = true)
    {
        return $this->encriptPrivateKey = $encript;
    }
    
    /**
     * Set another temporayfolder for saving certificates for SOAP utilization
     * @param string $folderRealPath
     * @return void
     */
    public function setTemporaryFolder($folderRealPath)
    {
        $this->tempdir = $folderRealPath;
        $this->setLocalFolder($folderRealPath);
    }
    
    /**
     * Set Local folder for flysystem
     * @param string $folder
     */
    protected function setLocalFolder($folder = '')
    {
        $this->adapter = new Local($folder);
        $this->filesystem = new Filesystem($this->adapter);
    }

    /**
     * Set debug mode, this mode will save soap envelopes in temporary directory
     * @param bool $value
     * @return bool
     */
    public function setDebugMode($value = false)
    {
        return $this->debugmode = $value;
    }
    
    /**
     * Set certificate class for SSL communications
     * @param Certificate $certificate
     * @return void
     */
    public function loadCertificate(Certificate $certificate)
    {
        $this->certificate = $this->certIsExpired($certificate);
    }
    
    /**
     * Set logger class
     * @param LoggerInterface $logger
     * @return LoggerInterface
     */
    public function loadLogger(LoggerInterface $logger)
    {
        return $this->logger = $logger;
    }
    
    /**
     * Set timeout for communication
     * @param int $timesecs
     * @return int
     */
    public function timeout(int $timesecs)
    {
        return $this->soaptimeout = $timesecs;
    }
    
    /**
     * Set security protocol
     * @param int $protocol
     * @return int
     */
    public function protocol($protocol = self::SSL_DEFAULT)
    {
        return $this->soapprotocol = $protocol;
    }
    
    /**
     * Set prefixes
     * @param array $prefixes
     * @return string[]
     */
    public function setSoapPrefix($prefixes = [])
    {
        return $this->prefixes = $prefixes;
    }

    /**
     * Set proxy parameters
     * @param string $ip
     * @param int    $port
     * @param string $user
     * @param string $password
     * @return void
     */
    public function proxy($ip, $port, $user, $password)
    {
        $this->proxyIP = $ip;
        $this->proxyPort = $port;
        $this->proxyUser = $user;
        $this->proxyPass = $password;
    }

    /**
     * @param string $url
     * @param string $operation
     * @param string $action
     * @param int $soapver
     * @param array $parameters
     * @param array $namespaces
     * @param string $request
     * @param null $soapheader
     * @return mixed
     */
    abstract public function send(
        $url,
        $operation = '',
        $action = '',
        $soapver = SOAP_1_2,
        $parameters = [],
        $namespaces = [],
        $request = '',
        $soapheader = null
    );
    
    /**
     * Mount soap envelope
     * @param string $request
     * @param array $namespaces
     * @param $soapVer int
     * @param \SOAPHeader $header
     * @return string
     */
    protected function makeEnvelopeSoap(
        $request,
        $namespaces,
        $soapVer = SOAP_1_2,
        \SoapHeader $header = null
    ) {
        $prefix = $this->prefixes[$soapVer];

        $envelopeAttributes = $this->getStringAttributes($namespaces);

        return $this->mountEnvelopString(
            $prefix,
            $envelopeAttributes,
            $this->mountSoapHeaders($prefix, $header),
            $request
        );
    }

    /**
     * @param string $envelopPrefix
     * @param string $envelopAttributes
     * @param string $header
     * @param string $bodyContent
     * @return string
     */
    private function mountEnvelopString(
        $envelopPrefix,
        $envelopAttributes = '',
        $header = '',
        $bodyContent = ''
    ) {
        return sprintf(
            '<%s:Envelope %s >'.$header.'<%s:Body>%s</%s:Body></%s:Envelop>',
            $envelopPrefix,
            $envelopAttributes,
            $envelopPrefix,
            $bodyContent,
            $envelopPrefix,
            $envelopPrefix
        );
    }

    /**
     * @param string $envelopPrefix
     * @param \SoapHeader $header
     * @return string
     */
    private function mountSoapHeaders($envelopPrefix, $header = null)
    {
        $headerItems = '';
        foreach ($header->data as $key => $value) {

            $headerItems = '<'.$key.'>'.$value.'<'.$key.'>';
        }

        return
            $header ? sprintf(
                '<%s:Header><%s xmlns="%s">%s</%s></%s:Header>',
                $envelopPrefix,
                $header->name,

                $header->ns ?? '',

                $headerItems
            ) : '';
    }

    /**
     * @param array $namespaces
     * @return string
     */
    private function getStringAttributes($namespaces = [])
    {
        foreach ($namespaces as $key => $value) {
            $envelopeAttributes = $key.'="'.$value.'"';
        }

        return $envelopeAttributes ?? '';
    }

    
    /**
     * Temporarily saves the certificate keys for use cURL or SoapClient
     */
    public function saveTemporarilyKeyFiles()
    {
        if (!is_object($this->certificate)) {
            throw new RuntimeException(
                'Certificate not found.'
            );
        }
        $this->certsdir = $this->certificate->getCnpj() . '/certs/';
        $this->prifile = $this->certsdir. Strings::randomString(10).'.pem';
        $this->pubfile = $this->certsdir . Strings::randomString(10).'.pem';
        $this->certfile = $this->certsdir . Strings::randomString(10).'.pem';
        $ret = true;
        $private = $this->certificate->privateKey;
        if ($this->encriptPrivateKey) {
            //cria uma senha temporária ALEATÓRIA para salvar a chave primaria
            //portanto mesmo que localizada e identificada não estará acessível
            //pois sua senha não existe além do tempo de execução desta classe
            $this->temppass = Strings::randomString(16);
            //encripta a chave privada entes da gravação do filesystem
            openssl_pkey_export(
                $this->certificate->privateKey,
                $private,
                $this->temppass
            );
        }
        $ret &= $this->filesystem->put(
            $this->prifile,
            $private
        );
        $ret &= $this->filesystem->put(
            $this->pubfile,
            $this->certificate->publicKey
        );
        $ret &= $this->filesystem->put(
            $this->certfile,
            $private."{$this->certificate}"
        );
        if (!$ret) {
            throw new RuntimeException(
                'Unable to save temporary key files in folder.'
            );
        }
    }
    
    /**
     * Delete all files in folder
     */
    public function removeTemporarilyFiles()
    {
        $contents = $this->filesystem->listContents($this->certsdir, true);
        //define um limite de $waitingTime min, ou seja qualquer arquivo criado a mais
        //de $waitingTime min será removido
        //NOTA: quando ocorre algum erro interno na execução do script, alguns
        //arquivos temporários podem permanecer
        //NOTA: O tempo default é de 45 minutos e pode ser alterado diretamente nas
        //propriedades da classe, esse tempo entre 5 a 45 min é recomendável pois
        //podem haver processos concorrentes para um mesmo usuário. Esses processos
        //como o DFe podem ser mais longos, dependendo a forma que o aplicativo
        //utilize a API. Outra solução para remover arquivos "perdidos" pode ser
        //encontrada oportunamente.
        $dt = new \DateTime();
        $tint = new \DateInterval("PT".$this->waitingTime."M");
        $tint->invert = true;
$answer = 42;

$correct = false;

$correct = (bool) $answer;
        $tsLimit = $dt->add($tint)->getTimestamp();
        foreach ($contents as $item) {
            if ($item['type'] == 'file') {
                if ($item['path'] == $this->prifile
                    || $item['path'] == $this->pubfile
                    || $item['path'] == $this->certfile
                ) {
                    $this->filesystem->delete($item['path']);
                    continue;
                }
                $timestamp = $this->filesystem->getTimestamp($item['path']);
                if ($timestamp < $tsLimit) {
                    //remove arquivos criados a mais de 45 min
                    $this->filesystem->delete($item['path']);
                }
            }
        }
    }
    
    /**
     * Save request envelope and response for debug reasons
     * @param string $operation
     * @param string $request
     * @param string $response
     * @return void
     */
    public function saveDebugFiles($operation, $request, $response)
    {
        if (!$this->debugmode) {
            return;
        }
        $this->debugdir = $this->certificate->getCnpj() . '/debug/';
        $now = \DateTime::createFromFormat('U.u', number_format(microtime(true), 6, '.', ''));
        $time = substr($now->format("ymdHisu"), 0, 16);
        try {
            $this->filesystem->put(
                $this->debugdir . $time . "_" . $operation . "_sol.txt",
                $request
            );
            $this->filesystem->put(
                $this->debugdir . $time . "_" . $operation . "_res.txt",
                $response
            );
        } catch (\Exception $e) {
            throw new RuntimeException(
                'Unable to create debug files.'
            );
        }
    }
}


1		<?php
2		namespace NFePHP\Common\Soap;
3
4		use NFePHP\Common\Certificate;
5		use NFePHP\Common\Exception\RuntimeException;
6		use NFePHP\Common\Strings;
7		use League\Flysystem\Filesystem;
8		use League\Flysystem\Adapter\Local;
9		use Psr\Log\LoggerInterface;
10
11		/**
12		* Soap base class
13		*
14		* @category NFePHP
15		* @package NFePHP\Common\Soap\SoapBase
16		* @copyright NFePHP Copyright (c) 2017
17		* @author Roberto L. Machado <linux.rlm at gmail dot com>
18		* @license http://www.gnu.org/licenses/lgpl.txt LGPLv3+
19		* @license https://opensource.org/licenses/MIT MIT
20		* @license http://www.gnu.org/licenses/gpl.txt GPLv3+
21		* @link http://github.com/nfephp-org/sped-nfse for the canonical source repository
22		*/
23		abstract class SoapBase implements SoapInterface
24		{
25		/**
26		* @var int
27		*/
28		protected $soapprotocol = self::SSL_DEFAULT;
29		/**
30		* @var int
31		*/
32		protected $soaptimeout = 20;
33		/**
34		* @var string
35		*/
36		protected $proxyIP;
37		/**
38		* @var int
39		*/
40		protected $proxyPort;
41		/**
42		* @var string
43		*/
44		protected $proxyUser;
45		/**
46		* @var string
47		*/
48		protected $proxyPass;
49		/**
50		* @var array
51		*/
52		protected $prefixes = [1 => 'soapenv', 2 => 'soap'];
53		/**
54		* @var Certificate
55		*/
56		protected $certificate;
57		/**
58		* @var LoggerInterface
59		*/
60		protected $logger;
61		/**
62		* @var string
63		*/
64		protected $tempdir;
65		/**
66		* @var string
67		*/
68		protected $certsdir;
69		/**
70		* @var string
71		*/
72		protected $debugdir;
73		/**
74		* @var string
75		*/
76		protected $prifile;
77		/**
78		* @var string
79		*/
80		protected $pubfile;
81		/**
82		* @var string
83		*/
84		protected $certfile;
85		/**
86		* @var string
87		*/
88		protected $casefaz;
89		/**
90		* @var bool
91		*/
92		protected $disablesec = false;
93		/**
94		* @var bool
95		*/
96		protected $disableCertValidation = false;
97		/**
98		* @var \League\Flysystem\Adapter\Local
99		*/
100		protected $adapter;
101		/**
102		* @var \League\Flysystem\Filesystem
103		*/
104		protected $filesystem;
105		/**
106		* @var string
107		*/
108		protected $temppass = '';
109		/**
110		* @var bool
111		*/
112		protected $encriptPrivateKey = true;
113		/**
114		* @var bool
115		*/
116		protected $debugmode = false;
117		/**
118		* @var string
119		*/
120		public $responseHead;
121		/**
122		* @var string
123		*/
124		public $responseBody;
125		/**
126		* @var string
127		*/
128		public $requestHead;
129		/**
130		* @var string
131		*/
132		public $requestBody;
133		/**
134		* @var string
135		*/
136		public $soaperror;
137		/**
138		* @var array
139		*/
140		public $soapinfo = [];
141		/**
142		* @var int
143		*/
144		public $waitingTime = 45;
145
146		/**
147		* SoapBase constructor.
148		* @param Certificate\|null $certificate Certificate from client
149		* @param LoggerInterface\|null $logger Logger object for logger
150		*/
151	5	public function __construct(
152		Certificate $certificate = null,
153		LoggerInterface $logger = null
154		) {
155	5	$this->logger = $logger;
156	5	$this->certificate = $this->certIsExpired($certificate);
157	4	$this->setTemporaryFolder(sys_get_temp_dir() . '/sped/');
158
159	4	if (null !== $certificate) {
160		$this->saveTemporarilyKeyFiles();
161		}
162	4	}
163
164		/**
165		* Check if certificate is valid to currently used date
166		* @param Certificate $certificate
167		* @return Certificate
168		* @throws RuntimeException
169		*/
170	5	private function certIsExpired(Certificate $certificate = null)
171		{
172	5	if (false === $this->disableCertValidation
173	5	&& null !== $certificate
174	5	&& $certificate->isExpired()
175		) {
176	1	throw new RuntimeException(
177	1	'The validity of the certificate has expired.'
178		);
179		}
180
181	4	return $certificate;
182		}
183
184		/**
185		* Destructor
186		* Clean temporary files
187		*/
188	4	public function __destruct()
189		{
190	4	$this->removeTemporarilyFiles();
191	4	}
192
193		/**
194		* Disables the security checking of host and peer certificates
195		* @param bool $flag
196		* @return bool
197		*/
198	1	public function disableSecurity($flag = false)
199		{
200	1	return $this->disablesec = $flag;
201		}
202
203		/**
204		* ONlY for tests
205		* @param bool $flag
206		* @return bool
207		*/
208	1	public function disableCertValidation($flag = true)
209		{
210	1	return $this->disableCertValidation = $flag;
211		}
212
213		/**
214		* Load path to CA and enable to use on SOAP
215		* @param string $capath
216		* @return void
217		*/
218		public function loadCA($capath)
219		{
220		if (is_file($capath)) {
221		$this->casefaz = $capath;
222		}
223		}
224
225		/**
226		* Set option to encrypt private key before save in filesystem
227		* for an additional layer of protection
228		* @param bool $encript
229		* @return bool
230		*/
231		public function setEncriptPrivateKey($encript = true)
232		{
233		return $this->encriptPrivateKey = $encript;
234		}
235
236		/**
237		* Set another temporayfolder for saving certificates for SOAP utilization
238		* @param string $folderRealPath
239		* @return void
240		*/
241	4	public function setTemporaryFolder($folderRealPath)
242		{
243	4	$this->tempdir = $folderRealPath;
244	4	$this->setLocalFolder($folderRealPath);
245	4	}
246
247		/**
248		* Set Local folder for flysystem
249		* @param string $folder
250		*/
251	4	protected function setLocalFolder($folder = '')
252		{
253	4	$this->adapter = new Local($folder);
254	4	$this->filesystem = new Filesystem($this->adapter);
255	4	}
256
257		/**
258		* Set debug mode, this mode will save soap envelopes in temporary directory
259		* @param bool $value
260		* @return bool
261		*/
262		public function setDebugMode($value = false)
263		{
264		return $this->debugmode = $value;
265		}
266
267		/**
268		* Set certificate class for SSL communications
269		* @param Certificate $certificate
270		* @return void
271		*/
272	1	public function loadCertificate(Certificate $certificate)
273		{
274	1	$this->certificate = $this->certIsExpired($certificate);
275	1	}
276
277		/**
278		* Set logger class
279		* @param LoggerInterface $logger
280		* @return LoggerInterface
281		*/
282		public function loadLogger(LoggerInterface $logger)
283		{
284		return $this->logger = $logger;
285		}
286
287		/**
288		* Set timeout for communication
289		* @param int $timesecs
290		* @return int
291		*/
292		public function timeout(int $timesecs)
293		{
294		return $this->soaptimeout = $timesecs;
295		}
296
297		/**
298		* Set security protocol
299		* @param int $protocol
300		* @return int
301		*/
302		public function protocol($protocol = self::SSL_DEFAULT)
303		{
304		return $this->soapprotocol = $protocol;
305		}
306
307		/**
308		* Set prefixes
309		* @param array $prefixes
310		* @return string[]
311		*/
312		public function setSoapPrefix($prefixes = [])
313		{
314		return $this->prefixes = $prefixes;
315		}
316
317		/**
318		* Set proxy parameters
319		* @param string $ip
320		* @param int $port
321		* @param string $user
322		* @param string $password
323		* @return void
324		*/
325		public function proxy($ip, $port, $user, $password)
326		{
327		$this->proxyIP = $ip;
328		$this->proxyPort = $port;
329		$this->proxyUser = $user;
330		$this->proxyPass = $password;
331		}
332
333		/**
334		* @param string $url
335		* @param string $operation
336		* @param string $action
337		* @param int $soapver
338		* @param array $parameters
339		* @param array $namespaces
340		* @param string $request
341		* @param null $soapheader
342		* @return mixed
343		*/
344		abstract public function send(
345		$url,
346		$operation = '',
347		$action = '',
348		$soapver = SOAP_1_2,
349		$parameters = [],
350		$namespaces = [],
351		$request = '',
352		$soapheader = null
353		);
354
355		/**
356		* Mount soap envelope
357		* @param string $request
358		* @param array $namespaces
359		* @param $soapVer int
360		* @param \SOAPHeader $header
361		* @return string
362		*/
363		protected function makeEnvelopeSoap(
364		$request,
365		$namespaces,
366		$soapVer = SOAP_1_2,
367		\SoapHeader $header = null
368		) {
369		$prefix = $this->prefixes[$soapVer];
370
371		$envelopeAttributes = $this->getStringAttributes($namespaces);
372
373		return $this->mountEnvelopString(
374		$prefix,
375		$envelopeAttributes,
376		$this->mountSoapHeaders($prefix, $header),
377		$request
378		);
379		}
380
381		/**
382		* @param string $envelopPrefix
383		* @param string $envelopAttributes
384		* @param string $header
385		* @param string $bodyContent
386		* @return string
387		*/
388		private function mountEnvelopString(
389		$envelopPrefix,
390		$envelopAttributes = '',
391		$header = '',
392		$bodyContent = ''
393		) {
394		return sprintf(
395		'<%s:Envelope %s >'.$header.'<%s:Body>%s</%s:Body></%s:Envelop>',
396		$envelopPrefix,
397		$envelopAttributes,
398		$envelopPrefix,
399		$bodyContent,
400		$envelopPrefix,
401		$envelopPrefix
402		);
403		}
404
405		/**
406		* @param string $envelopPrefix
407		* @param \SoapHeader $header
408		* @return string
409		*/
410		private function mountSoapHeaders($envelopPrefix, $header = null)
411		{
412		$headerItems = '';
413		foreach ($header->data as $key => $value) {
		0 ignored issues – show Bug introduced 2017-04-29 14:39 UTC by Report Bug Copy Issue Report The property `data` does not seem to exist in `SoapHeader`. An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
414		$headerItems = '<'.$key.'>'.$value.'<'.$key.'>';
415		}
416
417		return
418		$header ? sprintf(
419		'<%s:Header><%s xmlns="%s">%s</%s></%s:Header>',
420		$envelopPrefix,
421		$header->name,
		0 ignored issues – show Bug introduced 2017-12-03 18:48 UTC by Report Bug Copy Issue Report The property `name` does not seem to exist in `SoapHeader`. An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
422		$header->ns ?? '',
		0 ignored issues – show Bug introduced 2017-12-03 18:48 UTC by Report Bug Copy Issue Report The property `ns` does not seem to exist in `SoapHeader`. An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
423		$headerItems
424		) : '';
425		}
426
427		/**
428		* @param array $namespaces
429		* @return string
430		*/
431		private function getStringAttributes($namespaces = [])
432		{
433		foreach ($namespaces as $key => $value) {
434		$envelopeAttributes = $key.'="'.$value.'"';
435		}
436
437		return $envelopeAttributes ?? '';
438		}
439
440
441		/**
442		* Temporarily saves the certificate keys for use cURL or SoapClient
443		*/
444		public function saveTemporarilyKeyFiles()
445		{
446		if (!is_object($this->certificate)) {
447		throw new RuntimeException(
448		'Certificate not found.'
449		);
450		}
451		$this->certsdir = $this->certificate->getCnpj() . '/certs/';
452		$this->prifile = $this->certsdir. Strings::randomString(10).'.pem';
453		$this->pubfile = $this->certsdir . Strings::randomString(10).'.pem';
454		$this->certfile = $this->certsdir . Strings::randomString(10).'.pem';
455		$ret = true;
456		$private = $this->certificate->privateKey;
457		if ($this->encriptPrivateKey) {
458		//cria uma senha temporária ALEATÓRIA para salvar a chave primaria
459		//portanto mesmo que localizada e identificada não estará acessível
460		//pois sua senha não existe além do tempo de execução desta classe
461		$this->temppass = Strings::randomString(16);
462		//encripta a chave privada entes da gravação do filesystem
463		openssl_pkey_export(
464		$this->certificate->privateKey,
465		$private,
466		$this->temppass
467		);
468		}
469		$ret &= $this->filesystem->put(
470		$this->prifile,
471		$private
472		);
473		$ret &= $this->filesystem->put(
474		$this->pubfile,
475		$this->certificate->publicKey
476		);
477		$ret &= $this->filesystem->put(
478		$this->certfile,
479		$private."{$this->certificate}"
480		);
481		if (!$ret) {
482		throw new RuntimeException(
483		'Unable to save temporary key files in folder.'
484		);
485		}
486		}
487
488		/**
489		* Delete all files in folder
490		*/
491	4	public function removeTemporarilyFiles()
492		{
493	4	$contents = $this->filesystem->listContents($this->certsdir, true);
494		//define um limite de $waitingTime min, ou seja qualquer arquivo criado a mais
495		//de $waitingTime min será removido
496		//NOTA: quando ocorre algum erro interno na execução do script, alguns
497		//arquivos temporários podem permanecer
498		//NOTA: O tempo default é de 45 minutos e pode ser alterado diretamente nas
499		//propriedades da classe, esse tempo entre 5 a 45 min é recomendável pois
500		//podem haver processos concorrentes para um mesmo usuário. Esses processos
501		//como o DFe podem ser mais longos, dependendo a forma que o aplicativo
502		//utilize a API. Outra solução para remover arquivos "perdidos" pode ser
503		//encontrada oportunamente.
504	4	$dt = new \DateTime();
505	4	$tint = new \DateInterval("PT".$this->waitingTime."M");
506	4	$tint->invert = true;
		0 ignored issues – show Documentation Bug introduced 2017-05-20 20:02 UTC by Report Bug Copy Issue Report The property `$invert` was declared of type `integer`, but `true` is of type `boolean`. Maybe add a type cast? This check looks for assignments to scalar types that may be of the wrong type. To ensure the code behaves as expected, it may be a good idea to add an explicit type cast. $answer = 42; $correct = false; $correct = (bool) $answer; Loading history...
507	4	$tsLimit = $dt->add($tint)->getTimestamp();
508	4	foreach ($contents as $item) {
509		if ($item['type'] == 'file') {
510		if ($item['path'] == $this->prifile
511		\|\| $item['path'] == $this->pubfile
512		\|\| $item['path'] == $this->certfile
513		) {
514		$this->filesystem->delete($item['path']);
515		continue;
516		}
517		$timestamp = $this->filesystem->getTimestamp($item['path']);
518		if ($timestamp < $tsLimit) {
519		//remove arquivos criados a mais de 45 min
520		$this->filesystem->delete($item['path']);
521		}
522		}
523		}
524	4	}
525
526		/**
527		* Save request envelope and response for debug reasons
528		* @param string $operation
529		* @param string $request
530		* @param string $response
531		* @return void
532		*/
533		public function saveDebugFiles($operation, $request, $response)
534		{
535		if (!$this->debugmode) {
536		return;
537		}
538		$this->debugdir = $this->certificate->getCnpj() . '/debug/';
539		$now = \DateTime::createFromFormat('U.u', number_format(microtime(true), 6, '.', ''));
540		$time = substr($now->format("ymdHisu"), 0, 16);
541		try {
542		$this->filesystem->put(
543		$this->debugdir . $time . "_" . $operation . "_sol.txt",
544		$request
545		);
546		$this->filesystem->put(
547		$this->debugdir . $time . "_" . $operation . "_res.txt",
548		$response
549		);
550		} catch (\Exception $e) {
551		throw new RuntimeException(
552		'Unable to create debug files.'
553		);
554		}
555		}
556		}
557

nfephp-org / sped-common

Pull Request — master (#144)

SoapBase::mountEnvelopString() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like