Http::parseJSON() - Code Metrics - Inspection of "Merge pull request #271 from overtrue/develop" - overtrue/wechat - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c7d4dc...13d232 )

by Carlos

created 2016-01-27 15:02 UTC

Http::parseJSON() B

↳ Parent: Http

Complexity

Conditions	4
Paths	6

Size

Total Lines	23
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	12
CRAP Score	4

Importance

Changes	3
Bugs	1	Features	0

Metric	Value
c	3
b	1
f	0
dl	0
loc	23
ccs	12
cts	12
cp	1
rs	8.7972
cc	4
eloc	11
nc	6
nop	1
crap	4

<?php

/*
 * This file is part of the overtrue/wechat.
 *
 * (c) overtrue <[email protected]>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

/**
 * Http.php.
 *
 * This file is part of the wechat-components.
 *
 * (c) overtrue <[email protected]>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */
namespace EasyWeChat\Core;

use EasyWeChat\Core\Exceptions\HttpException;
use EasyWeChat\Support\Log;
use GuzzleHttp\Client as HttpClient;
use GuzzleHttp\HandlerStack;
use Psr\Http\Message\ResponseInterface;

/**
 * Class Http.
 */
class Http
{
    /**
     * Http client.
     *
     * @var HttpClient
     */
    protected $client;

    /**
     * The middlewares.
     *
     * @var array
     */
    protected $middlewares = [];

    /**
     * GET request.
     *
     * @param string $url
     * @param array  $options
     *
     * @return array|bool
     *
     * @throws HttpException
     */
    public function get($url, array $options = [])
    {
        return $this->request($url, 'GET', ['query' => $options]);
    }

    /**
     * POST request.
     *
     * @param string       $url
     * @param array|string $options
     *
     * @return array|bool
     *
     * @throws HttpException
     */
    public function post($url, $options = [])
    {
        $key = is_array($options) ? 'form_params' : 'body';

        return $this->request($url, 'POST', [$key => $options]);
    }

    /**
     * JSON request.
     *
     * @param string       $url
     * @param string|array $options
     * @param int          $encodeOption
     *
     * @return array|bool
     *
     * @throws HttpException
     */
    public function json($url, $options = [], $encodeOption = JSON_UNESCAPED_UNICODE)
    {
        is_array($options) && $options = json_encode($options, $encodeOption);

        return $this->request($url, 'POST', ['body' => $options, 'headers' => ['content-type' => 'application/json']]);
    }

    /**
     * Upload file.
     *
     * @param string $url
     * @param array  $files
     * @param array  $form
     *
     * @return array|bool
     *
     * @throws HttpException
     */
    public function upload($url, array $files = [], array $form = [], array $queries = [])
    {
        $multipart = [];

        foreach ($files as $name => $path) {
            $multipart[] = [
                'name' => $name,
                'contents' => fopen($path, 'r'),
            ];
        }

        foreach ($form as $name => $contents) {
            $multipart[] = compact('name', 'contents');
        }

        return $this->request($url, 'POST', ['query' => $queries, 'multipart' => $multipart]);
    }

    /**
     * Set GuzzleHttp\Client.
     *
     * @param \GuzzleHttp\Client $client
     *
     * @return Http
     */
    public function setClient(HttpClient $client)
    {
        $this->client = $client;

        return $this;
    }

    /**
     * Return GuzzleHttp\Client instance.
     *
     * @return \GuzzleHttp\Client.
     */
    public function getClient()
    {
        if (!($this->client instanceof HttpClient)) {
            $this->client = new HttpClient();
        }

        return $this->client;
    }

    /**
     * Add a middleware.
     *
     * @param callable $middleware
     *
     * @return $this
     */
    public function addMiddleware(callable $middleware)
    {
        array_push($this->middlewares, $middleware);

        return $this;
    }

    /**
     * Return all middlewares.
     *
     * @return array
     */
    public function getMiddlewares()
    {
        return $this->middlewares;
    }

