Service - Code Metrics - Inspection of "Cleaning params when init a curl request" - psfs/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 4b846c...33d274 )

by Fran

created 2017-09-28 21:36 UTC

Service B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	369
Duplicated Lines	6.78 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

11.81%

Importance

Changes

Metric	Value
dl	25
loc	369
ccs	17
cts	144
cp	0.1181
rs	8.439
c	0
b	0
f	0
wmc	47
lcom	1
cbo	4

30 Methods

Rating	Name	Duplication	Size	Complexity
A	closeConnection()	0	5	2
A	__destruct()	0	4	1
A	getUrl()	0	4	1
A	setUrl()	0	5	1
A	getResult()	0	4	1
A	setResult()	0	4	1
A	getParams()	0	4	1
A	addParam()	0	6	1
A	getOptions()	0	4	1
A	addOption()	0	6	1
A	setParams()	0	4	1
A	getHeaders()	0	4	1
A	setHeaders()	0	4	1
A	addHeader()	0	6	1
A	getType()	0	4	1
A	setType()	0	4	1
A	getLog()	0	4	1
A	setLog()	0	4	1
A	setIsJson()	0	3	1
A	getIsJson()	0	3	1
A	clearContext()	0	8	1
A	init()	0	5	1
A	initialize()	0	6	1
A	addRequestToken()	0	4	1
A	addAuthHeader()	0	4	1
A	applyOptions()	0	5	2
A	applyHeaders()	0	9	3
C	setDefaults()	25	46	11
B	callSrv()	0	24	4
A	getCallInfo()	0	3	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Service often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Service, and based on these observations, apply Extract Interface, too.

<?php
namespace PSFS\base;

use PSFS\base\config\Config;
use PSFS\base\types\helpers\SecurityHelper;

/**
 * Class Service
 * @package PSFS\base
 */
class Service extends Singleton
{
    /**
     * @var String Url de destino de la llamada
     */
    private $url;
    /**
     * @var array Parámetros de la llamada
     */
    private $params;
    /**
     * @var array Opciones llamada
     */
    private $options;
    /**
     * @var array Cabeceras de la llamada
     */
    private $headers;
    /**
     * @var string type
     */
    private $type;
    /**
     * @var resource $con
     */
    private $con;
    /**
     * @var string $result
     */
    private $result;
    /**
     * @var mixed
     */
    private $info;

    /**
     * @Injectable
     * @var \PSFS\base\Logger Log de las llamadas
     */
    protected $log;
    /**
     * @Injectable
     * @var \PSFS\base\Cache $cache
     */
    protected $cache;
    /**
     * @var bool
     */
    protected $isJson = true;

    private function closeConnection() {
        if(null !== $this->con) {
            curl_close($this->con);
        }
    }

    public function __destruct()
    {
        $this->closeConnection();
    }

    /**
     * @return String
     */
    public function getUrl()
    {
        return $this->url;
    }

    /**
     * @param String $url
     */
    public function setUrl($url)
    {
        $this->url = $url;
        $this->initialize();
    }

    /**
     * @return string
     */
    public function getResult()
    {
        return $this->result;
    }

    /**
     * @param string $result
     */
    public function setResult($result)
    {
        $this->result = $result;
    }

    /**
     * @return array
     */
    public function getParams()
    {
        return $this->params;
    }

    /**
     * Add request param
     *
     * @param $key
     * @param null $value
     *
     * @return \PSFS\base\Service
     */
    public function addParam($key, $value = NULL)
    {
        $this->params[$key] = $value;

        return $this;
    }

    /**
     * @return array
     */
    public function getOptions()
    {
        return $this->options;
    }

    /**
     * Add request param
     *
     * @param $key
     * @param null $value
     *
     * @return \PSFS\base\Service
     */
    public function addOption($key, $value = NULL)
    {
        $this->options[$key] = $value;

        return $this;
    }

    /**
     * @param array $params
     */
    public function setParams($params)
    {
        $this->params = $params;
    }

    /**
     * @return array
     */
    public function getHeaders()
    {
        return $this->headers;
    }

    /**
     * @param array $headers
     */
    public function setHeaders($headers)
    {
        $this->headers = $headers;
    }

    /**
     * @param $header
     * @param null $content
     *
     * @return $this
     */
    public function addHeader($header, $content = NULL)
    {
        $this->headers[$header] = $content;

        return $this;
    }

    /**
     * @return string
     */
    public function getType()
    {
        return $this->type;
    }

    /**
     * @param string $type
     */
    public function setType($type)
    {
        $this->type = $type;
    }

    /**
     * @return Logger
     */
    public function getLog()
    {
        return $this->log;
    }

    /**
     * @param Logger $log
     */
    public function setLog($log)
    {
        $this->log = $log;
    }

