CheckoutClient::getLastResponse() - Code Metrics - brucepc/sum-up - Measure and Improve Code Quality continuously with Scrutinizer

CheckoutClient::getLastResponse() A
last analyzed 2018-03-14 02:06 UTC

↳ Parent: CheckoutClient

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10
c	0
b	0
f	0

<?php

namespace BPCI\SumUp\Checkout;

use BPCI\SumUp\ContextInterface;
use BPCI\SumUp\Exception\InvalidCheckoutException;
use BPCI\SumUp\OAuth\AccessToken;
use BPCI\SumUp\SumUp;
use BPCI\SumUp\SumUpClientInterface;
use BPCI\SumUp\Traits\Client;
use BPCI\SumUp\Traits\ClientInterface;
use GuzzleHttp\Exception\BadResponseException;
use GuzzleHttp\Exception\ConnectException;
use Psr\Http\Message\ResponseInterface;

/**
 * Class CheckoutClient
 * @package BPCI\SumUp\Checkout
 */
class CheckoutClient implements CheckoutClientInterface, ClientInterface
{
    use Client {
        request as protected traitRequest;
    }

    protected $context;
    protected $lastResponse;
    protected $options = [];
    protected $currentToken;

    public function __construct(ContextInterface $context, ?array $options = [])
    {
        $this->context = $context;
        $this->options = $options;
    }

    /**
     * @param CheckoutInterface $checkout
     * @param string|null $type
     * @return array
     */
    static function getBody($checkout, string $type = null): array

    {
        $defaultBody = self::getCheckoutBody($checkout);
        switch ($checkout->getType()) {
            case 'card':
                $completeBody = self::getCardBody($checkout);
                break;

            case 'boleto':
                $completeBody = self::getBoletoBody($checkout);
                break;

            default:
                $completeBody = [];
        }

        return array_merge($defaultBody, $completeBody);
    }

    /**
     * Generate a body to create a new checkout
     *
     * @param CheckoutInterface $checkout
     * @return array
     */
    protected static function getCheckoutBody(CheckoutInterface $checkout): array
    {
        return [
            "checkout_reference" => $checkout->getReference(),
            "amount" => $checkout->getAmount(),
            "currency" => $checkout->getCurrency(),
            "fee_amount" => $checkout->getFeeAmount(),
            "pay_to_email" => $checkout->getPayToEmail(),
            "pay_from_email" => $checkout->getPayFromEmail(),
            "description" => $checkout->getDescription(),
            "return_url" => $checkout->getRedirectUrl(),
        ];
    }

    private static function getCardBody(CheckoutInterface $checkout): array
    {
        return [
            'payment_type' => $checkout->getType(),
            'token' => $checkout->getCard()->getToken(),
            'customer_id' => $checkout->getCustomer()->getCustomerId(),
        ];
    }

    private static function getBoletoBody(CheckoutInterface $checkout): array
    {
        $customer = $checkout->getCustomer();

        return [
            'payment_type' => $checkout->getType(),
            'description' => $checkout->getDescription(),
            'boleto_details' => [
//				'cpf_cnpj' => $customer->getCpfCnpj(),
                'payer_name' => $customer->getName(),
                'payer_address' => $customer->getAddress(),
                'payer_city' => $customer->getAddress()->getCity(),
                'payer_state_code' => $customer->getAddress()->getState(),
                'payer_post_code' => $customer->getAddress()->getPostalCode(),
            ],
        ];
    }

    /**
     * @inheritDoc
     */
    static function getScopes(): array

    {
        return [
            'payments',
            'boleto',
        ];
    }

    /**
     * @param CheckoutInterface $checkout
     * @return string
     */
    static function getCompleteUrl(CheckoutInterface $checkout): string

    {
        if ($checkout->getId()) {
            return SumUp::getEntrypoint().$checkout->getId();
        }

        return '';
    }

    /**
     * @inheritDoc
     * @throws BadResponseException
     * @throws ConnectException
     */
    public function create(CheckoutInterface $checkout, AccessToken $accessToken = null):? CheckoutInterface
    {
        return $this->request('post', $checkout) ? $checkout : null;
    }

