SoapBase::setTemporaryFolder() - Code Metrics - Inspection of "Merge pull request #152 from felipefill/fix-soap-c..." - nfephp-org/sped-common - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 6e678e...73971d )

by Roberto

created 2017-12-21 10:42 UTC

SoapBase::setTemporaryFolder() A

↳ Parent: SoapBase

Complexity

Conditions	3
Paths	4

Size

Total Lines	13
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	3.1406

Importance

Changes

Metric	Value
dl	0
loc	13
ccs	6
cts	8
cp	0.75
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	7
nc	4
nop	1
crap	3.1406

<?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|null
     */
    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
     * @param LoggerInterface|null $logger
     */
    public function __construct(
        Certificate $certificate = null,
        LoggerInterface $logger = null
    ) {
        $this->logger = $logger;
        $this->loadCertificate($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 void
     * @throws Certificate\Exception\Expired
     */
    private function isCertificateExpired(Certificate $certificate = null)
    {
        if (! $this->disableCertValidation) {
            if (null !== $certificate && $certificate->isExpired()) {
                throw new Certificate\Exception\Expired($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)
    {
        if (null !== $this->filesystem) {
            $this->removeTemporarilyFiles();
        }

        $this->tempdir = $folderRealPath;
        $this->setLocalFolder($folderRealPath);

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

    /**
     * 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 = null)
    {
        $this->isCertificateExpired($certificate);
        if (null !== $certificate) {
            $this->certificate = $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($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 int $soapVer
     * @param \SoapHeader $header
     * @return string
     */
    protected function makeEnvelopeSoap(
        $request,
        $namespaces,
        $soapVer = SOAP_1_2,
        $header = null
    ) {
        $prefix = $this->prefixes[$soapVer];

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

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

    /**
     * Create a envelop string
     * @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:Envelope>',
            $envelopPrefix,
            $envelopAttributes,
            $envelopPrefix,
            $bodyContent,
            $envelopPrefix,
            $envelopPrefix
        );
    }

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

            $headerItems = '<'.$key.'>'.$value.'<'.$key.'>';
        }
        return sprintf(
            '<%s:Header><%s xmlns="%s">%s</%s></%s:Header>',
            $envelopPrefix,
            $header->name,

            $header->ns === null ? '' : $header->ns,

            $headerItems,
            $header->name,
            $envelopPrefix
        );
    }

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


    /**
     * Temporarily saves the certificate keys for use cURL or SoapClient
     * @return void
     */
    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
     * @return void
     */
    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 = 1;
        $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\|null
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
149		* @param LoggerInterface\|null $logger
150		*/
151	5	public function __construct(
152		Certificate $certificate = null,
153		LoggerInterface $logger = null
154		) {
155	5	$this->logger = $logger;
156	5	$this->loadCertificate($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 void
168		* @throws Certificate\Exception\Expired
169		*/
170	5	private function isCertificateExpired(Certificate $certificate = null)
171		{
172	5	if (! $this->disableCertValidation) {
173	5	if (null !== $certificate && $certificate->isExpired()) {
174	1	throw new Certificate\Exception\Expired($certificate);
175		}
176		}
177	4	}
178
179		/**
180		* Destructor
181		* Clean temporary files
182		*/
183	4	public function __destruct()
184		{
185	4	$this->removeTemporarilyFiles();
186	4	}
187
188		/**
189		* Disables the security checking of host and peer certificates
190		* @param bool $flag
191		* @return bool
192		*/
193	1	public function disableSecurity($flag = false)
194		{
195	1	return $this->disablesec = $flag;
196		}
197
198		/**
199		* ONlY for tests
200		* @param bool $flag
201		* @return bool
202		*/
203	1	public function disableCertValidation($flag = true)
204		{
205	1	return $this->disableCertValidation = $flag;
206		}
207
208		/**
209		* Load path to CA and enable to use on SOAP
210		* @param string $capath
211		* @return void
212		*/
213		public function loadCA($capath)
214		{
215		if (is_file($capath)) {
216		$this->casefaz = $capath;
217		}
218		}
219
220		/**
221		* Set option to encrypt private key before save in filesystem
222		* for an additional layer of protection
223		* @param bool $encript
224		* @return bool
225		*/
226		public function setEncriptPrivateKey($encript = true)
227		{
228		return $this->encriptPrivateKey = $encript;
229		}
230
231		/**
232		* Set another temporayfolder for saving certificates for SOAP utilization
233		* @param string $folderRealPath
234		* @return void
235		*/
236	4	public function setTemporaryFolder($folderRealPath)
237		{
238	4	if (null !== $this->filesystem) {
239		$this->removeTemporarilyFiles();
240		}
241
242	4	$this->tempdir = $folderRealPath;
243	4	$this->setLocalFolder($folderRealPath);
244
245	4	if (null !== $this->certificate) {
246		$this->saveTemporarilyKeyFiles();
247		}
248	4	}
249
250		/**
251		* Set Local folder for flysystem
252		* @param string $folder
253		*/
254	4	protected function setLocalFolder($folder = '')
255		{
256	4	$this->adapter = new Local($folder);
257	4	$this->filesystem = new Filesystem($this->adapter);
258	4	}
259
260		/**
261		* Set debug mode, this mode will save soap envelopes in temporary directory
262		* @param bool $value
263		* @return bool
264		*/
265		public function setDebugMode($value = false)
266		{
267		return $this->debugmode = $value;
268		}
269
270		/**
271		* Set certificate class for SSL communications
272		* @param Certificate $certificate
273		* @return void
274		*/
275	5	public function loadCertificate(Certificate $certificate = null)
276		{
277	5	$this->isCertificateExpired($certificate);
278	4	if (null !== $certificate) {
279	1	$this->certificate = $certificate;
280		}
281	4	}
282
283		/**
284		* Set logger class
285		* @param LoggerInterface $logger
286		* @return LoggerInterface
287		*/
288		public function loadLogger(LoggerInterface $logger)
289		{
290		return $this->logger = $logger;
291		}
292
293		/**
294		* Set timeout for communication
295		* @param int $timesecs
296		* @return int
297		*/
298		public function timeout($timesecs)
299		{
300		return $this->soaptimeout = $timesecs;
301		}
302
303		/**
304		* Set security protocol
305		* @param int $protocol
306		* @return int
307		*/
308		public function protocol($protocol = self::SSL_DEFAULT)
309		{
310		return $this->soapprotocol = $protocol;
311		}
312
313		/**
314		* Set prefixes
315		* @param array $prefixes
316		* @return string[]
317		*/
318		public function setSoapPrefix($prefixes = [])
319		{
320		return $this->prefixes = $prefixes;
321		}
322
323		/**
324		* Set proxy parameters
325		* @param string $ip
326		* @param int $port
327		* @param string $user
328		* @param string $password
329		* @return void
330		*/
331		public function proxy($ip, $port, $user, $password)
332		{
333		$this->proxyIP = $ip;
334		$this->proxyPort = $port;
335		$this->proxyUser = $user;
336		$this->proxyPass = $password;
337		}
338
339		/**
340		* @param string $url
341		* @param string $operation
342		* @param string $action
343		* @param int $soapver
344		* @param array $parameters
345		* @param array $namespaces
346		* @param string $request
347		* @param null $soapheader
348		* @return mixed
349		*/
350		abstract public function send(
351		$url,
352		$operation = '',
353		$action = '',
354		$soapver = SOAP_1_2,
355		$parameters = [],
356		$namespaces = [],
357		$request = '',
358		$soapheader = null
359		);
360
361		/**
362		* Mount soap envelope
363		* @param string $request
364		* @param array $namespaces
365		* @param int $soapVer
366		* @param \SoapHeader $header
367		* @return string
368		*/
369		protected function makeEnvelopeSoap(
370		$request,
371		$namespaces,
372		$soapVer = SOAP_1_2,
373		$header = null
374		) {
375		$prefix = $this->prefixes[$soapVer];
376
377		$envelopeAttributes = $this->getStringAttributes($namespaces);
378
379		return $this->mountEnvelopString(
380		$prefix,
381		$envelopeAttributes,
382		$this->mountSoapHeaders($prefix, $header),
383		$request
384		);
385		}
386
387		/**
388		* Create a envelop string
389		* @param string $envelopPrefix
390		* @param string $envelopAttributes
391		* @param string $header
392		* @param string $bodyContent
393		* @return string
394		*/
395		private function mountEnvelopString(
396		$envelopPrefix,
397		$envelopAttributes = '',
398		$header = '',
399		$bodyContent = ''
400		) {
401		return sprintf(
402		'<%s:Envelope %s>'.$header.'<%s:Body>%s</%s:Body></%s:Envelope>',
403		$envelopPrefix,
404		$envelopAttributes,
405		$envelopPrefix,
406		$bodyContent,
407		$envelopPrefix,
408		$envelopPrefix
409		);
410		}
411
412		/**
413		* Create a haeader tag
414		* @param string $envelopPrefix
415		* @param \SoapHeader $header
416		* @return string
417		*/
418		private function mountSoapHeaders($envelopPrefix, $header = null)
419		{
420		if (null === $header) {
421		return '';
422		}
423		$headerItems = '';
424		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...
425		$headerItems = '<'.$key.'>'.$value.'<'.$key.'>';
426		}
427		return sprintf(
428		'<%s:Header><%s xmlns="%s">%s</%s></%s:Header>',
429		$envelopPrefix,
430		$header->name,
		0 ignored issues – show Bug introduced 2017-12-04 15:54 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...
431		$header->ns === null ? '' : $header->ns,
		0 ignored issues – show Bug introduced 2017-12-04 15:54 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...
432		$headerItems,
433		$header->name,
434		$envelopPrefix
435		);
436		}
437
438		/**
439		* Get attributes
440		* @param array $namespaces
441		* @return string
442		*/
443		private function getStringAttributes($namespaces = [])
444		{
445		$envelopeAttributes = '';
446		foreach ($namespaces as $key => $value) {
447		$envelopeAttributes = $key.'="'.$value.'"';
448		}
449		return $envelopeAttributes;
450		}
451
452
453		/**
454		* Temporarily saves the certificate keys for use cURL or SoapClient
455		* @return void
456		*/
457		public function saveTemporarilyKeyFiles()
458		{
459		if (!is_object($this->certificate)) {
460		throw new RuntimeException(
461		'Certificate not found.'
462		);
463		}
464		$this->certsdir = $this->certificate->getCnpj() . '/certs/';
465		$this->prifile = $this->certsdir. Strings::randomString(10).'.pem';
466		$this->pubfile = $this->certsdir . Strings::randomString(10).'.pem';
467		$this->certfile = $this->certsdir . Strings::randomString(10).'.pem';
468		$ret = true;
469		$private = $this->certificate->privateKey;
470		if ($this->encriptPrivateKey) {
471		//cria uma senha temporária ALEATÓRIA para salvar a chave primaria
472		//portanto mesmo que localizada e identificada não estará acessível
473		//pois sua senha não existe além do tempo de execução desta classe
474		$this->temppass = Strings::randomString(16);
475		//encripta a chave privada entes da gravação do filesystem
476		openssl_pkey_export(
477		$this->certificate->privateKey,
478		$private,
479		$this->temppass
480		);
481		}
482		$ret &= $this->filesystem->put(
483		$this->prifile,
484		$private
485		);
486		$ret &= $this->filesystem->put(
487		$this->pubfile,
488		$this->certificate->publicKey
489		);
490		$ret &= $this->filesystem->put(
491		$this->certfile,
492		$private."{$this->certificate}"
493		);
494		if (!$ret) {
495		throw new RuntimeException(
496		'Unable to save temporary key files in folder.'
497		);
498		}
499		}
500
501		/**
502		* Delete all files in folder
503		* @return void
504		*/
505	4	public function removeTemporarilyFiles()
506		{
507	4	$contents = $this->filesystem->listContents($this->certsdir, true);
508		//define um limite de $waitingTime min, ou seja qualquer arquivo criado a mais
509		//de $waitingTime min será removido
510		//NOTA: quando ocorre algum erro interno na execução do script, alguns
511		//arquivos temporários podem permanecer
512		//NOTA: O tempo default é de 45 minutos e pode ser alterado diretamente nas
513		//propriedades da classe, esse tempo entre 5 a 45 min é recomendável pois
514		//podem haver processos concorrentes para um mesmo usuário. Esses processos
515		//como o DFe podem ser mais longos, dependendo a forma que o aplicativo
516		//utilize a API. Outra solução para remover arquivos "perdidos" pode ser
517		//encontrada oportunamente.
518	4	$dt = new \DateTime();
519	4	$tint = new \DateInterval("PT".$this->waitingTime."M");
520	4	$tint->invert = 1;
521	4	$tsLimit = $dt->add($tint)->getTimestamp();
522	4	foreach ($contents as $item) {
523		if ($item['type'] == 'file') {
524		if ($item['path'] == $this->prifile
525		\|\| $item['path'] == $this->pubfile
526		\|\| $item['path'] == $this->certfile
527		) {
528		$this->filesystem->delete($item['path']);
529		continue;
530		}
531		$timestamp = $this->filesystem->getTimestamp($item['path']);
532		if ($timestamp < $tsLimit) {
533		//remove arquivos criados a mais de 45 min
534		$this->filesystem->delete($item['path']);
535		}
536		}
537		}
538	4	}
539
540		/**
541		* Save request envelope and response for debug reasons
542		* @param string $operation
543		* @param string $request
544		* @param string $response
545		* @return void
546		*/
547		public function saveDebugFiles($operation, $request, $response)
548		{
549		if (!$this->debugmode) {
550		return;
551		}
552		$this->debugdir = $this->certificate->getCnpj() . '/debug/';
553		$now = \DateTime::createFromFormat('U.u', number_format(microtime(true), 6, '.', ''));
554		$time = substr($now->format("ymdHisu"), 0, 16);
555		try {
556		$this->filesystem->put(
557		$this->debugdir . $time . "_" . $operation . "_sol.txt",
558		$request
559		);
560		$this->filesystem->put(
561		$this->debugdir . $time . "_" . $operation . "_res.txt",
562		$response
563		);
564		} catch (\Exception $e) {
565		throw new RuntimeException(
566		'Unable to create debug files.'
567		);
568		}
569		}
570		}
571

nfephp-org / sped-common

Push — master ( 6e678e...73971d )

SoapBase::setTemporaryFolder() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like