Client::put() - Code Metrics - liblynx-llc/liblynx-connect-php - Measure and Improve Code Quality continuously with Scrutinizer

Client::put() A
last analyzed 2018-10-11 16:33 UTC

↳ Parent: Client

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
nc	1
nop	2
dl	0
loc	4
rs	10
c	0
b	0
f	0

<?php

namespace LibLynx\Connect;

use GuzzleHttp\ClientInterface;
use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\Exception\GuzzleException;
use GuzzleHttp\Psr7\Request;
use LibLynx\Connect\Exception\APIException;
use LibLynx\Connect\Exception\LogicException;
use LibLynx\Connect\HTTPClient\HTTPClientFactory;
use LibLynx\Connect\Resource\Identification;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use Psr\SimpleCache\CacheInterface;

/**
 * LibLynx Connect API client
 *
 * $liblynx=new Liblynx\Connect\Client;
 * $liblynx->setCredentials('your client id', 'your client secret');
 *
 * //must set a PSR-16 cache - this can be used for testing
 * $liblynx->setCache(new \Symfony\Component\Cache\Simple\ArrayCache);
 *
 * $identification=$liblynx->authorize(Identification::fromSuperglobals());
 * if ($identification->isIdentified()) {
 *     //good to go
 * }
 *
 * if ($identification->requiresWayf()) {
 *     $identification->doWayfRedirect();
 * }
 *
 * @package LibLynx\Connect
 */
class Client implements LoggerAwareInterface
{
    private $apiroot = 'https://connect.liblynx.com';

    /** @var string client ID obtain from LibLynx Connect admin portal */
    private $clientId;

    /** @var string client secret obtain from LibLynx Connect admin portal */
    private $clientSecret;

    /** @var ClientInterface HTTP client for API requests */
    private $guzzle;

    /** @var \stdClass entry point resource */
    private $entrypoint;

    /** @var CacheInterface */
    protected $cache;

    /** @var LoggerInterface */
    protected $log;

    /** @var HTTPClientFactory */
    protected $httpClientFactory;

    /**
     * Create new LibLynx API client
     */
    public function __construct(HTTPClientFactory $clientFactory = null)
    {
        if (isset($_SERVER['LIBLYNX_CLIENT_ID'])) {
            $this->clientId = $_SERVER['LIBLYNX_CLIENT_ID'];
        }
        if (isset($_SERVER['LIBLYNX_CLIENT_SECRET'])) {
            $this->clientSecret = $_SERVER['LIBLYNX_CLIENT_SECRET'];
        }

        $this->log = new NullLogger();
        $this->httpClientFactory = $clientFactory ?? new HTTPClientFactory;
    }

    /**
     * @inheritdoc
     */
    public function setLogger(LoggerInterface $logger)
    {
        $this->log = $logger;
    }

    /**
     * Set API root
     * An alternative root may be provided to you by LibLynx Technical Support
     * @param string $url
     */
    public function setAPIRoot($url)
    {
        $this->apiroot = $url;
    }

    /**
     * Set OAuth2.0 client credentials
     * These will be provided to you by LibLynx Technical Support
     *
     * @param string $clientId
     * @param string $clientSecret
     */
    public function setCredentials($clientId, $clientSecret)
    {
        $this->clientId = $clientId;
        $this->clientSecret = $clientSecret;
    }

    /**
     * @return array containing client id and secret
     */
    public function getCredentials()
    {
        return [$this->clientId, $this->clientSecret];
    }

    /**
     * Attempt an identification using the LibLynx API
     *
     * @param IdentificationRequest $request
     * @return Identification|null
     */
    public function authorize(IdentificationRequest $request)
    {
        $payload = $request->getRequestJSON();
        $response = $this->post('@new_identification', $payload);
        if (!isset($response->id)) {
            //failed
            $this->log->critical('Identification request failed {payload}', ['payload' => $payload]);
            return null;
        }

        $identification = new Identification($response);
        $this->log->info(
            'Identification request for ip {ip} on URL {url} succeeded status={status} id={id}',
            [
                'status' => $identification->status,
                'id' => $identification->id,
                'ip' => $identification->ip,
                'url' => $identification->url
            ]
        );

        return $identification;
    }

    /**
     * General purpose 'GET' request against API
     * @param $entrypoint string contains either an @entrypoint or full URL obtained from a resource
     * @return mixed
     */
    public function get($entrypoint)
    {
        return $this->makeAPIRequest('GET', $entrypoint);
    }

    /**
     * General purpose 'POST' request against API
     * @param $entrypoint string contains either an @entrypoint or full URL obtained from a resource
     * @param $json string contains JSON formatted data to post
     * @return mixed
     */
    public function post($entrypoint, $json)
    {
        return $this->makeAPIRequest('POST', $entrypoint, $json);
    }