    /**
     * @param string $action
     * @param CheckoutInterface $checkout
     * @param string|null $endpoint
     * @return bool|null
     */
    public function request(string $action, $checkout, string $endpoint = null):? bool
    {
        if (!$checkout->isValid()) {
            throw new InvalidCheckoutException($checkout);
        }

        return $this->traitRequest($action, $checkout);
    }

    /**
     * @inheritDoc
     * @throws BadResponseException
     * @throws ConnectException
     */
    public function complete(CheckoutInterface $checkout, AccessToken $accessToken = null):? CheckoutInterface
    {
        return $this->request('put', $checkout) ? $checkout : null;
    }

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

    /**
     * @param ResponseInterface $response
     * @return SumUpClientInterface
     */
    public function setLastResponse(ResponseInterface $response): SumUpClientInterface
    {
        $this->lastResponse = $response;

        return $this;
    }

    /**
     * return the context used to created the client.
     * @return ContextInterface
     */
    public function getContext(): ContextInterface
    {
        return $this->context;
    }

    public function getOptions(): array
    {
        return $this->options??[];
    }

    /**
     * @return string
     */
    public function getEndPoint(): string
    {
        return 'checkouts';
    }

    /**
     * @param AccessToken $token
     * @return SumUpClientInterface
     */
    public function setToken(AccessToken $token): SumUpClientInterface
    {
        $this->currentToken = $token;

        return $this;
    }

    /**
     * @return AccessToken
     */
    public function getToken():? AccessToken
    {
        return $this->currentToken;
    }
}


