LinkedIn::getLoginUrl() - Code Metrics - Inspection of "Merge pull request #73 from Happyr/psr7" - Happyr/LinkedIn-API-client - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b65b29...f39982 )

by Tobias

created 2016-01-01 13:37 UTC

LinkedIn::getLoginUrl() A

↳ Parent: LinkedIn

Complexity

Conditions	2
Paths	2

Size

Total Lines	11
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	6
Bugs	1	Features	0

Metric	Value
c	6
b	1
f	0
dl	0
loc	11
rs	9.4286
cc	2
eloc	5
nc	2
nop	1

<?php

namespace Happyr\LinkedIn;

use Happyr\LinkedIn\Exception\LoginError;
use Happyr\LinkedIn\Http\GlobalVariableGetter;
use Happyr\LinkedIn\Http\RequestManager;
use Happyr\LinkedIn\Http\ResponseConverter;
use Happyr\LinkedIn\Http\UrlGenerator;
use Happyr\LinkedIn\Http\UrlGeneratorInterface;
use Happyr\LinkedIn\Storage\DataStorageInterface;
use Http\Client\HttpClient;
use Psr\Http\Message\ResponseInterface;

/**
 * Class LinkedIn lets you talk to LinkedIn api.
 *
 * When a new user arrives and want to authenticate here is whats happens:
 * 1. You redirect him to whatever url getLoginUrl() returns.
 * 2. The user logs in on www.linkedin.com and authorize your application.
 * 3. The user returns to your site with a *code* in the the $_REQUEST.
 * 4. You call isAuthenticated() or getAccessToken()
 * 5. We don't got an access token (only a *code*). So getAccessToken() calls fetchNewAccessToken()
 * 6. fetchNewAccessToken() gets the *code* from the $_REQUEST and calls getAccessTokenFromCode()
 * 7. getAccessTokenFromCode() makes a request to www.linkedin.com and exchanges the *code* for an access token
 * 8. When you have the access token you should store it in a database and/or query the API.
 * 9. When you make a second request to the API we have the access token in memory, so we don't go through all these
 *    authentication steps again.
 *
 * @author Tobias Nyholm <[email protected]>
 */
class LinkedIn implements LinkedInInterface
{
    /**
     * The OAuth access token received in exchange for a valid authorization
     * code.  null means the access token has yet to be determined.
     *
     * @var AccessToken
     */
    protected $accessToken = null;

    /**
     * @var string format
     */
    private $format;

    /**
     * @var string responseFormat
     */
    private $responseDataType;

    /**
     * @var ResponseInterface
     */
    private $lastResponse;

    /**
     * @var RequestManager
     */
    private $requestManager;

    /**
     * @var Authenticator
     */
    private $authenticator;

    /**
     * @var UrlGeneratorInterface
     */
    private $urlGenerator;

    /**
     * Constructor.
     *
     * @param string $appId
     * @param string $appSecret
     * @param string $format           'json', 'xml'
     * @param string $responseDataType 'array', 'string', 'simple_xml' 'psr7', 'stream'
     */
    public function __construct($appId, $appSecret, $format = 'json', $responseDataType = 'array')
    {
        $this->format = $format;
        $this->responseDataType = $responseDataType;

        $this->requestManager = new RequestManager();
        $this->authenticator = new Authenticator($this->requestManager, $appId, $appSecret);
    }

    /**
     * {@inheritdoc}
     */
    public function isAuthenticated()
    {
        $accessToken = $this->getAccessToken();
        if ($accessToken === null) {
            return false;
        }

        $user = $this->api('GET', '/v1/people/~:(id,firstName,lastName)', array('format' => 'json', 'response_data_type' => 'array'));

        return !empty($user['id']);
    }

    /**
     * {@inheritdoc}
     */
    public function api($method, $resource, array $options = array())
    {
        // Add access token to the headers
        $options['headers']['Authorization'] = sprintf('Bearer %s', (string) $this->getAccessToken());

        // Do logic and adjustments to the options
        $requestFormat = $this->filterRequestOption($options);

        // Generate an url
        $url = $this->getUrlGenerator()->getUrl(
            'api',
            $resource,
            isset($options['query']) ? $options['query'] : array()
        );

        $body = isset($options['body']) ? $options['body'] : null;
        $this->lastResponse = $this->getRequestManager()->sendRequest($method, $url, $options['headers'], $body);

        //Get the response data format
        if (isset($options['response_data_type'])) {
            $responseDataType = $options['response_data_type'];
        } else {
            $responseDataType = $this->getResponseDataType();
        }

        return ResponseConverter::convert($this->lastResponse, $requestFormat, $responseDataType);
    }