    /**
     * General purpose 'PUT' request against API
     * @param $entrypoint string contains either an @entrypoint or full URL obtained from a resource
     * @return mixed string contains JSON formatted data to put
     */
    public function put($entrypoint, $json)
    {
        return $this->makeAPIRequest('PUT', $entrypoint, $json);
    }

    /**
     * @param $method
     * @param $entrypoint
     * @param null $json
     * @return \stdClass object containing JSON decoded response - note this can be an error response for normally
     *         handled errors
     * @throws LogicException for integration errors, e.g. not setting a cache
     * @throws APIException for unexpected API failures
     */
    protected function makeAPIRequest($method, $entrypoint, $json = null)
    {
        $this->log->debug('{method} {entry} {json}', ['method' => $method, 'entry' => $entrypoint, 'json' => $json]);
        $url = $this->resolveEntryPoint($entrypoint);
        $client = $this->getClient();

        $headers = ['Accept' => 'application/json'];
        if (!empty($json)) {
            $headers['Content-Type'] = 'application/json';
        }

        $request = new Request($method, $url, $headers, $json);

        try {
            $response = $client->send($request);
            $this->log->debug(
                '{method} {entry} succeeded {status}',
                ['method' => $method, 'entry' => $entrypoint, 'status' => $response->getStatusCode()]
            );
        } catch (RequestException $e) {
            //we usually have a response available, but it's not guaranteed
            $response = $e->getResponse();
            $this->log->error(
                '{method} {entrypoint} {json} failed ({status}): {body}',
                [
                    'method' => $method,
                    'json' => $json,
                    'entrypoint' => $entrypoint,
                    'status' => $response ? $response->getStatusCode() : 0,
                    'body' => $response ? $response->getBody() : ''
                ]
            );

            throw new APIException("$method $entrypoint request failed", $e->getCode(), $e);
        } catch (GuzzleException $e) {
            $this->log->critical(
                '{method} {entry} {json} failed',
                ['method' => $method, 'json' => $json, 'entry' => $entrypoint]
            );

            throw new APIException("$method $entrypoint failed", 0, $e);
        }

        return json_decode($response->getBody());
    }

    public function resolveEntryPoint($nameOrUrl)
    {
        if ($nameOrUrl[0] === '@') {
            $resolved = $this->getEntryPoint($nameOrUrl);
            $this->log->debug(
                'Entrypoint {entrypoint} resolves to {url}',
                ['entrypoint' => $nameOrUrl, 'url' => $resolved]
            );
            return $resolved;
        }
        //it's a URL
        return $nameOrUrl;
    }

    public function getEntryPoint($name)
    {
        if (!is_array($this->entrypoint)) {
            $this->entrypoint = $this->getEntrypointResource();
        } else {
            $this->log->debug('using previously loaded entrypoint');
        }

        if (!isset($this->entrypoint->_links->$name->href)) {
            throw new LogicException("Invalid LibLynx API entrypoint $name requested");
        }

        return $this->entrypoint->_links->$name->href;
    }

    protected function getEntrypointResource()
    {
        $key = 'entrypoint' . $this->clientId;

        $cache = $this->getCache();
        if ($cache->has($key)) {
            $this->log->debug('loading entrypoint from persistent cache');
            $entrypointResource = $cache->get($key);
            ;
        } else {
            $this->log->debug('entrypoint not cached, requesting from API');
            $entrypointResource = $this->get('api');
            $cache->set($key, $entrypointResource, 86400);
            $this->log->info('entrypoint loaded from API and cached');
        }


        return $entrypointResource;
    }

    public function getCache()
    {
        if (is_null($this->cache)) {
            throw new LogicException('LibLynx Connect Client requires a PSR-16 compatible cache');
        }
        return $this->cache;
    }

    public function setCache(CacheInterface $cache)
    {
        $this->cache = $cache;
    }

    /**
     * Internal helper to provide an OAuth2 capable HTTP client
     */
    protected function getClient()
    {
        if (empty($this->clientId)) {
            throw new LogicException('Cannot make API calls until setCredentials has been called');
        }
        if (!is_object($this->guzzle)) {
            $this->guzzle = $this->httpClientFactory->create(
                $this->apiroot,
                $this->clientId,
                $this->clientSecret,
                $this->getCache()
            );
        }

        return $this->guzzle;
    }
}


