SalesForceClient - Code Metrics - Inspection of "PAPO-1025: create Parameterized Search" - crunch-accounting/salesforce-api-php-wrapper - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#10)

unknown

created 2017-11-22 14:34 UTC

SalesForceClient B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	391
Duplicated Lines	18.16 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

Metric	Value
wmc	38
lcom	1
cbo	7
dl	71
loc	391
rs	8.3999
c	0
b	0
f	0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	17	1
B	search()	0	26	4
A	parameterizedSearch()	0	15	1
A	getAllRessources()	0	7	1
A	getBasicInformation()	7	7	1
A	getDescribedObject()	12	12	1
A	findById()	14	14	1
A	insert()	7	7	1
A	upsertByExternalId()	18	18	1
A	update()	13	13	1
A	delete()	0	14	1
A	getBaseUrl()	0	8	2
A	setAccessToken()	0	5	1
A	getHeaderWithAuthorizationAndData()	0	7	1
A	getHeaderWithAuthorization()	0	4	1
A	getHeaderJsonAndAuthorization()	0	4	1
A	getAuthorizationField()	0	8	1
A	refreshToken()	0	23	1
A	setupToken()	0	12	3
B	authenticate()	0	25	1
A	downloadImageFromUrl()	0	4	1
C	request()	0	34	11

How to fix Duplicated Code

<?php

namespace Akeneo\SalesForce\Connector;

use Akeneo\SalesForce\Authentification\AccessToken;
use Akeneo\SalesForce\Authentification\AccessTokenGenerator;
use Akeneo\SalesForce\Exception\AuthenticationException;
use Akeneo\SalesForce\Exception\DuplicateDetectedException;
use Akeneo\SalesForce\Search\ParameterizedSearchBuilder;
use GuzzleHttp\Client as GuzzleClient;
use Akeneo\SalesForce\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';
    const BASE_SEARCH_URL = '/services/data/v37.0/parameterizedSearch';

    /**
     * @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']; // or $data['searchRecords']


        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 parameterizedSearch(string $query)
    {
        $url = sprintf(
            '%s%s/?q=%s',
            $this->getBaseUrl(),
            static::BASE_SEARCH_URL,
            $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['searchRecords'];

        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 (\GuzzleHttp\Exception\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 (isset($error[0])
                && isset($error[0]['errorCode'])
                && isset($error[0]['message'])
                && $e->getResponse()->getStatusCode() == 401
            ) {
                throw new AuthenticationException($error[0]['errorCode'], $error[0]['message']);
            }

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

            throw new RequestException($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 Akeneo\SalesForce\Exception\DuplicateDetectedException;
9			use Akeneo\SalesForce\Search\ParameterizedSearchBuilder;
10			use GuzzleHttp\Client as GuzzleClient;
11			use Akeneo\SalesForce\Exception\RequestException;
12
13			/**
14			* @author Anael Chardan <[email protected]>
15			*/
16			class SalesForceClient
17			{
18			const BASE_API_URL = '/services/data/v37.0/sobjects';
19			const BASE_QUERY_URL = '/services/data/v37.0/query';
20			const BASE_SEARCH_URL = '/services/data/v37.0/parameterizedSearch';
21
22			/**
23			* @var string
24			*/
25			protected $salesforceLoginUrl;
26
27			/**
28			* @var string
29			*/
30			protected $clientId;
31
32			/**
33			* @var string
34			*/
35			protected $clientSecret;
36
37			/**
38			* @var GuzzleClient
39			*/
40			protected $clientGuzzle;

crunch-accounting / salesforce-api-php-wrapper

Pull Request — master (#10)

SalesForceClient B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

22 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like