SalesForceClient::getHeaderJsonAndAuthorization() - Code Metrics - Inspection of "Update query builder" - crunch-accounting/salesforce-api-php-wrapper - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#6)

unknown

created 2017-04-20 14:55 UTC

SalesForceClient::getHeaderJsonAndAuthorization() A

↳ Parent: SalesForceClient

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Akeneo\SalesForce\Connector;

use Akeneo\SalesForce\Authentification\AccessToken;
use Akeneo\SalesForce\Authentification\AccessTokenGenerator;
use Akeneo\SalesForce\Exception\AuthenticationException;
use GuzzleHttp\Client as GuzzleClient;
use GuzzleHttp\Exception\RequestException;

/**
 * @author Anael Chardan <[email protected]>
 */
class SalesForceClient
{
    const BASE_API_URL   = '/services/data/v37.0/sobjects';
    const BASE_QUERY_URL = '/services/data/v37.0/query';

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

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

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

    /**
     * @var GuzzleClient
     */
    protected $clientGuzzle;

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

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

    /**
     * @var AccessTokenGenerator
     */
    protected $accessTokenGenerator;

    /**
     * @var AccessToken
     */
    protected $salesForceAccessToken;

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

    /**
     * {@inheritdoc}
     */
    public function __construct(
        string $username,
        string $password,
        string $clientId,
        string $clientSecret,
        string $salesForceLoginUrl,
        GuzzleClient $guzzleClient,
        AccessTokenGenerator $accessTokenGenerator
    ) {
        $this->username             = $username;
        $this->password             = $password;
        $this->clientId             = $clientId;
        $this->clientSecret         = $clientSecret;
        $this->salesforceLoginUrl   = $salesForceLoginUrl;
        $this->clientGuzzle         = $guzzleClient;
        $this->accessTokenGenerator = $accessTokenGenerator;
    }

    public function search($query = null, $nextUrl = null)
    {
        $url = !empty($nextUrl) ?
            sprintf('%s/%s', $this->getBaseUrl(), $nextUrl) :
            sprintf(
                '%s%s/?q=%s',
                $this->getBaseUrl(),
                static::BASE_QUERY_URL,
                urlencode($query)
            )
        ;

        $response = $this->request(HttpWords::GET, $url, $this->getHeaderWithAuthorization());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $data     = json_decode($response->getBody(), true);

        $results = $data['records'];

        if (!$data['done']) {
            $more_results = $this->search(null, substr($data['nextRecordsUrl'], 1));
            if (!empty($more_results)) {
                $results = array_merge($results, $more_results);
            }
        }

        return $results;
    }

