RestClient - Code Metrics - Inspection of "Fix disordered POST parameters (#279)" - mailgun/mailgun-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ae9ee5...0bc0a3 )

by Sean

created 2017-04-07 23:24 UTC

RestClient B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	351
Duplicated Lines	4.27 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

60%

Importance

Changes	5
Bugs	1	Features	0

Metric	Value
wmc	40
lcom	1
cbo	10
dl	15
loc	351
ccs	72
cts	120
cp	0.6
rs	8.2608
c	5
b	1
f	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
B	send()	0	22	4
A	getAttachment()	0	9	1
C	post()	15	36	8
A	get()	0	4	1
A	delete()	0	4	1
A	put()	0	4	1
C	responseHandler()	0	24	7
A	getResponseExceptionMessage()	0	10	3
B	prepareFile()	0	31	6
A	getHttpClient()	0	8	2
A	getApiUrl()	0	4	1
A	generateEndpoint()	0	4	2
A	setApiVersion()	0	6	1
A	setSslEnabled()	0	6	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 RestClient 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 RestClient, and based on these observations, apply Extract Interface, too.

<?PHP

/*
 * Copyright (C) 2013-2016 Mailgun
 *
 * This software may be modified and distributed under the terms
 * of the MIT license. See the LICENSE file for details.
 */

namespace Mailgun\Connection;

use Http\Client\HttpClient;
use Http\Discovery\HttpClientDiscovery;
use Http\Discovery\MessageFactoryDiscovery;
use Http\Message\MultipartStream\MultipartStreamBuilder;
use Mailgun\Connection\Exceptions\GenericHTTPError;
use Mailgun\Connection\Exceptions\InvalidCredentials;
use Mailgun\Connection\Exceptions\MissingEndpoint;
use Mailgun\Connection\Exceptions\MissingRequiredParameters;
use Mailgun\Constants\Api;
use Mailgun\Constants\ExceptionMessages;
use Psr\Http\Message\ResponseInterface;

/**
 * This class is a wrapper for the HTTP client.
 *
 * @deprecated Will be removed in 3.0
 */
class RestClient
{
    /**
     * Your API key.
     *
     * @var string
     */
    private $apiKey;

    /**
     * @var HttpClient
     */
    protected $httpClient;

    /**
     * @var string
     */
    protected $apiHost;

    /**
     * The version of the API to use.
     *
     * @var string
     */
    protected $apiVersion = 'v2';

    /**
     * If we should use SSL or not.
     *
     * @var bool
     *
     * @deprecated To be removed in 3.0
     */
    protected $sslEnabled = true;

    /**
     * @param string     $apiKey
     * @param string     $apiHost
     * @param HttpClient $httpClient
     */
    public function __construct($apiKey, $apiHost, HttpClient $httpClient = null)
    {
        $this->apiKey = $apiKey;
        $this->apiHost = $apiHost;
        $this->httpClient = $httpClient;
    }

    /**
     * @param string $method
     * @param string $uri
     * @param mixed  $body
     * @param array  $files
     * @param array  $headers
     *
     * @throws GenericHTTPError
     * @throws InvalidCredentials
     * @throws MissingEndpoint
     * @throws MissingRequiredParameters
     *
     * @return \stdClass
     */
    protected function send($method, $uri, $body = null, $files = [], array $headers = [])
    {
        $headers['User-Agent'] = Api::SDK_USER_AGENT.'/'.Api::SDK_VERSION;
        $headers['Authorization'] = 'Basic '.base64_encode(sprintf('%s:%s', Api::API_USER, $this->apiKey));

        if (!empty($files)) {
            $builder = new MultipartStreamBuilder();
            foreach ($files as $file) {
                $builder->addResource($file['name'], $file['contents'], $file);
            }
            $body = $builder->build();
            $headers['Content-Type'] = 'multipart/form-data; boundary="'.$builder->getBoundary().'"';
        } elseif (is_array($body)) {
            $body = http_build_query($body);
            $headers['Content-Type'] = 'application/x-www-form-urlencoded';
        }

        $request = MessageFactoryDiscovery::find()->createRequest($method, $this->getApiUrl($uri), $headers, $body);
        $response = $this->getHttpClient()->sendRequest($request);

        return $this->responseHandler($response);
    }