    /**
     * Make a request.
     *
     * @param string $url
     * @param string $method
     * @param array  $options
     *
     * @return array|bool
     *
     * @throws HttpException
     */
    public function request($url, $method = 'GET', $options = [])
    {
        $method = strtoupper($method);

        Log::debug('Client Request:', compact('url', 'method', 'options'));

        $options['handler'] = $this->getHandler();

        $response = $this->getClient()->request($method, $url, $options);

        Log::debug('API response:', [
            'Status' => $response->getStatusCode(),
            'Reason' => $response->getReasonPhrase(),
            'Headers' => $response->getHeaders(),
            'Body' => strval($response->getBody()),
        ]);

        return $response;
    }

    /**
     * @param \Psr\Http\Message\ResponseInterface|string $body
     *
     * @return mixed
     *
     * @throws \EasyWeChat\Core\Exceptions\HttpException
     */
    public function parseJSON($body)
    {
        if ($body instanceof ResponseInterface) {
            $body = $body->getBody();
        }

        // XXX: json maybe contains special chars. So, let's FUCK the WeChat API developers ...
        $body = $this->fuckTheWeChatInvalidJSON($body);

        if (empty($body)) {
            return false;
        }

        $contents = json_decode($body, true);

        Log::debug('API response decoded:', compact('contents'));

        if (JSON_ERROR_NONE !== json_last_error()) {
            throw new HttpException('Failed to parse JSON: '.json_last_error_msg());
        }

        return $contents;
    }

    /**
     * Filter the invalid JSON string.
     *
     * @param \Psr\Http\Message\StreamInterface|string $invalidJSON
     *
     * @return string
     */
    protected function fuckTheWeChatInvalidJSON($invalidJSON)
    {
        return preg_replace("/\p{Cc}/u", '', trim($invalidJSON));
    }

    /**
     * Build a handler.
     *
     * @return HandlerStack
     */
    protected function getHandler()
    {
        $stack = HandlerStack::create();

        foreach ($this->middlewares as $middleware) {
            $stack->push($middleware);
        }

        return $stack;
    }
}