    /**
     * Modify and filter the request options. Make sure we use the correct query parameters and headers.
     *
     * @param array &$options
     *
     * @return string the request format to use
     */
    protected function filterRequestOption(array &$options)
    {
        if (isset($options['json'])) {
            $options['format'] = 'json';
            $options['body'] = json_encode($options['json']);
        } elseif (!isset($options['format'])) {
            // Make sure we always have a format
            $options['format'] = $this->getFormat();
        }

        // Set correct headers for this format
        switch ($options['format']) {
            case 'xml':
                $options['headers']['Content-Type'] = 'text/xml';
                break;
            case 'json':
                $options['headers']['Content-Type'] = 'application/json';
                $options['headers']['x-li-format'] = 'json';
                $options['query']['format'] = 'json';
                break;
            default:
                // Do nothing
        }

        return $options['format'];
    }

    /**
     * {@inheritdoc}
     */
    public function getLoginUrl($options = array())
    {
        $urlGenerator = $this->getUrlGenerator();

        // Set redirect_uri to current URL if not defined
        if (!isset($options['redirect_uri'])) {
            $options['redirect_uri'] = $urlGenerator->getCurrentUrl();
        }

        return $this->getAuthenticator()->getLoginUrl($urlGenerator, $options);
    }

    /**
     * See docs for LinkedIn::api().
     *
     * @param string $resource
     * @param array  $options
     *
     * @return mixed
     */
    public function get($resource, array $options = array())
    {
        return $this->api('GET', $resource, $options);
    }

    /**
     * See docs for LinkedIn::api().
     *
     * @param string $resource
     * @param array  $options
     *
     * @return mixed
     */
    public function post($resource, array $options = array())
    {
        return $this->api('POST', $resource, $options);
    }