    /**
     * @param string $url
     *
     * @throws GenericHTTPError
     * @throws InvalidCredentials
     * @throws MissingEndpoint
     * @throws MissingRequiredParameters
     *
     * @return \stdClass
     */
    public function getAttachment($url)
    {
        $headers['User-Agent'] = Api::SDK_USER_AGENT.'/'.Api::SDK_VERSION;
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

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

    // do something with $myArray
}
        $headers['Authorization'] = 'Basic '.base64_encode(sprintf('%s:%s', Api::API_USER, $this->apiKey));
        $request = MessageFactoryDiscovery::find()->createRequest('get', $url, $headers);
        $response = HttpClientDiscovery::find()->sendRequest($request);

        return $this->responseHandler($response);
    }

    /**
     * @param string $endpointUrl
     * @param array  $postData
     * @param array  $files
     *
     * @throws GenericHTTPError
     * @throws InvalidCredentials
     * @throws MissingEndpoint
     * @throws MissingRequiredParameters
     *
     * @return \stdClass
     */
    public function post($endpointUrl, array $postData = [], $files = [])
    {
        $postFiles = [];

        $fields = ['message', 'attachment', 'inline'];
        foreach ($fields as $fieldName) {
            if (isset($files[$fieldName])) {
                if (is_array($files[$fieldName])) {
                    foreach ($files[$fieldName] as $file) {
                        $postFiles[] = $this->prepareFile($fieldName, $file);
                    }
                } else {
                    $postFiles[] = $this->prepareFile($fieldName, $files[$fieldName]);
                }
            }
        }

        $postDataMultipart = [];
        foreach ($postData as $key => $value) {

            if (is_array($value)) {
                foreach ($value as $subValue) {
                    $postDataMultipart[] = [
                        'name' => $key,
                        'contents' => $subValue,
                    ];
                }
            } else {
                $postDataMultipart[] = [
                    'name' => $key,
                    'contents' => $value,
                ];
            }
        }

        return $this->send('POST', $endpointUrl, [], array_merge($postDataMultipart, $postFiles));
    }

    /**
     * @param string $endpointUrl
     * @param array  $queryString
     *
     * @throws GenericHTTPError
     * @throws InvalidCredentials
     * @throws MissingEndpoint
     * @throws MissingRequiredParameters
     *
     * @return \stdClass
     */
    public function get($endpointUrl, $queryString = [])
    {
        return $this->send('GET', $endpointUrl.'?'.http_build_query($queryString));
    }

    /**
     * @param string $endpointUrl
     *
     * @throws GenericHTTPError
     * @throws InvalidCredentials
     * @throws MissingEndpoint
     * @throws MissingRequiredParameters
     *
     * @return \stdClass
     */
    public function delete($endpointUrl)
    {
        return $this->send('DELETE', $endpointUrl);
    }

    /**
     * @param string $endpointUrl
     * @param mixed  $putData
     *
     * @throws GenericHTTPError
     * @throws InvalidCredentials
     * @throws MissingEndpoint
     * @throws MissingRequiredParameters
     *
     * @return \stdClass
     */
    public function put($endpointUrl, $putData)
    {
        return $this->send('PUT', $endpointUrl, $putData);
    }

    /**
     * @param ResponseInterface $responseObj
     *
     * @throws GenericHTTPError
     * @throws InvalidCredentials
     * @throws MissingEndpoint
     * @throws MissingRequiredParameters
     *
     * @return \stdClass
     */
    public function responseHandler(ResponseInterface $responseObj)
    {
        $httpResponseCode = (int) $responseObj->getStatusCode();

        switch ($httpResponseCode) {
        case 200:
            $data = (string) $responseObj->getBody();
            $jsonResponseData = json_decode($data, false);
            $result = new \stdClass();
            // return response data as json if possible, raw if not
            $result->http_response_body = $data && $jsonResponseData === null ? $data : $jsonResponseData;
            $result->http_response_code = $httpResponseCode;

            return $result;
        case 400:
            throw new MissingRequiredParameters(ExceptionMessages::EXCEPTION_MISSING_REQUIRED_PARAMETERS.$this->getResponseExceptionMessage($responseObj));

        case 401:
            throw new InvalidCredentials(ExceptionMessages::EXCEPTION_INVALID_CREDENTIALS);

        case 404:
            throw new MissingEndpoint(ExceptionMessages::EXCEPTION_MISSING_ENDPOINT.$this->getResponseExceptionMessage($responseObj));

        default:
            throw new GenericHTTPError(ExceptionMessages::EXCEPTION_GENERIC_HTTP_ERROR, $httpResponseCode, $responseObj->getBody());

        }
    }

    /**
     * @param ResponseInterface $responseObj
     *
     * @return string
     */
    protected function getResponseExceptionMessage(ResponseInterface $responseObj)
    {
        $body = (string) $responseObj->getBody();
        $response = json_decode($body);
        if (json_last_error() == JSON_ERROR_NONE && isset($response->message)) {
            return ' '.$response->message;
        }

        return '';
    }

    /**
     * Prepare a file for the postBody.
     *
     * @param string       $fieldName
     * @param string|array $filePath
     *
     * @return array
     */
    protected function prepareFile($fieldName, $filePath)
    {
        $filename = null;

        if (is_array($filePath) && isset($filePath['fileContent'])) {
            // File from memory
            $filename = $filePath['filename'];
            $resource = fopen('php://temp', 'r+');
            fwrite($resource, $filePath['fileContent']);
            rewind($resource);
        } else {
            // Backward compatibility code
            if (is_array($filePath) && isset($filePath['filePath'])) {
                $filename = $filePath['remoteName'];
                $filePath = $filePath['filePath'];
            }

            // Remove leading @ symbol
            if (strpos($filePath, '@') === 0) {
                $filePath = substr($filePath, 1);
            }

            $resource = fopen($filePath, 'r');
        }

        return [
            'name' => $fieldName,
            'contents' => $resource,
            'filename' => $filename,
        ];
    }

    /**
     * @return HttpClient
     */
    protected function getHttpClient()
    {
        if ($this->httpClient === null) {
            $this->httpClient = HttpClientDiscovery::find();
        }

        return $this->httpClient;
    }

    /**
     * @param string $uri
     *
     * @return string
     */
    private function getApiUrl($uri)
    {
        return $this->generateEndpoint($this->apiHost, $this->apiVersion, $this->sslEnabled).$uri;

    }

    /**
     * @param string $apiEndpoint
     * @param string $apiVersion
     * @param bool   $ssl
     *
     * @return string
     */
    private function generateEndpoint($apiEndpoint, $apiVersion, $ssl)
    {
        return ($ssl ? 'https://' : 'http://').$apiEndpoint.'/'.$apiVersion.'/';
    }

    /**
     * @param string $apiVersion
     *
     * @return RestClient
     */
    public function setApiVersion($apiVersion)
    {
        $this->apiVersion = $apiVersion;

        return $this;
    }

    /**
     * @param bool $sslEnabled
     *
     * @return RestClient
     *
     * @deprecated To be removed in 3.0
     */
    public function setSslEnabled($sslEnabled)
    {
        $this->sslEnabled = $sslEnabled;


        return $this;
    }
}