1		<?php
2
3		/*
4		* This file is part of the overtrue/wechat.
5		*
6		* (c) overtrue <[email protected]>
7		*
8		* This source file is subject to the MIT license that is bundled
9		* with this source code in the file LICENSE.
10		*/
11
12		/**
13		* Http.php.
14		*
15		* This file is part of the wechat-components.
16		*
17		* (c) overtrue <[email protected]>
18		*
19		* This source file is subject to the MIT license that is bundled
20		* with this source code in the file LICENSE.
21		*/
22		namespace EasyWeChat\Core;
23
24		use EasyWeChat\Core\Exceptions\HttpException;
25		use EasyWeChat\Support\Log;
26		use GuzzleHttp\Client as HttpClient;
27		use GuzzleHttp\HandlerStack;
28		use Psr\Http\Message\ResponseInterface;
29
30		/**
31		* Class Http.
32		*/
33		class Http
34		{
35		/**
36		* Http client.
37		*
38		* @var HttpClient
39		*/
40		protected $client;
41
42		/**
43		* The middlewares.
44		*
45		* @var array
46		*/
47		protected $middlewares = [];
48
49		/**
50		* GET request.
51		*
52		* @param string $url
53		* @param array $options
54		*
55		* @return array\|bool
56		*
57		* @throws HttpException
58		*/
59	1	public function get($url, array $options = [])
60		{
61	1	return $this->request($url, 'GET', ['query' => $options]);
62		}
63
64		/**
65		* POST request.
66		*
67		* @param string $url
68		* @param array\|string $options
69		*
70		* @return array\|bool
71		*
72		* @throws HttpException
73		*/
74	1	public function post($url, $options = [])
75		{
76	1	$key = is_array($options) ? 'form_params' : 'body';
77
78	1	return $this->request($url, 'POST', [$key => $options]);
79		}
80
81		/**
82		* JSON request.
83		*
84		* @param string $url
85		* @param string\|array $options
86		* @param int $encodeOption
87		*
88		* @return array\|bool
89		*
90		* @throws HttpException
91		*/
92	1	public function json($url, $options = [], $encodeOption = JSON_UNESCAPED_UNICODE)
93		{
94	1	is_array($options) && $options = json_encode($options, $encodeOption);
95
96	1	return $this->request($url, 'POST', ['body' => $options, 'headers' => ['content-type' => 'application/json']]);
97		}
98
99		/**
100		* Upload file.
101		*
102		* @param string $url
103		* @param array $files
104		* @param array $form
105		*
106		* @return array\|bool
107		*
108		* @throws HttpException
109		*/
110	1	public function upload($url, array $files = [], array $form = [], array $queries = [])
111		{
112	1	$multipart = [];
113
114	1	foreach ($files as $name => $path) {
115	1	$multipart[] = [
116	1	'name' => $name,
117	1	'contents' => fopen($path, 'r'),
118		];
119	1	}
120
121	1	foreach ($form as $name => $contents) {
122	1	$multipart[] = compact('name', 'contents');
123	1	}
124
125	1	return $this->request($url, 'POST', ['query' => $queries, 'multipart' => $multipart]);
126		}
127
128		/**
129		* Set GuzzleHttp\Client.
130		*
131		* @param \GuzzleHttp\Client $client
132		*
133		* @return Http
134		*/
135	6	public function setClient(HttpClient $client)
136		{
137	6	$this->client = $client;
138
139	6	return $this;
140		}
141
142		/**
143		* Return GuzzleHttp\Client instance.
144		*
145		* @return \GuzzleHttp\Client.
146		*/
147	2	public function getClient()
148		{
149	2	if (!($this->client instanceof HttpClient)) {
150		$this->client = new HttpClient();
151		}
152
153	2	return $this->client;
154		}
155
156		/**
157		* Add a middleware.
158		*
159		* @param callable $middleware
160		*
161		* @return $this
162		*/
163	79	public function addMiddleware(callable $middleware)
164		{
165	79	array_push($this->middlewares, $middleware);
166
167	79	return $this;
168		}
169
170		/**
171		* Return all middlewares.
172		*
173		* @return array
174		*/
175		public function getMiddlewares()
176		{
177		return $this->middlewares;
178		}
179
180		/**
181		* Make a request.
182		*
183		* @param string $url
184		* @param string $method
185		* @param array $options
186		*
187		* @return array\|bool
188		*
189		* @throws HttpException
190		*/
191	2	public function request($url, $method = 'GET', $options = [])
192		{
193	2	$method = strtoupper($method);
194
195	2	Log::debug('Client Request:', compact('url', 'method', 'options'));
196
197	2	$options['handler'] = $this->getHandler();
198
199	2	$response = $this->getClient()->request($method, $url, $options);
200
201	2	Log::debug('API response:', [
202	2	'Status' => $response->getStatusCode(),
203	2	'Reason' => $response->getReasonPhrase(),
204	2	'Headers' => $response->getHeaders(),
205	2	'Body' => strval($response->getBody()),
206	2	]);
207
208	2	return $response;
209		}
210
211		/**
212		* @param \Psr\Http\Message\ResponseInterface\|string $body
213		*
214		* @return mixed
215		*
216		* @throws \EasyWeChat\Core\Exceptions\HttpException
217		*/
218	9	public function parseJSON($body)
219		{
220	9	if ($body instanceof ResponseInterface) {
221	2	$body = $body->getBody();
222	2	}
223
224		// XXX: json maybe contains special chars. So, let's FUCK the WeChat API developers ...
225	9	$body = $this->fuckTheWeChatInvalidJSON($body);
226
227	9	if (empty($body)) {
228	1	return false;
229		}
230
231	9	$contents = json_decode($body, true);
232
233	9	Log::debug('API response decoded:', compact('contents'));
234
235	9	if (JSON_ERROR_NONE !== json_last_error()) {
236	1	throw new HttpException('Failed to parse JSON: '.json_last_error_msg());
237		}
238
239	9	return $contents;
240		}
241
242		/**
243		* Filter the invalid JSON string.
244		*
245		* @param \Psr\Http\Message\StreamInterface\|string $invalidJSON
246		*
247		* @return string
248		*/
249	9	protected function fuckTheWeChatInvalidJSON($invalidJSON)
250		{
251	9	return preg_replace("/\p{Cc}/u", '', trim($invalidJSON));
252		}
253
254		/**
255		* Build a handler.
256		*
257		* @return HandlerStack
258		*/
259	2	protected function getHandler()
260		{
261	2	$stack = HandlerStack::create();
262
263	2	foreach ($this->middlewares as $middleware) {
264		$stack->push($middleware);
265	2	}
266
267	2	return $stack;
268		}
269		}
270

overtrue / wechat

Push — master ( c7d4dc...13d232 )

Http::parseJSON() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like