1			<?php
2
3			namespace LibLynx\Connect;
4
5			use GuzzleHttp\ClientInterface;
6			use GuzzleHttp\Exception\RequestException;
7			use GuzzleHttp\Exception\GuzzleException;
8			use GuzzleHttp\Psr7\Request;
9			use LibLynx\Connect\Exception\APIException;
10			use LibLynx\Connect\Exception\LogicException;
11			use LibLynx\Connect\HTTPClient\HTTPClientFactory;
12			use LibLynx\Connect\Resource\Identification;
13			use Psr\Log\LoggerAwareInterface;
14			use Psr\Log\LoggerInterface;
15			use Psr\Log\NullLogger;
16			use Psr\SimpleCache\CacheInterface;
17
18			/**
19			* LibLynx Connect API client
20			*
21			* $liblynx=new Liblynx\Connect\Client;
22			* $liblynx->setCredentials('your client id', 'your client secret');
23			*
24			* //must set a PSR-16 cache - this can be used for testing
25			* $liblynx->setCache(new \Symfony\Component\Cache\Simple\ArrayCache);
26			*
27			* $identification=$liblynx->authorize(Identification::fromSuperglobals());
28			* if ($identification->isIdentified()) {
29			* //good to go
30			* }
31			*
32			* if ($identification->requiresWayf()) {
33			* $identification->doWayfRedirect();
34			* }
35			*
36			* @package LibLynx\Connect
37			*/
38			class Client implements LoggerAwareInterface
39			{
40			private $apiroot = 'https://connect.liblynx.com';
41
42			/** @var string client ID obtain from LibLynx Connect admin portal */
43			private $clientId;
44
45			/** @var string client secret obtain from LibLynx Connect admin portal */
46			private $clientSecret;
47
48			/** @var ClientInterface HTTP client for API requests */
49			private $guzzle;
50
51			/** @var \stdClass entry point resource */
52			private $entrypoint;
53
54			/** @var CacheInterface */
55			protected $cache;
56
57			/** @var LoggerInterface */
58			protected $log;
59
60			/** @var HTTPClientFactory */
61			protected $httpClientFactory;
62
63			/**
64			* Create new LibLynx API client
65			*/
66			public function __construct(HTTPClientFactory $clientFactory = null)
67			{
68			if (isset($_SERVER['LIBLYNX_CLIENT_ID'])) {
69			$this->clientId = $_SERVER['LIBLYNX_CLIENT_ID'];
70			}
71			if (isset($_SERVER['LIBLYNX_CLIENT_SECRET'])) {
72			$this->clientSecret = $_SERVER['LIBLYNX_CLIENT_SECRET'];
73			}
74
75			$this->log = new NullLogger();
76			$this->httpClientFactory = $clientFactory ?? new HTTPClientFactory;
77			}
78
79			/**
80			* @inheritdoc
81			*/
82			public function setLogger(LoggerInterface $logger)
83			{
84			$this->log = $logger;
85			}
86
87			/**
88			* Set API root
89			* An alternative root may be provided to you by LibLynx Technical Support
90			* @param string $url
91			*/
92			public function setAPIRoot($url)
93			{
94			$this->apiroot = $url;
95			}
96
97			/**
98			* Set OAuth2.0 client credentials
99			* These will be provided to you by LibLynx Technical Support
100			*
101			* @param string $clientId
102			* @param string $clientSecret
103			*/
104			public function setCredentials($clientId, $clientSecret)
105			{
106			$this->clientId = $clientId;
107			$this->clientSecret = $clientSecret;
108			}
109
110			/**
111			* @return array containing client id and secret
112			*/
113			public function getCredentials()
114			{
115			return [$this->clientId, $this->clientSecret];
116			}
117
118			/**
119			* Attempt an identification using the LibLynx API
120			*
121			* @param IdentificationRequest $request
122			* @return Identification\|null
123			*/
124			public function authorize(IdentificationRequest $request)
125			{
126			$payload = $request->getRequestJSON();
127			$response = $this->post('@new_identification', $payload);
128			if (!isset($response->id)) {
129			//failed
130			$this->log->critical('Identification request failed {payload}', ['payload' => $payload]);
131			return null;
132			}
133
134			$identification = new Identification($response);
135			$this->log->info(
136			'Identification request for ip {ip} on URL {url} succeeded status={status} id={id}',
137			[
138			'status' => $identification->status,
139			'id' => $identification->id,
140			'ip' => $identification->ip,
141			'url' => $identification->url
142			]
143			);
144
145			return $identification;
146			}
147
148			/**
149			* General purpose 'GET' request against API
150			* @param $entrypoint string contains either an @entrypoint or full URL obtained from a resource
151			* @return mixed
152			*/
153			public function get($entrypoint)
154			{
155			return $this->makeAPIRequest('GET', $entrypoint);
156			}
157
158			/**
159			* General purpose 'POST' request against API
160			* @param $entrypoint string contains either an @entrypoint or full URL obtained from a resource
161			* @param $json string contains JSON formatted data to post
162			* @return mixed
163			*/
164			public function post($entrypoint, $json)
165			{
166			return $this->makeAPIRequest('POST', $entrypoint, $json);
167			}
168
169			/**
170			* General purpose 'PUT' request against API
171			* @param $entrypoint string contains either an @entrypoint or full URL obtained from a resource
172			* @return mixed string contains JSON formatted data to put
173			*/
174			public function put($entrypoint, $json)
175			{
176			return $this->makeAPIRequest('PUT', $entrypoint, $json);
177			}
178
179			/**
180			* @param $method
181			* @param $entrypoint
182			* @param null $json
183			* @return \stdClass object containing JSON decoded response - note this can be an error response for normally
184			* handled errors
185			* @throws LogicException for integration errors, e.g. not setting a cache
186			* @throws APIException for unexpected API failures
187			*/
188			protected function makeAPIRequest($method, $entrypoint, $json = null)
189			{
190			$this->log->debug('{method} {entry} {json}', ['method' => $method, 'entry' => $entrypoint, 'json' => $json]);
191			$url = $this->resolveEntryPoint($entrypoint);
192			$client = $this->getClient();
193
194			$headers = ['Accept' => 'application/json'];
195			if (!empty($json)) {
196			$headers['Content-Type'] = 'application/json';
197			}
198
199			$request = new Request($method, $url, $headers, $json);
200
201			try {
202			$response = $client->send($request);
203			$this->log->debug(
204			'{method} {entry} succeeded {status}',
205			['method' => $method, 'entry' => $entrypoint, 'status' => $response->getStatusCode()]
206			);
207			} catch (RequestException $e) {
208			//we usually have a response available, but it's not guaranteed
209			$response = $e->getResponse();
210			$this->log->error(
211			'{method} {entrypoint} {json} failed ({status}): {body}',
212			[
213			'method' => $method,
214			'json' => $json,
215			'entrypoint' => $entrypoint,
216			'status' => $response ? $response->getStatusCode() : 0,
217			'body' => $response ? $response->getBody() : ''
218			]
219			);
220
221			throw new APIException("$method $entrypoint request failed", $e->getCode(), $e);
222			} catch (GuzzleException $e) {
223			$this->log->critical(
224			'{method} {entry} {json} failed',
225			['method' => $method, 'json' => $json, 'entry' => $entrypoint]
226			);
227
228			throw new APIException("$method $entrypoint failed", 0, $e);
229			}
230
231			return json_decode($response->getBody());
232			}
233
234			public function resolveEntryPoint($nameOrUrl)
235			{
236			if ($nameOrUrl[0] === '@') {
237			$resolved = $this->getEntryPoint($nameOrUrl);
238			$this->log->debug(
239			'Entrypoint {entrypoint} resolves to {url}',
240			['entrypoint' => $nameOrUrl, 'url' => $resolved]
241			);
242			return $resolved;
243			}
244			//it's a URL
245			return $nameOrUrl;
246			}
247
248			public function getEntryPoint($name)
249			{
250			if (!is_array($this->entrypoint)) {
251			$this->entrypoint = $this->getEntrypointResource();
252			} else {
253			$this->log->debug('using previously loaded entrypoint');
254			}
255
256			if (!isset($this->entrypoint->_links->$name->href)) {
257			throw new LogicException("Invalid LibLynx API entrypoint $name requested");
258			}
259
260			return $this->entrypoint->_links->$name->href;
261			}
262
263			protected function getEntrypointResource()
264			{
265			$key = 'entrypoint' . $this->clientId;
266
267			$cache = $this->getCache();
268			if ($cache->has($key)) {
269			$this->log->debug('loading entrypoint from persistent cache');
270			$entrypointResource = $cache->get($key);
271			;
272			} else {
273			$this->log->debug('entrypoint not cached, requesting from API');
274			$entrypointResource = $this->get('api');
275			$cache->set($key, $entrypointResource, 86400);
276			$this->log->info('entrypoint loaded from API and cached');
277			}
278
279
280			return $entrypointResource;
281			}
282
283			public function getCache()
284			{
285			if (is_null($this->cache)) {
286			throw new LogicException('LibLynx Connect Client requires a PSR-16 compatible cache');
287			}
288			return $this->cache;
289			}
290
291			public function setCache(CacheInterface $cache)
292			{
293			$this->cache = $cache;
294			}
295
296			/**
297			* Internal helper to provide an OAuth2 capable HTTP client
298			*/
299			protected function getClient()
300			{
301			if (empty($this->clientId)) {
302			throw new LogicException('Cannot make API calls until setCredentials has been called');
303			}
304			if (!is_object($this->guzzle)) {
305			$this->guzzle = $this->httpClientFactory->create(
306			$this->apiroot,
307			$this->clientId,
308			$this->clientSecret,
309			$this->getCache()
310			);
311			}
312
313			return $this->guzzle;
314			}
315			}
316

liblynx-llc / liblynx-connect-php

Client::put() A last analyzed 2018-10-11 16:33 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Client::put() A
last analyzed 2018-10-11 16:33 UTC