CustomerClient::request() - Code Metrics - Inspection of "Add README.md" - brucepc/sum-up - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed
Push — master ( 4c62c0...259020 )

by Bruce Pinheiro de
created 2018-02-25 02:17 UTC
CustomerClient::request() B

↳ Parent: CustomerClient
Complexity

Conditions	4
Paths	6
Size

Total Lines	40
Code Lines	27
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	4
eloc	27
nc	6
nop	4
dl	0
loc	40
rs	8.5806
c	0
b	0
f	0
<?php
namespace BPCI\SumUp\Customer;

use BPCI\SumUp\ContextInterface;
use BPCI\SumUp\Customer\Card\CardInterface;
use BPCI\SumUp\Exception\BadRequestException;
use BPCI\SumUp\Exception\InvalidCustomerException;
use BPCI\SumUp\OAuth\AccessToken;
use BPCI\SumUp\OAuth\AuthenticationHelper;
use BPCI\SumUp\SumUp;
use BPCI\SumUp\Utils\Hydrator;
filter:
    dependency_paths: ["lib/*"]
use Psr\Http\Message\ResponseInterface;

class CustomerClient implements CustomerClientInterface
{
    const ENDPOINT = 'customers';
    protected $context;
    protected $lastResponse;

    /**
	 * CheckoutClientInterface constructor.
	 * @param ContextInterface $context
	 */
	public function __construct(ContextInterface $context)
	{
		$this->context = $context;
	}

    /**
     * @inheritDoc
     * @throws BadRequestException
     */
    public function createCard(CustomerInterface $customer, CardInterface $card, AccessToken $accessToken): ?CardInterface
    {
        //TODO Implement this method

    }

    /**
     * @inheritDoc
     * @throws BadRequestException
     */
    public function getCards(CustomerInterface $custome, AccessToken $accessToken): array
    {
        //TODO Implement this method
    }
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}

    /**
     * @inheritDoc
     * @throws BadRequestException
     */
    public function deleteCard(CustomerInterface $customer, CardInterface $card, AccessToken $accessToken): void
    {
        //TODO Implement this method
    }

    /**
     * @inheritDoc
     * @throws BadRequestException
     * @throws InvalidCustomerException
     */
    public function create(CustomerInterface $customer, AccessToken $accessToken): ?CustomerInterface
    {
        $accessToken = AuthenticationHelper::getValidToken($this->context, $accessToken, self::getScopes());
        self::validateCustomer($customer);
        $client = SumUp::getClient();
        $headers = AuthenticationHelper::getOAuthHeader($accessToken);
        $body = self::getCustomerBody($customer);
        try {
            $response = $client->post(self::ENDPOINT, [
                'headers' => $headers
            ], $body);
            $response = $client->post(self::ENDPOINT, [
            $successul = $response->getStatusCode() === 201;
        } catch(\GuzzleHttp\Exception\RequestException $e){
            throw new BadRequestException(
                $e->getMessage(),
                $e->getRequest(),
                /** @scrutinizer ignore-type */ $e->getRequest(),
                $e->getResponse()
                /** @scrutinizer ignore-type */ $e->getResponse()
            );
        }

        if ($successul) {
            $wrapper = new Hydrator($response);
            $customer = $wrapper->hydrate($customer);
            return $customer;
        }

        return null;
    }

	private function request(string $action, CustomerInterface $customer, AccessToken $accessToken, array $scopes):? CustomerInterface
	{
		$accessToken = AuthenticationHelper::getValidToken(
			$this->context,
			$accessToken,
			$scopes??self::getScopes()
		);

		$client = SumUp::getClient();
		$options = AuthenticationHelper::getOAuthHeader($accessToken);
		$options['form_params'] = self::getCustomerBody($customer);

		$successCode=200;
		$uri = self::ENDPOINT . '/' . $customer->getCustomerId();
		switch (true){
			case $action==='create': {
				$action='post';
				$successCode=201;
				$uri = self::ENDPOINT;
				break;
			}
			case $action==='complete': {
				$action='put';
				break;
			}
			default:{
				$action='get';
				break;
			}
		}

		/** @var ResponseInterface $response */
		$response = $client->{$action}($uri, $options);
		$this->lastResponse = $response;
		if($successCode===$response->getStatusCode()){
			$wrapper = new Hydrator($response);
			return $wrapper->hydrate($customer);
		}

		return null;
	}

    /**
     * Validate an customer
     *
     * @param CustomerInterface $customer
     * @return void
     * @throws InvalidCustomerException
     */
    private static function validateCustomer(CustomerInterface $customer): void
    {
        if (!$customer->isValid()) {
            throw new InvalidCustomerException('Ops! Something is wrong with this CustomerInterface Instance');
        }
    }

    public static function getCustomerBody(CustomerInterface $customer): array
    {
        $customerBody = [
            'personal_details' => [
                'name' => $customer->getName(),
                'phone' => $customer->getPhone(),
                'address' => [
                    'line1' => $customer->getAddress()->getLine1(),
                    'line2' => $customer->getAddress()->getLine2(),
                    'country' => $customer->getAddress()->getCountry(),
                    'postal_code' => $customer->getAddress()->getPostalCode(),
                    'city' => $customer->getAddress()->getCity(),
                    'state' => $customer->getAddress()->getState(),
                ],
            ],
        ];

        if ($customer->getCustomerId() !== null) {
            $customerBody['customer_id'] = $customer->getCustomerId();
        }

        return $customerBody;
    }

    public function setContext(ContextInterface $context): CustomerClientInterface
	{
		$this->context = $context;
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
	}

    /**
     * @inheritDoc
     */
    public static function getScopes(): array
    {
        return [
            'payment_instruments',
        ];
    }

	function getLastResponse(): ResponseInterface

	{
		return $this->lastResponse;
	}


	/**
	 * return the context used to created the client.
	 * @return ContextInterface
	 */
	function getContext(): ContextInterface

	{
		// TODO: Implement getContext() method.
	}
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
}

brucepc / sum-up

Push — master ( 4c62c0...259020 )

CustomerClient::request() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