1			<?PHP
2
3			/*
4			* Copyright (C) 2013-2016 Mailgun
5			*
6			* This software may be modified and distributed under the terms
7			* of the MIT license. See the LICENSE file for details.
8			*/
9
10			namespace Mailgun\Connection;
11
12			use Http\Client\HttpClient;
13			use Http\Discovery\HttpClientDiscovery;
14			use Http\Discovery\MessageFactoryDiscovery;
15			use Http\Message\MultipartStream\MultipartStreamBuilder;
16			use Mailgun\Connection\Exceptions\GenericHTTPError;
17			use Mailgun\Connection\Exceptions\InvalidCredentials;
18			use Mailgun\Connection\Exceptions\MissingEndpoint;
19			use Mailgun\Connection\Exceptions\MissingRequiredParameters;
20			use Mailgun\Constants\Api;
21			use Mailgun\Constants\ExceptionMessages;
22			use Psr\Http\Message\ResponseInterface;
23
24			/**
25			* This class is a wrapper for the HTTP client.
26			*
27			* @deprecated Will be removed in 3.0
28			*/
29			class RestClient
30			{
31			/**
32			* Your API key.
33			*
34			* @var string
35			*/
36			private $apiKey;
37
38			/**
39			* @var HttpClient
40			*/
41			protected $httpClient;
42
43			/**
44			* @var string
45			*/
46			protected $apiHost;
47
48			/**
49			* The version of the API to use.
50			*
51			* @var string
52			*/
53			protected $apiVersion = 'v2';
54
55			/**
56			* If we should use SSL or not.
57			*
58			* @var bool
59			*
60			* @deprecated To be removed in 3.0
61			*/
62			protected $sslEnabled = true;
63
64			/**
65			* @param string $apiKey
66			* @param string $apiHost
67			* @param HttpClient $httpClient
68			*/
69	7		public function __construct($apiKey, $apiHost, HttpClient $httpClient = null)
70			{
71	7		$this->apiKey = $apiKey;
72	7		$this->apiHost = $apiHost;
73	7		$this->httpClient = $httpClient;
74	7		}
75
76			/**
77			* @param string $method
78			* @param string $uri
79			* @param mixed $body
80			* @param array $files
81			* @param array $headers
82			*
83			* @throws GenericHTTPError
84			* @throws InvalidCredentials
85			* @throws MissingEndpoint
86			* @throws MissingRequiredParameters
87			*
88			* @return \stdClass
89			*/
90			protected function send($method, $uri, $body = null, $files = [], array $headers = [])
91			{
92			$headers['User-Agent'] = Api::SDK_USER_AGENT.'/'.Api::SDK_VERSION;
93			$headers['Authorization'] = 'Basic '.base64_encode(sprintf('%s:%s', Api::API_USER, $this->apiKey));
94
95			if (!empty($files)) {
96			$builder = new MultipartStreamBuilder();
97			foreach ($files as $file) {
98			$builder->addResource($file['name'], $file['contents'], $file);
99			}
100			$body = $builder->build();
101			$headers['Content-Type'] = 'multipart/form-data; boundary="'.$builder->getBoundary().'"';
102			} elseif (is_array($body)) {
103			$body = http_build_query($body);
104			$headers['Content-Type'] = 'application/x-www-form-urlencoded';
105			}
106
107			$request = MessageFactoryDiscovery::find()->createRequest($method, $this->getApiUrl($uri), $headers, $body);
108			$response = $this->getHttpClient()->sendRequest($request);
109
110			return $this->responseHandler($response);
111			}
112
113			/**
114			* @param string $url
115			*
116			* @throws GenericHTTPError
117			* @throws InvalidCredentials
118			* @throws MissingEndpoint
119			* @throws MissingRequiredParameters
120			*
121			* @return \stdClass
122			*/
123	2		public function getAttachment($url)
124			{
125	2		$headers['User-Agent'] = Api::SDK_USER_AGENT.'/'.Api::SDK_VERSION;
			0 ignored issues – show Coding Style Comprehensibility introduced 2017-02-28 07:13 UTC by Report Bug Copy Issue Report `$headers` was never initialized. Although not strictly required by PHP, it is generally a good practice to add `$headers = 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...
126	2		$headers['Authorization'] = 'Basic '.base64_encode(sprintf('%s:%s', Api::API_USER, $this->apiKey));
127	2		$request = MessageFactoryDiscovery::find()->createRequest('get', $url, $headers);
128	2		$response = HttpClientDiscovery::find()->sendRequest($request);
129
130	2		return $this->responseHandler($response);
131			}
132
133			/**
134			* @param string $endpointUrl
135			* @param array $postData
136			* @param array $files
137			*
138			* @throws GenericHTTPError
139			* @throws InvalidCredentials
140			* @throws MissingEndpoint
141			* @throws MissingRequiredParameters
142			*
143			* @return \stdClass
144			*/
145	5		public function post($endpointUrl, array $postData = [], $files = [])
146			{
147	5		$postFiles = [];
148
149	5		$fields = ['message', 'attachment', 'inline'];
150	5		foreach ($fields as $fieldName) {
151	5		if (isset($files[$fieldName])) {
152	3		if (is_array($files[$fieldName])) {
153	3		foreach ($files[$fieldName] as $file) {
154	3		$postFiles[] = $this->prepareFile($fieldName, $file);
155	3		}
156	3		} else {
157			$postFiles[] = $this->prepareFile($fieldName, $files[$fieldName]);
158			}
159	3		}
160	5		}
161
162	5		$postDataMultipart = [];
163	5	View Code Duplication	foreach ($postData as $key => $value) {
			0 ignored issues – show Duplication introduced 2016-12-07 21:56 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
164	5		if (is_array($value)) {
165	2		foreach ($value as $subValue) {
166	2		$postDataMultipart[] = [
167	2		'name' => $key,
168	2		'contents' => $subValue,
169			];
170	2		}
171	2		} else {
172	5		$postDataMultipart[] = [
173	5		'name' => $key,
174	5		'contents' => $value,
175			];
176			}
177	5		}
178
179	5		return $this->send('POST', $endpointUrl, [], array_merge($postDataMultipart, $postFiles));
180			}
181
182			/**
183			* @param string $endpointUrl
184			* @param array $queryString
185			*
186			* @throws GenericHTTPError
187			* @throws InvalidCredentials
188			* @throws MissingEndpoint
189			* @throws MissingRequiredParameters
190			*
191			* @return \stdClass
192			*/
193			public function get($endpointUrl, $queryString = [])
194			{
195			return $this->send('GET', $endpointUrl.'?'.http_build_query($queryString));
196			}
197
198			/**
199			* @param string $endpointUrl
200			*
201			* @throws GenericHTTPError
202			* @throws InvalidCredentials
203			* @throws MissingEndpoint
204			* @throws MissingRequiredParameters
205			*
206			* @return \stdClass
207			*/
208			public function delete($endpointUrl)
209			{
210			return $this->send('DELETE', $endpointUrl);
211			}
212
213			/**
214			* @param string $endpointUrl
215			* @param mixed $putData
216			*
217			* @throws GenericHTTPError
218			* @throws InvalidCredentials
219			* @throws MissingEndpoint
220			* @throws MissingRequiredParameters
221			*
222			* @return \stdClass
223			*/
224			public function put($endpointUrl, $putData)
225			{
226			return $this->send('PUT', $endpointUrl, $putData);
227			}
228
229			/**
230			* @param ResponseInterface $responseObj
231			*
232			* @throws GenericHTTPError
233			* @throws InvalidCredentials
234			* @throws MissingEndpoint
235			* @throws MissingRequiredParameters
236			*
237			* @return \stdClass
238			*/
239	2		public function responseHandler(ResponseInterface $responseObj)
240			{
241	2		$httpResponseCode = (int) $responseObj->getStatusCode();
242
243			switch ($httpResponseCode) {
244	2		case 200:
245	1		$data = (string) $responseObj->getBody();
246	1		$jsonResponseData = json_decode($data, false);
247	1		$result = new \stdClass();
248			// return response data as json if possible, raw if not
249	1		$result->http_response_body = $data && $jsonResponseData === null ? $data : $jsonResponseData;
250	1		$result->http_response_code = $httpResponseCode;
251
252	1		return $result;
253	1		case 400:
254			throw new MissingRequiredParameters(ExceptionMessages::EXCEPTION_MISSING_REQUIRED_PARAMETERS.$this->getResponseExceptionMessage($responseObj));
			0 ignored issues – show Deprecated Code introduced 2017-03-14 10:05 UTC by Report Bug Copy Issue Report The class `Mailgun\Connection\Excep...ssingRequiredParameters` has been deprecated with message: Will be removed in 3.0 This class, trait or interface has been deprecated. The supplier of the file has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the type will be removed from the class and what other constant to use instead. Loading history...
255	1		case 401:
256			throw new InvalidCredentials(ExceptionMessages::EXCEPTION_INVALID_CREDENTIALS);
			0 ignored issues – show Deprecated Code introduced 2017-03-14 10:05 UTC by Report Bug Copy Issue Report The class `Mailgun\Connection\Exceptions\InvalidCredentials` has been deprecated with message: Will be removed in 3.0 This class, trait or interface has been deprecated. The supplier of the file has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the type will be removed from the class and what other constant to use instead. Loading history...
257	1		case 404:
258			throw new MissingEndpoint(ExceptionMessages::EXCEPTION_MISSING_ENDPOINT.$this->getResponseExceptionMessage($responseObj));
			0 ignored issues – show Deprecated Code introduced 2017-03-14 10:05 UTC by Report Bug Copy Issue Report The class `Mailgun\Connection\Exceptions\MissingEndpoint` has been deprecated with message: Will be removed in 3.0 This class, trait or interface has been deprecated. The supplier of the file has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the type will be removed from the class and what other constant to use instead. Loading history...
259	1		default:
260	1		throw new GenericHTTPError(ExceptionMessages::EXCEPTION_GENERIC_HTTP_ERROR, $httpResponseCode, $responseObj->getBody());
			0 ignored issues – show Deprecated Code introduced 2017-03-14 10:05 UTC by Report Bug Copy Issue Report The class `Mailgun\Connection\Exceptions\GenericHTTPError` has been deprecated with message: Will be removed in 3.0 This class, trait or interface has been deprecated. The supplier of the file has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the type will be removed from the class and what other constant to use instead. Loading history...
261	1		}
262			}
263
264			/**
265			* @param ResponseInterface $responseObj
266			*
267			* @return string
268			*/
269			protected function getResponseExceptionMessage(ResponseInterface $responseObj)
270			{
271			$body = (string) $responseObj->getBody();
272			$response = json_decode($body);
273			if (json_last_error() == JSON_ERROR_NONE && isset($response->message)) {
274			return ' '.$response->message;
275			}
276
277			return '';
278			}
279
280			/**
281			* Prepare a file for the postBody.
282			*
283			* @param string $fieldName
284			* @param string\|array $filePath
285			*
286			* @return array
287			*/
288	3		protected function prepareFile($fieldName, $filePath)
289			{
290	3		$filename = null;
291
292	3		if (is_array($filePath) && isset($filePath['fileContent'])) {
293			// File from memory
294	1		$filename = $filePath['filename'];
295	1		$resource = fopen('php://temp', 'r+');
296	1		fwrite($resource, $filePath['fileContent']);
297	1		rewind($resource);
298	1		} else {
299			// Backward compatibility code
300	3		if (is_array($filePath) && isset($filePath['filePath'])) {
301	3		$filename = $filePath['remoteName'];
302	3		$filePath = $filePath['filePath'];
303	3		}
304
305			// Remove leading @ symbol
306	3		if (strpos($filePath, '@') === 0) {
307	1		$filePath = substr($filePath, 1);
308	1		}
309
310	3		$resource = fopen($filePath, 'r');
311			}
312
313			return [
314	3		'name' => $fieldName,
315	3		'contents' => $resource,
316	3		'filename' => $filename,
317	3		];
318			}
319
320			/**
321			* @return HttpClient
322			*/
323			protected function getHttpClient()
324			{
325			if ($this->httpClient === null) {
326			$this->httpClient = HttpClientDiscovery::find();
327			}
328
329			return $this->httpClient;
330			}
331
332			/**
333			* @param string $uri
334			*
335			* @return string
336			*/
337			private function getApiUrl($uri)
338			{
339			return $this->generateEndpoint($this->apiHost, $this->apiVersion, $this->sslEnabled).$uri;
			0 ignored issues – show Deprecated Code introduced 2016-11-24 17:22 UTC by Report Bug Copy Issue Report The property `Mailgun\Connection\RestClient::$sslEnabled` has been deprecated with message: To be removed in 3.0 This property has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the property will be removed from the class and what other property to use instead. Loading history...
340			}
341
342			/**
343			* @param string $apiEndpoint
344			* @param string $apiVersion
345			* @param bool $ssl
346			*
347			* @return string
348			*/
349			private function generateEndpoint($apiEndpoint, $apiVersion, $ssl)
350			{
351			return ($ssl ? 'https://' : 'http://').$apiEndpoint.'/'.$apiVersion.'/';
352			}
353
354			/**
355			* @param string $apiVersion
356			*
357			* @return RestClient
358			*/
359			public function setApiVersion($apiVersion)
360			{
361			$this->apiVersion = $apiVersion;
362
363			return $this;
364			}
365
366			/**
367			* @param bool $sslEnabled
368			*
369			* @return RestClient
370			*
371			* @deprecated To be removed in 3.0
372			*/
373			public function setSslEnabled($sslEnabled)
374			{
375			$this->sslEnabled = $sslEnabled;
			0 ignored issues – show Deprecated Code introduced 2016-11-24 17:22 UTC by Report Bug Copy Issue Report The property `Mailgun\Connection\RestClient::$sslEnabled` has been deprecated with message: To be removed in 3.0 This property has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the property will be removed from the class and what other property to use instead. Loading history...
376
377			return $this;
378			}
379			}
380

mailgun / mailgun-php