1		<?php
2
3		namespace BPCI\SumUp\Checkout;
4
5		use BPCI\SumUp\ContextInterface;
6		use BPCI\SumUp\Exception\InvalidCheckoutException;
7		use BPCI\SumUp\OAuth\AccessToken;
8		use BPCI\SumUp\SumUp;
9		use BPCI\SumUp\SumUpClientInterface;
10		use BPCI\SumUp\Traits\Client;
11		use BPCI\SumUp\Traits\ClientInterface;
12		use GuzzleHttp\Exception\BadResponseException;
13		use GuzzleHttp\Exception\ConnectException;
14		use Psr\Http\Message\ResponseInterface;
15
16		/**
17		* Class CheckoutClient
18		* @package BPCI\SumUp\Checkout
19		*/
20		class CheckoutClient implements CheckoutClientInterface, ClientInterface
21		{
22		use Client {
23		request as protected traitRequest;
24		}
25
26		protected $context;
27		protected $lastResponse;
28		protected $options = [];
29		protected $currentToken;
30
31	2	public function __construct(ContextInterface $context, ?array $options = [])
32		{
33	2	$this->context = $context;
34	2	$this->options = $options;
35	2	}
36
37		/**
38		* @param CheckoutInterface $checkout
39		* @param string\|null $type
40		* @return array
41		*/
42	2	static function getBody($checkout, string $type = null): array
		0 ignored issues – show Best Practice introduced 2018-03-03 12:44 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
43		{
44	2	$defaultBody = self::getCheckoutBody($checkout);
45	2	switch ($checkout->getType()) {
46	2	case 'card':
47		$completeBody = self::getCardBody($checkout);
48		break;
49
50	2	case 'boleto':
51		$completeBody = self::getBoletoBody($checkout);
52		break;
53
54		default:
55	2	$completeBody = [];
56		}
57
58	2	return array_merge($defaultBody, $completeBody);
59		}
60
61		/**
62		* Generate a body to create a new checkout
63		*
64		* @param CheckoutInterface $checkout
65		* @return array
66		*/
67	2	protected static function getCheckoutBody(CheckoutInterface $checkout): array
68		{
69		return [
70	2	"checkout_reference" => $checkout->getReference(),
71	2	"amount" => $checkout->getAmount(),
72	2	"currency" => $checkout->getCurrency(),
73	2	"fee_amount" => $checkout->getFeeAmount(),
74	2	"pay_to_email" => $checkout->getPayToEmail(),
75	2	"pay_from_email" => $checkout->getPayFromEmail(),
76	2	"description" => $checkout->getDescription(),
77	2	"return_url" => $checkout->getRedirectUrl(),
78		];
79		}
80
81		private static function getCardBody(CheckoutInterface $checkout): array
82		{
83		return [
84		'payment_type' => $checkout->getType(),
85		'token' => $checkout->getCard()->getToken(),
86		'customer_id' => $checkout->getCustomer()->getCustomerId(),
87		];
88		}
89
90		private static function getBoletoBody(CheckoutInterface $checkout): array
91		{
92		$customer = $checkout->getCustomer();
93
94		return [
95		'payment_type' => $checkout->getType(),
96		'description' => $checkout->getDescription(),
97		'boleto_details' => [
98		// 'cpf_cnpj' => $customer->getCpfCnpj(),
99		'payer_name' => $customer->getName(),
100		'payer_address' => $customer->getAddress(),
101		'payer_city' => $customer->getAddress()->getCity(),
102		'payer_state_code' => $customer->getAddress()->getState(),
103		'payer_post_code' => $customer->getAddress()->getPostalCode(),
104		],
105		];
106		}
107
108		/**
109		* @inheritDoc
110		*/
111	2	static function getScopes(): array
		0 ignored issues – show Best Practice introduced 2018-02-25 01:34 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
112		{
113		return [
114	2	'payments',
115		'boleto',
116		];
117		}
118
119		/**
120		* @param CheckoutInterface $checkout
121		* @return string
122		*/
123	1	static function getCompleteUrl(CheckoutInterface $checkout): string
		0 ignored issues – show Best Practice introduced 2018-03-03 12:44 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
124		{
125	1	if ($checkout->getId()) {
126	1	return SumUp::getEntrypoint().$checkout->getId();
127		}
128
129		return '';
130		}
131
132		/**
133		* @inheritDoc
134		* @throws BadResponseException
135		* @throws ConnectException
136		*/
137	1	public function create(CheckoutInterface $checkout, AccessToken $accessToken = null):? CheckoutInterface
138		{
139	1	return $this->request('post', $checkout) ? $checkout : null;
140		}
141
142		/**
143		* @param string $action
144		* @param CheckoutInterface $checkout
145		* @param string\|null $endpoint
146		* @return bool\|null
147		*/
148	2	public function request(string $action, $checkout, string $endpoint = null):? bool
149		{
150	2	if (!$checkout->isValid()) {
151		throw new InvalidCheckoutException($checkout);
152		}
153
154	2	return $this->traitRequest($action, $checkout);
155		}
156
157		/**
158		* @inheritDoc
159		* @throws BadResponseException
160		* @throws ConnectException
161		*/
162	1	public function complete(CheckoutInterface $checkout, AccessToken $accessToken = null):? CheckoutInterface
163		{
164	1	return $this->request('put', $checkout) ? $checkout : null;
165		}
166
167		/**
168		* @return ResponseInterface
169		*/
170	1	public function getLastResponse(): ResponseInterface
171		{
172	1	return $this->lastResponse;
173		}
174
175		/**
176		* @param ResponseInterface $response
177		* @return SumUpClientInterface
178		*/
179	2	public function setLastResponse(ResponseInterface $response): SumUpClientInterface
180		{
181	2	$this->lastResponse = $response;
182
183	2	return $this;
184		}
185
186		/**
187		* return the context used to created the client.
188		* @return ContextInterface
189		*/
190	2	public function getContext(): ContextInterface
191		{
192	2	return $this->context;
193		}
194
195	2	public function getOptions(): array
196		{
197	2	return $this->options??[];
198		}
199
200		/**
201		* @return string
202		*/
203	2	public function getEndPoint(): string
204		{
205	2	return 'checkouts';
206		}
207
208		/**
209		* @param AccessToken $token
210		* @return SumUpClientInterface
211		*/
212	2	public function setToken(AccessToken $token): SumUpClientInterface
213		{
214	2	$this->currentToken = $token;
215
216	2	return $this;
217		}
218
219		/**
220		* @return AccessToken
221		*/
222	2	public function getToken():? AccessToken
223		{
224	2	return $this->currentToken;
225		}
226		}
227

brucepc / sum-up

CheckoutClient::getLastResponse() A last analyzed 2018-03-14 02:06 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

CheckoutClient::getLastResponse() A
last analyzed 2018-03-14 02:06 UTC