Webservices   A
last analyzed

Complexity

Total Complexity 15

Size/Duplication

Total Lines 117
Duplicated Lines 0 %

Coupling/Cohesion

Components 1
Dependencies 0

Test Coverage

Coverage 0%

Importance

Changes 0
Metric Value
wmc 15
lcom 1
cbo 0
dl 0
loc 117
ccs 0
cts 73
cp 0
rs 10
c 0
b 0
f 0

6 Methods

Rating   Name   Duplication   Size   Complexity  
A __construct() 0 4 1
A get() 0 22 5
A toStd() 0 7 2
A __toString() 0 4 1
A convert() 0 17 4
A extract() 0 19 2
1
<?php
2
3
namespace NFePHP\MDFe\Common;
4
5
/**
6
 * Class to Read and preprocess WS parameters from xml storage
7
 * file to json encode or stdClass
8
 *
9
 * @author    Cleiton Perin <cperin20 at gmail dot com>
10
 * @package   NFePHP\MDFe\Common\Webservices
11
 * @copyright NFePHP Copyright (c) 2008-2019
12
 * @license   http://www.gnu.org/licenses/lgpl.txt LGPLv3+
13
 * @license   https://opensource.org/licenses/MIT MIT
14
 * @license   http://www.gnu.org/licenses/gpl.txt GPLv3+
15
 * @category  NFePHP
16
 * @link      http://github.com/nfephp-org/sped-mdfe for the canonical source repository
17
 */
18
19
use SimpleXMLElement;
20
21
class Webservices
22
{
23
    public $json;
24
    public $std;
25
26
    /**
27
     * Constructor
28
     * @param string $xml path or xml content from
29
     *               nfe_ws3_mod55
30
     */
31
    public function __construct($xml)
32
    {
33
        $this->toStd($xml);
34
    }
35
36
    /**
37
     * Get webservices parameters for specific conditions
38
     * the parameters with the authorizers are in a json file in
39
     * the storage folder
40
     * @param string $sigla
41
     * @param string $ambiente "homologacao" ou "producao"
42
     * @param string $modelo "58"
43
     * @return boolean | \stdClass
44
     */
45
    public function get($sigla, $ambiente, $modelo)
46
    {
47
        $autfile = realpath(__DIR__ . '/../../storage/autorizadores.json');
48
        $autorizadores = json_decode(file_get_contents($autfile), true);
49
        if (!key_exists($sigla, $autorizadores[$modelo])) {
50
            throw new \RuntimeException(
51
                "Não existe o autorizador [$sigla] para os "
52
                . "webservices"
53
            );
54
        }
55
        $auto = $autorizadores[$modelo][$sigla];
56
        if (empty($auto) || empty($this->std)) {
57
            return false;
58
        }
59
        if (empty($this->std->$auto)) {
60
            throw new \RuntimeException(
61
                "Não existem webservices cadastrados para  [$sigla]"
62
            );
63
        }
64
        $svw = $this->std->$auto->$ambiente;
65
        return $svw;
66
    }
67
68
    /**
69
     * Return WS parameters in a stdClass
70
     * @param string $xml
71
     * @return \stdClass
72
     */
73
    public function toStd($xml = '')
74
    {
75
        if (!empty($xml)) {
76
            $this->convert($xml);
77
        }
78
        return $this->std;
79
    }
80
81
    /**
82
     * Return WS parameters in json format
83
     * @return string
84
     */
85
    public function __toString()
86
    {
87
        return (string)$this->json;
88
    }
89
90
    /**
91
     * Read WS xml and convert to json and stdClass
92
     * @param string $xml
93
     */
94
    protected function convert($xml)
95
    {
96
        $resp = simplexml_load_string($xml, null, LIBXML_NOCDATA);
97
        $aWS = [];
98
        foreach ($resp->children() as $element) {
99
            $sigla = (string)$element->sigla;
100
            $aWS[$sigla] = [];
101
            if (isset($element->homologacao)) {
102
                $aWS[$sigla] += $this->extract($element->homologacao, 'homologacao');
103
            }
104
            if (isset($element->producao)) {
105
                $aWS[$sigla] += $this->extract($element->producao, 'producao');
106
            }
107
        }
108
        $this->json = json_encode($aWS);
109
        $this->std = json_decode(json_encode($aWS));
110
    }
111
112
    /**
113
     * Extract data from wbservices XML strorage to a array
114
     * @param SimpleXMLElement $node
115
     * @param string $environment
116
     * @return array
117
     */
118
    protected function extract(SimpleXMLElement $node, $environment)
119
    {
120
        $amb[$environment] = [];
0 ignored issues
show
Coding Style Comprehensibility introduced by icompsoft
$amb was never initialized. Although not strictly required by PHP, it is generally a good practice to add $amb = array(); before regardless.

Adding an explicit array definition is generally preferable to implicit array definition as it guarantees a stable state of the code.

Let’s take a look at an example:

foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}

As you can see in this example, the array $myArray is initialized the first time when the foreach loop is entered. You can also see that the value of the bar key is only written conditionally; thus, its value might result from a previous iteration.

This might or might not be intended. To make your intention clear, your code more readible and to avoid accidental bugs, we recommend to add an explicit initialization $myArray = array() either outside or inside the foreach loop.

Loading history...
121
        foreach ($node->children() as $children) {
122
            $name = (string)$children->getName();
123
            $method = (string)$children['method'];
124
            $operation = (string)$children['operation'];
125
            $version = (string)$children['version'];
126
            $url = (string)$children[0];
127
            $operations = [
128
                'method' => $method,
129
                'operation' => $operation,
130
                'version' => $version,
131
                'url' => $url
132
            ];
133
            $amb[$environment][$name] = $operations;
134
        }
135
        return $amb;
136
    }
137
}
138