    /**
     * @param bool $isJson
     */
    public function setIsJson($isJson = true) {
        $this->isJson = $isJson;
    }

    /**
     * @return bool
     */
    public function getIsJson() {
        return $this->isJson;
    }

    /**
     * Método que limpia el contexto de la llamada
     */
    private function clearContext()
    {
        $this->url = NULL;
        $this->params = array();
        $this->headers = array();
        Logger::log("Context service for " . get_called_class() . " cleared!");
        $this->closeConnection();
    }

    /**
     *
     */
    public function init()
    {
        parent::init();
        $this->clearContext();
    }

    /**
     * Initialize CURL
     */
    private function initialize()
    {
        $this->closeConnection();
        $this->params = [];
        $this->con = curl_init($this->url);
    }

    /**
     * Generate auth header
     * @param string $secret
     * @param string $module
     */
    protected function addRequestToken($secret, $module = 'PSFS')
    {
        $this->addHeader('X-PSFS-SEC-TOKEN', SecurityHelper::generateToken($secret, $module));
    }

    /**
     * @param $user
     * @param $pass
     */
    protected function addAuthHeader($user, $pass) {
        $this->addOption(CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
        $this->addOption(CURLOPT_USERPWD, "$user:$pass");
    }

    protected function applyOptions() {
        if(count($this->options)) {
            curl_setopt_array($this->con, $this->options);
        }
    }

    protected function applyHeaders() {
        $headers = [];
        foreach($this->headers as $key => $value) {
            $headers[] = $key . ': ' . $value;
        }
        if(count($headers)) {
            curl_setopt($this->con, CURLOPT_HTTPHEADER, $headers);
        }
    }

    protected function setDefaults()
    {
        switch (strtoupper($this->type)) {
            case 'GET':
            default:
                $this->addOption(CURLOPT_CUSTOMREQUEST, "GET");
                if(!empty($this->params)) {
                    $sep = !preg_match('/\?/', $this->getUrl()) ? '?' : '';
                    $this->url = $this->url . $sep . http_build_query($this->params);
                }
                break;
            case 'POST':
                $this->addOption(CURLOPT_CUSTOMREQUEST, "POST");
                if($this->getIsJson()) {
                    $this->addOption(CURLOPT_POSTFIELDS, json_encode($this->params));
                } else {
                    $this->addOption(CURLOPT_POSTFIELDS, http_build_query($this->params));
                }
                break;
            case 'DELETE':
                $this->addOption(CURLOPT_CUSTOMREQUEST, "DELETE");
                break;
            case 'PUT':
                $this->addOption(CURLOPT_CUSTOMREQUEST, "PUT");

                if($this->getIsJson()) {
                    $this->addOption(CURLOPT_POSTFIELDS, json_encode($this->params));
                } else {
                    $this->addOption(CURLOPT_POSTFIELDS, http_build_query($this->params));
                }
                break;
            case 'PATCH':
                $this->addOption(CURLOPT_CUSTOMREQUEST, "PATCH");
                if($this->getIsJson()) {
                    $this->addOption(CURLOPT_POSTFIELDS, json_encode($this->params));
                } else {
                    $this->addOption(CURLOPT_POSTFIELDS, http_build_query($this->params));
                }
                break;
        }

        $this->addOption(CURLOPT_RETURNTRANSFER, true);
        $this->addOption(CURLOPT_FOLLOWLOCATION, true);
        $this->addOption(CURLOPT_SSL_VERIFYHOST, false);
        $this->addOption(CURLOPT_SSL_VERIFYPEER, false);
    }

    public function callSrv()
    {
        $this->setDefaults();
        $this->applyOptions();
        $this->applyHeaders();
        if('debug' === Config::getParam('log.level')) {
            curl_setopt($this->con, CURLOPT_VERBOSE, true);
            $verbose = fopen('php://temp', 'w+');
            curl_setopt($this->con, CURLOPT_STDERR, $verbose);
        }
        $result = curl_exec($this->con);
        $this->result = $this->isJson ? json_decode($result, true) : $result;
        if('debug' === Config::getParam('log.level')) {
            rewind($verbose);
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
            $verboseLog = stream_get_contents($verbose);
            Logger::log($verboseLog, LOG_DEBUG, [
                'headers' => $this->getHeaders(),
                'options' => $this->getOptions(),
                'url' => $this->getUrl(),
            ]);
        }
        Logger::log($this->url . ' response: ', LOG_DEBUG, $this->result);
        $this->info = curl_getinfo($this->con);
    }

    /**
     * @return mixed
     */
    public function getCallInfo() {
        return $this->info;
    }

}


1			<?php
2			namespace PSFS\base;
3
4			use PSFS\base\config\Config;
5			use PSFS\base\types\helpers\SecurityHelper;
6
7			/**
8			* Class Service
9			* @package PSFS\base
10			*/
11			class Service extends Singleton
12			{
13			/**
14			* @var String Url de destino de la llamada
15			*/
16			private $url;
17			/**
18			* @var array Parámetros de la llamada
19			*/
20			private $params;
21			/**
22			* @var array Opciones llamada
23			*/
24			private $options;
25			/**
26			* @var array Cabeceras de la llamada
27			*/
28			private $headers;
29			/**
30			* @var string type
31			*/
32			private $type;
33			/**
34			* @var resource $con
35			*/
36			private $con;
37			/**
38			* @var string $result
39			*/
40			private $result;
41			/**
42			* @var mixed
43			*/
44			private $info;
45
46			/**
47			* @Injectable
48			* @var \PSFS\base\Logger Log de las llamadas
49			*/
50			protected $log;
51			/**
52			* @Injectable
53			* @var \PSFS\base\Cache $cache
54			*/
55			protected $cache;
56			/**
57			* @var bool
58			*/
59			protected $isJson = true;
60
61	1		private function closeConnection() {
62	1		if(null !== $this->con) {
63			curl_close($this->con);
64			}
65	1		}
66
67			public function __destruct()
68			{
69			$this->closeConnection();
70			}
71
72			/**
73			* @return String
74			*/
75			public function getUrl()
76			{
77			return $this->url;
78			}
79
80			/**
81			* @param String $url
82			*/
83			public function setUrl($url)
84			{
85			$this->url = $url;
86			$this->initialize();
87			}
88
89			/**
90			* @return string
91			*/
92			public function getResult()
93			{
94			return $this->result;
95			}
96
97			/**
98			* @param string $result
99			*/
100			public function setResult($result)
101			{
102			$this->result = $result;
103			}
104
105			/**
106			* @return array
107			*/
108			public function getParams()
109			{
110			return $this->params;
111			}
112
113			/**
114			* Add request param
115			*
116			* @param $key
117			* @param null $value
118			*
119			* @return \PSFS\base\Service
120			*/
121			public function addParam($key, $value = NULL)
122			{
123			$this->params[$key] = $value;
124
125			return $this;
126			}
127
128			/**
129			* @return array
130			*/
131			public function getOptions()
132			{
133			return $this->options;
134			}
135
136			/**
137			* Add request param
138			*
139			* @param $key
140			* @param null $value
141			*
142			* @return \PSFS\base\Service
143			*/
144			public function addOption($key, $value = NULL)
145			{
146			$this->options[$key] = $value;
147
148			return $this;
149			}
150
151			/**
152			* @param array $params
153			*/
154			public function setParams($params)
155			{
156			$this->params = $params;
157			}
158
159			/**
160			* @return array
161			*/
162			public function getHeaders()
163			{
164			return $this->headers;
165			}
166
167			/**
168			* @param array $headers
169			*/
170			public function setHeaders($headers)
171			{
172			$this->headers = $headers;
173			}
174
175			/**
176			* @param $header
177			* @param null $content
178			*
179			* @return $this
180			*/
181			public function addHeader($header, $content = NULL)
182			{
183			$this->headers[$header] = $content;
184
185			return $this;
186			}
187
188			/**
189			* @return string
190			*/
191			public function getType()
192			{
193			return $this->type;
194			}
195
196			/**
197			* @param string $type
198			*/
199			public function setType($type)
200			{
201			$this->type = $type;
202			}
203
204			/**
205			* @return Logger
206			*/
207			public function getLog()
208			{
209			return $this->log;
210			}
211
212			/**
213			* @param Logger $log
214			*/
215	1		public function setLog($log)
216			{
217	1		$this->log = $log;
218	1		}
219
220			/**
221			* @param bool $isJson
222			*/
223			public function setIsJson($isJson = true) {
224			$this->isJson = $isJson;
225			}
226
227			/**
228			* @return bool
229			*/
230			public function getIsJson() {
231			return $this->isJson;
232			}
233
234			/**
235			* Método que limpia el contexto de la llamada
236			*/
237	1		private function clearContext()
238			{
239	1		$this->url = NULL;
240	1		$this->params = array();
241	1		$this->headers = array();
242	1		Logger::log("Context service for " . get_called_class() . " cleared!");
243	1		$this->closeConnection();
244	1		}
245
246			/**
247			*
248			*/
249	1		public function init()
250			{
251	1		parent::init();
252	1		$this->clearContext();
253	1		}
254
255			/**
256			* Initialize CURL
257			*/
258			private function initialize()
259			{
260			$this->closeConnection();
261			$this->params = [];
262			$this->con = curl_init($this->url);
263			}
264
265			/**
266			* Generate auth header
267			* @param string $secret
268			* @param string $module
269			*/
270			protected function addRequestToken($secret, $module = 'PSFS')
271			{
272			$this->addHeader('X-PSFS-SEC-TOKEN', SecurityHelper::generateToken($secret, $module));
273			}
274
275			/**
276			* @param $user
277			* @param $pass
278			*/
279			protected function addAuthHeader($user, $pass) {
280			$this->addOption(CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
281			$this->addOption(CURLOPT_USERPWD, "$user:$pass");
282			}
283
284			protected function applyOptions() {
285			if(count($this->options)) {
286			curl_setopt_array($this->con, $this->options);
287			}
288			}
289
290			protected function applyHeaders() {
291			$headers = [];
292			foreach($this->headers as $key => $value) {
293			$headers[] = $key . ': ' . $value;
294			}
295			if(count($headers)) {
296			curl_setopt($this->con, CURLOPT_HTTPHEADER, $headers);
297			}
298			}
299
300			protected function setDefaults()
301			{
302			switch (strtoupper($this->type)) {
303			case 'GET':
304			default:
305			$this->addOption(CURLOPT_CUSTOMREQUEST, "GET");
306			if(!empty($this->params)) {
307			$sep = !preg_match('/\?/', $this->getUrl()) ? '?' : '';
308			$this->url = $this->url . $sep . http_build_query($this->params);
309			}
310			break;
311		View Code Duplication	case 'POST':
312			$this->addOption(CURLOPT_CUSTOMREQUEST, "POST");
313			if($this->getIsJson()) {
314			$this->addOption(CURLOPT_POSTFIELDS, json_encode($this->params));
315			} else {
316			$this->addOption(CURLOPT_POSTFIELDS, http_build_query($this->params));
317			}
318			break;
319			case 'DELETE':
320			$this->addOption(CURLOPT_CUSTOMREQUEST, "DELETE");
321			break;
322		View Code Duplication	case 'PUT':
323			$this->addOption(CURLOPT_CUSTOMREQUEST, "PUT");
324
325			if($this->getIsJson()) {
326			$this->addOption(CURLOPT_POSTFIELDS, json_encode($this->params));
327			} else {
328			$this->addOption(CURLOPT_POSTFIELDS, http_build_query($this->params));
329			}
330			break;
331		View Code Duplication	case 'PATCH':
332			$this->addOption(CURLOPT_CUSTOMREQUEST, "PATCH");
333			if($this->getIsJson()) {
334			$this->addOption(CURLOPT_POSTFIELDS, json_encode($this->params));
335			} else {
336			$this->addOption(CURLOPT_POSTFIELDS, http_build_query($this->params));
337			}
338			break;
339			}
340
341			$this->addOption(CURLOPT_RETURNTRANSFER, true);
342			$this->addOption(CURLOPT_FOLLOWLOCATION, true);
343			$this->addOption(CURLOPT_SSL_VERIFYHOST, false);
344			$this->addOption(CURLOPT_SSL_VERIFYPEER, false);
345			}
346
347			public function callSrv()
348			{
349			$this->setDefaults();
350			$this->applyOptions();
351			$this->applyHeaders();
352			if('debug' === Config::getParam('log.level')) {
353			curl_setopt($this->con, CURLOPT_VERBOSE, true);
354			$verbose = fopen('php://temp', 'w+');
355			curl_setopt($this->con, CURLOPT_STDERR, $verbose);
356			}
357			$result = curl_exec($this->con);
358			$this->result = $this->isJson ? json_decode($result, true) : $result;
359			if('debug' === Config::getParam('log.level')) {
360			rewind($verbose);
			0 ignored issues – show Bug introduced 2017-07-26 09:45 UTC by Report Bug Copy Issue Report The variable `$verbose` does not seem to be defined for all execution paths leading up to this point. If you define a variable conditionally, it can happen that it is not defined for all execution paths. Let’s take a look at an example: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } // $x is potentially undefined here. echo $x; } In the above example, the variable `$x` is defined if you pass “foo” or “bar” as argument for `$a`. However, since the `switch` statement has no default case statement, if you pass any other value, the variable `$x` would be undefined. Available Fixes Check for existence of the variable explicitly: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } if (isset($x)) { // Make sure it's always set. echo $x; } } Define a default value for the variable: function myFunction($a) { $x = ''; // Set a default which gets overridden for certain paths. switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } echo $x; } Add a value for the missing path: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; // We add support for the missing case. default: $x = ''; break; } echo $x; } Loading history...
361			$verboseLog = stream_get_contents($verbose);
362			Logger::log($verboseLog, LOG_DEBUG, [
363			'headers' => $this->getHeaders(),
364			'options' => $this->getOptions(),
365			'url' => $this->getUrl(),
366			]);
367			}
368			Logger::log($this->url . ' response: ', LOG_DEBUG, $this->result);
369			$this->info = curl_getinfo($this->con);
370			}
371
372			/**
373			* @return mixed
374			*/
375			public function getCallInfo() {
376			return $this->info;
377			}
378
379			}
380

psfs / core