    public function getAllRessources()
    {
        $url      = sprintf('%s%s', $this->getBaseUrl(), static::BASE_API_URL);
        $response = $this->request(HttpWords::GET, $url, $this->getHeaderWithAuthorization());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

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

    public function getBasicInformation(string $objectName)

    {
        $url      = sprintf('%s%s/%s', $this->getBaseUrl(), static::BASE_API_URL, $objectName);
        $response = $this->request(HttpWords::GET, $url, $this->getHeaderWithAuthorization());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

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

    public function getDescribedObject(string $objectName)

    {
        $url      = sprintf(
            '%s%s/%s/describe',
            $this->getBaseUrl(),
            static::BASE_API_URL,
            $objectName
        );
        $response = $this->request(HttpWords::GET, $url, $this->getHeaderWithAuthorization());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

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

    public function findById($objectName, $objectId, array $fields = [])

    {
        $url      = sprintf(
            '%s%s/%s/%s?fields=%s',
            $this->getBaseUrl(),
            static::BASE_API_URL,
            $objectName,
            $objectId,
            implode(',', $fields)
        );
        $response = $this->request(HttpWords::GET, $url, $this->getHeaderWithAuthorization());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

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

    public function insert($objectName, array $data = [])

    {
        $url      = sprintf('%s%s/%s/', $this->getBaseUrl(), static::BASE_API_URL, $objectName);
        $response = $this->request(HttpWords::POST, $url, $this->getHeaderWithAuthorizationAndData($data));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

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

    public function upsertByExternalId(

        string $objectName,
        string $externalIdName,
        string $externalIdValue,
        array $data = []
    ) {
        $url      = sprintf(
            '%s%s/%s/%s/%s',
            $this->getBaseUrl(),
            static::BASE_API_URL,
            $objectName,
            $externalIdName,
            $externalIdValue
        );
        $response = $this->request(HttpWords::PATCH, $url, $this->getHeaderWithAuthorizationAndData($data));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

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

    public function update($objectName, $objectId, $data = [])

    {
        $url      = sprintf(
            '%s%s/%s/%s',
            $this->getBaseUrl(),
            static::BASE_API_URL,
            $objectName,
            $objectId
        );
        $response = $this->request(HttpWords::PATCH, $url, $this->getHeaderWithAuthorizationAndData($data));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

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

    public function delete($objectName, $objectId)
    {
        $url = sprintf(
            '%s%s/%s/%s',
            $this->getBaseUrl(),
            static::BASE_API_URL,
            $objectName,
            $objectId
        );

        $this->request(HttpWords::DELETE, $url, $this->getHeaderWithAuthorization());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        return true;
    }

    protected function getBaseUrl()
    {
        if ($this->baseUrl == null) {
            $this->setupToken();
        }

        return $this->baseUrl;
    }

    /**
     * @param AccessToken $accessToken
     */
    public function setAccessToken(AccessToken $accessToken)
    {
        $this->salesForceAccessToken = $accessToken;
        $this->baseUrl               = $accessToken->getApiUrl();
    }

    protected function getHeaderWithAuthorizationAndData(array $data = [])
    {
        return [
            HttpWords::HEADERS => $this->getHeaderJsonAndAuthorization(),
            HttpWords::BODY    => json_encode($data),
        ];
    }

    protected function getHeaderWithAuthorization()
    {
        return [HttpWords::HEADERS => $this->getAuthorizationField()];
    }

    protected function getHeaderJsonAndAuthorization()
    {
        return array_merge([HttpWords::CONTENT_TYPE => HttpWords::APPLICATION_JSON], $this->getAuthorizationField());
    }

    protected function getAuthorizationField()
    {
        $this->setupToken();

        $value = sprintf('%s %s', HttpWords::BEARER, $this->salesForceAccessToken->getAccessToken());

        return [HttpWords::AUTHORIZATION => $value];
    }

    /**
     * Refresh an existing access token.
     *
     * @throws \Exception
     *
     * @return AccessToken
     */
    protected function refreshToken()
    {
        $url = sprintf(
            '%s%s',
            $this->salesforceLoginUrl,
            SalesForceWords::TOKEN_ENDPOINT
        );

        $postData = [
            SalesForceWords::GRANT_TYPE    => SalesForceWords::REFRESH_TOKEN,
            SalesForceWords::CLIENT_ID     => $this->clientId,
            SalesForceWords::CLIENT_SECRET => $this->clientSecret,
            SalesForceWords::REFRESH_TOKEN => $this->salesForceAccessToken->getRefreshToken(),
        ];

        $response = $this->request(HttpWords::POST, $url, [SalesForceWords::FORM_PARAMS => $postData]);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $update = json_decode($response->getBody(), true);
        $this->salesForceAccessToken->updateFromSalesforceRefresh($update);
        $this->baseUrl = $this->salesForceAccessToken->getApiUrl();

        return $this->salesForceAccessToken;
    }

    /**
     * @return AccessToken
     */
    protected function setupToken()
    {
        if ($this->salesForceAccessToken === null) {
            $this->authenticate();

            return;
        }

        if ($this->salesForceAccessToken->needsRefresh()) {
            $this->salesForceAccessToken = $this->refreshToken();
        }
    }

    protected function authenticate()
    {
        $url = sprintf(
            '%s%s',
            $this->salesforceLoginUrl,
            SalesForceWords::TOKEN_ENDPOINT
        );

        $postData = [
            SalesForceWords::GRANT_TYPE    => SalesForceWords::PASSWORD,
            SalesForceWords::CLIENT_ID     => $this->clientId,
            SalesForceWords::CLIENT_SECRET => $this->clientSecret,
            SalesForceWords::USERNAME      => $this->username,
            SalesForceWords::PASSWORD      => $this->password,
        ];

        $response = $this->request(HttpWords::POST, $url, [SalesForceWords::FORM_PARAMS => $postData]);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $this->salesForceAccessToken = $this
            ->accessTokenGenerator
            ->createFromSalesforceResponse(json_decode($response->getBody(), true))
        ;

        $this->baseUrl = $this->salesForceAccessToken->getApiUrl();
    }

    /**
     * @param string $imageUrl
     *
     * @return mixed
     * @throws AuthenticationException
     * @throws \Exception
     */
    public function downloadImageFromUrl(string $imageUrl)
    {
        return $this->request(HttpWords::GET, $imageUrl, $this->getHeaderWithAuthorization());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }


    /**
     * @param string $method
     * @param string $url
     * @param string $data
     *
     * @throws AuthenticationException
     * @throws \Exception
     *
     * @return mixed
     */
    protected function request($method, $url, $data)
    {
        try {
            $response = $this->clientGuzzle->$method($url, $data);

            return $response;
        } catch (RequestException $e) {
            if ($e->getResponse() === null) {
                throw $e;
            }

            $error = json_decode($e->getResponse()->getBody(), true);

            //If its an auth error convert to an auth exception
            if ($e->getResponse()->getStatusCode() == 401) {
                throw new AuthenticationException($error[0]['errorCode'], $error[0]['message']);
            }

            //Invalid data sent to salesforce
            if ($e->getResponse()->getStatusCode() == 400 && $error[0]['errorCode'] == 'DUPLICATES_DETECTED') {
                throw new DuplicateDetectedException($error, $e->getRequest()->getUri());
            }

            throw new \Exception(json_encode([$e->getMessage(), (string) $e->getResponse()->getBody()]));
        }
    }
}


1			<?php
2
3			namespace Akeneo\SalesForce\Connector;
4
5			use Akeneo\SalesForce\Authentification\AccessToken;
6			use Akeneo\SalesForce\Authentification\AccessTokenGenerator;
7			use Akeneo\SalesForce\Exception\AuthenticationException;
8			use GuzzleHttp\Client as GuzzleClient;
9			use GuzzleHttp\Exception\RequestException;
10
11			/**
12			* @author Anael Chardan <[email protected]>
13			*/
14			class SalesForceClient
15			{
16			const BASE_API_URL = '/services/data/v37.0/sobjects';
17			const BASE_QUERY_URL = '/services/data/v37.0/query';
18
19			/**
20			* @var string
21			*/
22			protected $salesforceLoginUrl;
23
24			/**
25			* @var string
26			*/
27			protected $clientId;
28
29			/**
30			* @var string
31			*/
32			protected $clientSecret;
33
34			/**
35			* @var GuzzleClient
36			*/
37			protected $clientGuzzle;
38
39			/**
40			* @var string

crunch-accounting / salesforce-api-php-wrapper

Pull Request — master (#6)

SalesForceClient::getHeaderJsonAndAuthorization() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like