    /**
     * {@inheritdoc}
     */
    public function clearStorage()
    {
        $this->getAuthenticator()->clearStorage();

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function hasError()
    {
        return GlobalVariableGetter::has('error');
    }

    /**
     * {@inheritdoc}
     */
    public function getError()
    {
        if ($this->hasError()) {
            return new LoginError(GlobalVariableGetter::get('error'), GlobalVariableGetter::get('error_description'));
        }
    }

    /**
     * Get the default format to use when sending requests.
     *
     * @return string
     */
    protected function getFormat()
    {
        return $this->format;
    }

    /**
     * {@inheritdoc}
     */
    public function setFormat($format)
    {
        $this->format = $format;

        return $this;
    }

    /**
     * Get the default data type to be returned as a response.
     *
     * @return string
     */
    protected function getResponseDataType()
    {
        return $this->responseDataType;
    }

    /**
     * {@inheritdoc}
     */
    public function setResponseDataType($responseDataType)
    {
        $this->responseDataType = $responseDataType;

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function getLastResponse()
    {
        return $this->lastResponse;
    }

    /**
     * {@inheritdoc}
     */
    public function getAccessToken()
    {
        if ($this->accessToken === null) {
            if (null !== $newAccessToken = $this->getAuthenticator()->fetchNewAccessToken($this->getUrlGenerator())) {
                $this->setAccessToken($newAccessToken);
            }
        }

        // return the new access token or null if none found
        return $this->accessToken;
    }

    /**
     * {@inheritdoc}
     */
    public function setAccessToken($accessToken)
    {
        if (!($accessToken instanceof AccessToken)) {
            $accessToken = new AccessToken($accessToken);
        }

        $this->accessToken = $accessToken;

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function setUrlGenerator(UrlGeneratorInterface $urlGenerator)
    {
        $this->urlGenerator = $urlGenerator;

        return $this;
    }

    /**
     * @return UrlGeneratorInterface
     */
    protected function getUrlGenerator()
    {
        if ($this->urlGenerator === null) {
            $this->urlGenerator = new UrlGenerator();
        }

        return $this->urlGenerator;
    }

    /**
     * {@inheritdoc}
     */
    public function setStorage(DataStorageInterface $storage)
    {
        $this->getAuthenticator()->setStorage($storage);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function setHttpClient(HttpClient $client)
    {
        $this->getRequestManager()->setHttpClient($client);

        return $this;
    }

    /**
     * @return RequestManager
     */
    protected function getRequestManager()
    {
        return $this->requestManager;
    }

    /**
     * @return Authenticator
     */
    protected function getAuthenticator()
    {
        return $this->authenticator;
    }
}


1			<?php
2
3			namespace Happyr\LinkedIn;
4
5			use Happyr\LinkedIn\Exception\LoginError;
6			use Happyr\LinkedIn\Http\GlobalVariableGetter;
7			use Happyr\LinkedIn\Http\RequestManager;
8			use Happyr\LinkedIn\Http\ResponseConverter;
9			use Happyr\LinkedIn\Http\UrlGenerator;
10			use Happyr\LinkedIn\Http\UrlGeneratorInterface;
11			use Happyr\LinkedIn\Storage\DataStorageInterface;
12			use Http\Client\HttpClient;
13			use Psr\Http\Message\ResponseInterface;
14
15			/**
16			* Class LinkedIn lets you talk to LinkedIn api.
17			*
18			* When a new user arrives and want to authenticate here is whats happens:
19			* 1. You redirect him to whatever url getLoginUrl() returns.
20			* 2. The user logs in on www.linkedin.com and authorize your application.
21			* 3. The user returns to your site with a code in the the $_REQUEST.
22			* 4. You call isAuthenticated() or getAccessToken()
23			* 5. We don't got an access token (only a code). So getAccessToken() calls fetchNewAccessToken()
24			* 6. fetchNewAccessToken() gets the code from the $_REQUEST and calls getAccessTokenFromCode()
25			* 7. getAccessTokenFromCode() makes a request to www.linkedin.com and exchanges the code for an access token
26			* 8. When you have the access token you should store it in a database and/or query the API.
27			* 9. When you make a second request to the API we have the access token in memory, so we don't go through all these
28			* authentication steps again.
29			*
30			* @author Tobias Nyholm <[email protected]>
31			*/
32			class LinkedIn implements LinkedInInterface
33			{
34			/**
35			* The OAuth access token received in exchange for a valid authorization
36			* code. null means the access token has yet to be determined.
37			*
38			* @var AccessToken
39			*/
40			protected $accessToken = null;
41
42			/**
43			* @var string format
44			*/
45			private $format;
46
47			/**
48			* @var string responseFormat
49			*/
50			private $responseDataType;
51
52			/**
53			* @var ResponseInterface
54			*/
55			private $lastResponse;
56
57			/**
58			* @var RequestManager
59			*/
60			private $requestManager;
61
62			/**
63			* @var Authenticator
64			*/
65			private $authenticator;
66
67			/**
68			* @var UrlGeneratorInterface
69			*/
70			private $urlGenerator;
71
72			/**
73			* Constructor.
74			*
75			* @param string $appId
76			* @param string $appSecret
77			* @param string $format 'json', 'xml'
78			* @param string $responseDataType 'array', 'string', 'simple_xml' 'psr7', 'stream'
79			*/
80			public function __construct($appId, $appSecret, $format = 'json', $responseDataType = 'array')
81			{
82			$this->format = $format;
83			$this->responseDataType = $responseDataType;
84
85			$this->requestManager = new RequestManager();
86			$this->authenticator = new Authenticator($this->requestManager, $appId, $appSecret);
87			}
88
89			/**
90			* {@inheritdoc}
91			*/
92			public function isAuthenticated()
93			{
94			$accessToken = $this->getAccessToken();
95			if ($accessToken === null) {
96			return false;
97			}
98
99			$user = $this->api('GET', '/v1/people/~:(id,firstName,lastName)', array('format' => 'json', 'response_data_type' => 'array'));
100
101			return !empty($user['id']);
102			}
103
104			/**
105			* {@inheritdoc}
106			*/
107			public function api($method, $resource, array $options = array())
108			{
109			// Add access token to the headers
110			$options['headers']['Authorization'] = sprintf('Bearer %s', (string) $this->getAccessToken());
111
112			// Do logic and adjustments to the options
113			$requestFormat = $this->filterRequestOption($options);
114
115			// Generate an url
116			$url = $this->getUrlGenerator()->getUrl(
117			'api',
118			$resource,
119			isset($options['query']) ? $options['query'] : array()
120			);
121
122			$body = isset($options['body']) ? $options['body'] : null;
123			$this->lastResponse = $this->getRequestManager()->sendRequest($method, $url, $options['headers'], $body);
124
125			//Get the response data format
126			if (isset($options['response_data_type'])) {
127			$responseDataType = $options['response_data_type'];
128			} else {
129			$responseDataType = $this->getResponseDataType();
130			}
131
132			return ResponseConverter::convert($this->lastResponse, $requestFormat, $responseDataType);
133			}
134
135			/**
136			* Modify and filter the request options. Make sure we use the correct query parameters and headers.
137			*
138			* @param array &$options
139			*
140			* @return string the request format to use
141			*/
142			protected function filterRequestOption(array &$options)
143			{
144			if (isset($options['json'])) {
145			$options['format'] = 'json';
146			$options['body'] = json_encode($options['json']);
147			} elseif (!isset($options['format'])) {
148			// Make sure we always have a format
149			$options['format'] = $this->getFormat();
150			}
151
152			// Set correct headers for this format
153			switch ($options['format']) {
154			case 'xml':
155			$options['headers']['Content-Type'] = 'text/xml';
156			break;
157			case 'json':
158			$options['headers']['Content-Type'] = 'application/json';
159			$options['headers']['x-li-format'] = 'json';
160			$options['query']['format'] = 'json';
161			break;
162			default:
163			// Do nothing
164			}
165
166			return $options['format'];
167			}
168
169			/**
170			* {@inheritdoc}
171			*/
172			public function getLoginUrl($options = array())
173			{
174			$urlGenerator = $this->getUrlGenerator();
175
176			// Set redirect_uri to current URL if not defined
177			if (!isset($options['redirect_uri'])) {
178			$options['redirect_uri'] = $urlGenerator->getCurrentUrl();
179			}
180
181			return $this->getAuthenticator()->getLoginUrl($urlGenerator, $options);
182			}
183
184			/**
185			* See docs for LinkedIn::api().
186			*
187			* @param string $resource
188			* @param array $options
189			*
190			* @return mixed
191			*/
192			public function get($resource, array $options = array())
193			{
194			return $this->api('GET', $resource, $options);
195			}
196
197			/**
198			* See docs for LinkedIn::api().
199			*
200			* @param string $resource
201			* @param array $options
202			*
203			* @return mixed
204			*/
205			public function post($resource, array $options = array())
206			{
207			return $this->api('POST', $resource, $options);
208			}
209
210			/**
211			* {@inheritdoc}
212			*/
213			public function clearStorage()
214			{
215			$this->getAuthenticator()->clearStorage();
216
217			return $this;
218			}
219
220			/**
221			* {@inheritdoc}
222			*/
223			public function hasError()
224			{
225			return GlobalVariableGetter::has('error');
226			}
227
228			/**
229			* {@inheritdoc}
230			*/
231			public function getError()
232			{
233			if ($this->hasError()) {
234			return new LoginError(GlobalVariableGetter::get('error'), GlobalVariableGetter::get('error_description'));
235			}
236			}
237
238			/**
239			* Get the default format to use when sending requests.
240			*
241			* @return string
242			*/
243			protected function getFormat()
244			{
245			return $this->format;
246			}
247
248			/**
249			* {@inheritdoc}
250			*/
251			public function setFormat($format)
252			{
253			$this->format = $format;
254
255			return $this;
256			}
257
258			/**
259			* Get the default data type to be returned as a response.
260			*
261			* @return string
262			*/
263			protected function getResponseDataType()
264			{
265			return $this->responseDataType;
266			}
267
268			/**
269			* {@inheritdoc}
270			*/
271			public function setResponseDataType($responseDataType)
272			{
273			$this->responseDataType = $responseDataType;
274
275			return $this;
276			}
277
278			/**
279			* {@inheritdoc}
280			*/
281			public function getLastResponse()
282			{
283			return $this->lastResponse;
284			}
285
286			/**
287			* {@inheritdoc}
288			*/
289			public function getAccessToken()
290			{
291			if ($this->accessToken === null) {
292			if (null !== $newAccessToken = $this->getAuthenticator()->fetchNewAccessToken($this->getUrlGenerator())) {
293			$this->setAccessToken($newAccessToken);
294			}
295			}
296
297			// return the new access token or null if none found
298			return $this->accessToken;
299			}
300
301			/**
302			* {@inheritdoc}
303			*/
304			public function setAccessToken($accessToken)
305			{
306			if (!($accessToken instanceof AccessToken)) {
307			$accessToken = new AccessToken($accessToken);
308			}
309
310			$this->accessToken = $accessToken;
311
312			return $this;
313			}
314
315			/**
316			* {@inheritdoc}
317			*/
318			public function setUrlGenerator(UrlGeneratorInterface $urlGenerator)
319			{
320			$this->urlGenerator = $urlGenerator;
321
322			return $this;
323			}
324
325			/**
326			* @return UrlGeneratorInterface
327			*/
328			protected function getUrlGenerator()
329			{
330			if ($this->urlGenerator === null) {
331			$this->urlGenerator = new UrlGenerator();
332			}
333
334			return $this->urlGenerator;
335			}
336
337			/**
338			* {@inheritdoc}
339			*/
340			public function setStorage(DataStorageInterface $storage)
341			{
342			$this->getAuthenticator()->setStorage($storage);
343
344			return $this;
345			}
346
347			/**
348			* {@inheritdoc}
349			*/
350			public function setHttpClient(HttpClient $client)
351			{
352			$this->getRequestManager()->setHttpClient($client);
353
354			return $this;
355			}
356
357			/**
358			* @return RequestManager
359			*/
360			protected function getRequestManager()
361			{
362			return $this->requestManager;
363			}
364
365			/**
366			* @return Authenticator
367			*/
368			protected function getAuthenticator()
369			{
370			return $this->authenticator;
371			}
372			}
373

Happyr / LinkedIn-API-client

Push — master ( b65b29...f39982 )

LinkedIn::getLoginUrl() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like