Transaction::toAuthorizeTransactionArray() - Code Metrics - greenlystapp/basecommerce-php - Measure and Improve Code Quality continuously with Scrutinizer

Transaction::toAuthorizeTransactionArray() A
last analyzed 2019-09-21 07:12 UTC

↳ Parent: Transaction

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

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

<?php

declare(strict_types=1);

namespace Greenlyst\BaseCommerce\Models;

use function ArrayHelpers\array_get;
use function ArrayHelpers\array_set;
use Carbon\Carbon;
use Greenlyst\BaseCommerce\ClientException;
use Greenlyst\BaseCommerce\Core\Helpers;
use Greenlyst\BaseCommerce\LogicException;
use Greenlyst\BaseCommerce\Traits\HasClient;
use Greenlyst\BaseCommerce\Traits\HasErrorMessages;

final class Transaction
{
    use HasClient, HasErrorMessages;

    private $transactionId;
    private $status;
    private $authorizationDate;
    private $capturedDate;
    private $amount;
    private $taxAmount;
    private $tipAmount;
    private $transactionType;
    private $responseCode;
    private $responseMessage;
    private $card;

    const TRANSACTION_STATUS_FAILED = 'FAILED';
    const TRANSACTION_STATUS_CREATED = 'CREATED';
    const TRANSACTION_STATUS_AUTHORIZED = 'AUTHORIZED';
    const TRANSACTION_STATUS_CAPTURED = 'CAPTURED';
    const TRANSACTION_STATUS_SETTLED = 'SETTLED';
    const TRANSACTION_STATUS_VOIDED = 'VOIDED';
    const TRANSACTION_STATUS_DECLINED = 'DECLINED';
    const TRANSACTION_STATUS_3D_SECURE = '3DSECURE';
    const TRANSACTION_STATUS_VERIFIED = 'VERIFIED';

    const TRANSACTION_TYPE_AUTHORIZE = 'AUTH';
    const TRANSACTION_TYPE_CAPTURE = 'CAPTURE';
    const TRANSACTION_TYPE_CREDIT = 'CREDIT';
    const TRANSACTION_TYPE_REFUND = 'REFUND';
    const TRANSACTION_TYPE_SALE = 'SALE';
    const TRANSACTION_TYPE_VOID = 'VOID';

    const URI_CARD_TRANSACTION = '/pcms/?f=API_processBankCardTransactionV4';

    /**
     * @return mixed
     */
    public function getTransactionId()
    {
        return $this->transactionId;
    }

    /**
     * @param mixed $transactionId
     */
    public function setTransactionId($transactionId): void
    {
        $this->transactionId = $transactionId;
    }

    /**
     * @return mixed
     */
    public function getStatus()
    {
        return $this->status;
    }

    /**
     * @param mixed $status
     */
    public function setStatus($status): void
    {
        $this->status = $status;
    }

    /**
     * @return mixed
     */
    public function getAuthorizationDate()
    {
        return $this->authorizationDate;
    }

    /**
     * @param mixed $authorizationDate
     */
    public function setAuthorizationDate($authorizationDate): void
    {
        $this->authorizationDate = $authorizationDate;
    }

    /**
     * @return mixed
     */
    public function getCapturedDate()
    {
        return $this->capturedDate;
    }

    /**
     * @param mixed $capturedDate
     */
    public function setCapturedDate($capturedDate): void
    {
        $this->capturedDate = $capturedDate;
    }

    /**
     * @return mixed
     */
    public function getAmount()
    {
        return $this->amount;
    }

    /**
     * @param mixed $amount
     */
    public function setAmount($amount): void
    {
        $this->amount = $amount;
    }

    /**
     * @return mixed
     */
    public function getTaxAmount()
    {
        return $this->taxAmount;
    }

    /**
     * @param mixed $taxAmount
     */
    public function setTaxAmount($taxAmount): void
    {
        $this->taxAmount = $taxAmount;
    }

    /**
     * @return mixed
     */
    public function getTipAmount()
    {
        return $this->tipAmount;
    }

    /**
     * @param mixed $tipAmount
     */
    public function setTipAmount($tipAmount): void
    {
        $this->tipAmount = $tipAmount;
    }

    /**
     * @return mixed
     */
    public function getTransactionType()
    {
        return $this->transactionType;
    }

    /**
     * @param mixed $transactionType
     */
    public function setTransactionType($transactionType): void
    {
        $this->transactionType = $transactionType;
    }

    /**
     * @return mixed
     */
    public function getResponseCode()
    {
        return $this->responseCode;
    }

    /**
     * @param mixed $responseCode
     */
    public function setResponseCode($responseCode): void
    {
        $this->responseCode = $responseCode;
    }

    /**
     * @return mixed
     */
    public function getResponseMessage()
    {
        return $this->responseMessage;
    }

    /**
     * @param mixed $responseMessage
     */
    public function setResponseMessage($responseMessage): void
    {
        $this->responseMessage = $responseMessage;
    }

    /**
     * @return Card
     */
    public function getCard()
    {
        return $this->card;
    }

    /**
     * @param Card $card
     */
    public function setCard($card): void
    {
        $this->card = $card;
    }

    public function isVaultTransaction()
    {
        if ($this->getCard() !== null) {
            return !empty($this->getCard()->getToken());
        }

        //TODO: Do the same for ACH Bank Account Token as well
        return false;
    }

    public function isCardTransaction()
    {
        return $this->getCard() !== null;
    }

    /**
     * @throws LogicException
     * @throws ClientException
     */
    public function authorize()
    {
        if ($this->isVaultTransaction()) {
            Helpers::validateArray($this->toAuthorizeTransactionArray(), ['bank_card_transaction_type', 'token', 'bank_card_transaction_amount']);
        } else {
            Helpers::validateArray($this->toAuthorizeTransactionArray(), [
                'bank_card_transaction_name', 'bank_card_transaction_card_number', 'bank_card_transaction_expiration_month',
                'bank_card_transaction_expiration_year', 'bank_card_transaction_type', 'bank_card_transaction_amount',
            ]);
        }

        return $this->processTransaction($this->toAuthorizeTransactionArray());
    }

    /**
     * @throws ClientException
     * @throws LogicException
     *
     * @return $this
     */
    public function capture()
    {
        Helpers::validateArray($this->toCaptureTransactionArray(), ['bank_card_transaction_id', 'bank_card_transaction_amount', 'bank_card_transaction_type']);

        return $this->processTransaction($this->toCaptureTransactionArray());
    }

    /**
     * @throws LogicException
     * @throws ClientException
     */
    public function createSale()
    {
        if ($this->isVaultTransaction()) {
            Helpers::validateArray($this->toCreateTransactionArray(), ['bank_card_transaction_type', 'token', 'bank_card_transaction_amount']);
        } else {
            Helpers::validateArray($this->toCreateTransactionArray(), [
                'bank_card_transaction_name', 'bank_card_transaction_card_number', 'bank_card_transaction_expiration_month',
                'bank_card_transaction_expiration_year', 'bank_card_transaction_type', 'bank_card_transaction_amount',
            ]);
        }

        return $this->processTransaction($this->toCreateTransactionArray());
    }

    /**
     * @throws LogicException
     * @throws ClientException
     */
    public function refundSale()
    {
        Helpers::validateArray($this->toRefundTransactionArray(), ['bank_card_transaction_id', 'bank_card_transaction_amount', 'bank_card_transaction_type']);

        return $this->processTransaction($this->toRefundTransactionArray());
    }

    /**
     * @param $data
     *
     * @throws ClientException
     *
     * @return $this
     */
    private function processTransaction($data)
    {
        $response = $this->client->postRequest(self::URI_CARD_TRANSACTION, json_encode($data));

        $instance = $this->fromArray($response['bank_card_transaction']);

        $instance->handleMessages($response);

        return $instance;
    }

    /**
     * @return array
     */
    private function toRefundTransactionArray(): array
    {
        return clear_array([
            'bank_card_transaction_id'     => $this->getTransactionId(),
            'bank_card_transaction_amount' => $this->getAmount(),
            'bank_card_transaction_type'   => self::TRANSACTION_TYPE_REFUND,
        ]);
    }

    private function toCaptureTransactionArray(): array
    {
        $data = $this->toRefundTransactionArray();

        array_set($data, 'bank_card_transaction_type', self::TRANSACTION_TYPE_CAPTURE);

        return $data;
    }

    /**
     * @throws LogicException
     *
     * @return array
     */
    private function toCreateTransactionArray(): array
    {
        if ($this->isCardTransaction()) {
            if ($this->isVaultTransaction()) {
                return clear_array([
                    'bank_card_transaction_type'   => self::TRANSACTION_TYPE_SALE,
                    'token'                        => $this->getCard()->getToken(),
                    'bank_card_transaction_amount' => $this->getAmount(),
                ]);
            } else {
                return clear_array([
                    'bank_card_transaction_name'             => $this->getCard()->getName(),
                    'bank_card_transaction_card_number'      => $this->getCard()->getCardNumber(),
                    'bank_card_transaction_expiration_month' => $this->getCard()->getCardExpirationMonth(),
                    'bank_card_transaction_expiration_year'  => $this->getCard()->getCardExpirationYear(),
                    'bank_card_transaction_billing_address'  => $this->getCard()->getBillingAddress() ? $this->getCard()->getBillingAddress()->toArray() : null,
                    'bank_card_transaction_type'             => self::TRANSACTION_TYPE_SALE,
                    'bank_card_transaction_amount'           => $this->getAmount(),
                ]);
            }
        } else {
            throw LogicException::pendingImplementation('ACH Bank Transaction implementation');
        }
    }

    /**
     * @throws LogicException
     *
     * @return array
     */
    private function toAuthorizeTransactionArray(): array
    {
        if ($this->isCardTransaction()) {
            $data = $this->toCreateTransactionArray();

            array_set($data, 'bank_card_transaction_type', self::TRANSACTION_TYPE_AUTHORIZE);

            return $data;
        } else {
            throw LogicException::methodCallNotSupported('ACH Processing');
        }
    }

    private function fromArray(array $data)
    {
        $instance = new static();

        $instance->setTransactionId(array_get($data, 'bank_card_transaction_id'));
        $instance->setStatus(array_get($data, 'bank_card_transaction_status.bank_card_transaction_status_name'));
        $instance->setAmount(array_get($data, 'bank_card_transaction_amount', 0));
        $instance->setTipAmount(array_get($data, 'bank_card_transaction_tip_amount', 0));
        $instance->setTaxAmount(array_get($data, 'bank_card_transaction_tax_amount', 0));
        $instance->setAuthorizationDate(Carbon::parse(array_get($data, 'bank_card_transaction_authorization_date'))->toDateTime());
        $instance->setCapturedDate(Carbon::parse(array_get($data, 'bank_card_transaction_capture_date'))->toDateTime());
        $instance->setTransactionType(array_get($data, 'bank_card_transaction_type.bank_card_transaction_type_name'));
        $instance->setResponseCode(array_get($data, 'bank_card_transaction_response_code'));
        $instance->setResponseMessage(array_get($data, 'bank_card_transaction_response_message'));

        return $instance;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Greenlyst\BaseCommerce\Models;
6
7			use function ArrayHelpers\array_get;
8			use function ArrayHelpers\array_set;
9			use Carbon\Carbon;
10			use Greenlyst\BaseCommerce\ClientException;
11			use Greenlyst\BaseCommerce\Core\Helpers;
12			use Greenlyst\BaseCommerce\LogicException;
13			use Greenlyst\BaseCommerce\Traits\HasClient;
14			use Greenlyst\BaseCommerce\Traits\HasErrorMessages;
15
16			final class Transaction
17			{
18			use HasClient, HasErrorMessages;
19
20			private $transactionId;
21			private $status;
22			private $authorizationDate;
23			private $capturedDate;
24			private $amount;
25			private $taxAmount;
26			private $tipAmount;
27			private $transactionType;
28			private $responseCode;
29			private $responseMessage;
30			private $card;
31
32			const TRANSACTION_STATUS_FAILED = 'FAILED';
33			const TRANSACTION_STATUS_CREATED = 'CREATED';
34			const TRANSACTION_STATUS_AUTHORIZED = 'AUTHORIZED';
35			const TRANSACTION_STATUS_CAPTURED = 'CAPTURED';
36			const TRANSACTION_STATUS_SETTLED = 'SETTLED';
37			const TRANSACTION_STATUS_VOIDED = 'VOIDED';
38			const TRANSACTION_STATUS_DECLINED = 'DECLINED';
39			const TRANSACTION_STATUS_3D_SECURE = '3DSECURE';
40			const TRANSACTION_STATUS_VERIFIED = 'VERIFIED';
41
42			const TRANSACTION_TYPE_AUTHORIZE = 'AUTH';
43			const TRANSACTION_TYPE_CAPTURE = 'CAPTURE';
44			const TRANSACTION_TYPE_CREDIT = 'CREDIT';
45			const TRANSACTION_TYPE_REFUND = 'REFUND';
46			const TRANSACTION_TYPE_SALE = 'SALE';
47			const TRANSACTION_TYPE_VOID = 'VOID';
48
49			const URI_CARD_TRANSACTION = '/pcms/?f=API_processBankCardTransactionV4';
50
51			/**
52			* @return mixed
53			*/
54			public function getTransactionId()
55			{
56			return $this->transactionId;
57			}
58
59			/**
60			* @param mixed $transactionId
61			*/
62			public function setTransactionId($transactionId): void
63			{
64			$this->transactionId = $transactionId;
65			}
66
67			/**
68			* @return mixed
69			*/
70			public function getStatus()
71			{
72			return $this->status;
73			}
74
75			/**
76			* @param mixed $status
77			*/
78			public function setStatus($status): void
79			{
80			$this->status = $status;
81			}
82
83			/**
84			* @return mixed
85			*/
86			public function getAuthorizationDate()
87			{
88			return $this->authorizationDate;
89			}
90
91			/**
92			* @param mixed $authorizationDate
93			*/
94			public function setAuthorizationDate($authorizationDate): void
95			{
96			$this->authorizationDate = $authorizationDate;
97			}
98
99			/**
100			* @return mixed
101			*/
102			public function getCapturedDate()
103			{
104			return $this->capturedDate;
105			}
106
107			/**
108			* @param mixed $capturedDate
109			*/
110			public function setCapturedDate($capturedDate): void
111			{
112			$this->capturedDate = $capturedDate;
113			}
114
115			/**
116			* @return mixed
117			*/
118			public function getAmount()
119			{
120			return $this->amount;
121			}
122
123			/**
124			* @param mixed $amount
125			*/
126			public function setAmount($amount): void
127			{
128			$this->amount = $amount;
129			}
130
131			/**
132			* @return mixed
133			*/
134			public function getTaxAmount()
135			{
136			return $this->taxAmount;
137			}
138
139			/**
140			* @param mixed $taxAmount
141			*/
142			public function setTaxAmount($taxAmount): void
143			{
144			$this->taxAmount = $taxAmount;
145			}
146
147			/**
148			* @return mixed
149			*/
150			public function getTipAmount()
151			{
152			return $this->tipAmount;
153			}
154
155			/**
156			* @param mixed $tipAmount
157			*/
158			public function setTipAmount($tipAmount): void
159			{
160			$this->tipAmount = $tipAmount;
161			}
162
163			/**
164			* @return mixed
165			*/
166			public function getTransactionType()
167			{
168			return $this->transactionType;
169			}
170
171			/**
172			* @param mixed $transactionType
173			*/
174			public function setTransactionType($transactionType): void
175			{
176			$this->transactionType = $transactionType;
177			}
178
179			/**
180			* @return mixed
181			*/
182			public function getResponseCode()
183			{
184			return $this->responseCode;
185			}
186
187			/**
188			* @param mixed $responseCode
189			*/
190			public function setResponseCode($responseCode): void
191			{
192			$this->responseCode = $responseCode;
193			}
194
195			/**
196			* @return mixed
197			*/
198			public function getResponseMessage()
199			{
200			return $this->responseMessage;
201			}
202
203			/**
204			* @param mixed $responseMessage
205			*/
206			public function setResponseMessage($responseMessage): void
207			{
208			$this->responseMessage = $responseMessage;
209			}
210
211			/**
212			* @return Card
213			*/
214			public function getCard()
215			{
216			return $this->card;
217			}
218
219			/**
220			* @param Card $card
221			*/
222			public function setCard($card): void
223			{
224			$this->card = $card;
225			}
226
227			public function isVaultTransaction()
228			{
229			if ($this->getCard() !== null) {
230			return !empty($this->getCard()->getToken());
231			}
232
233			//TODO: Do the same for ACH Bank Account Token as well
234			return false;
235			}
236
237			public function isCardTransaction()
238			{
239			return $this->getCard() !== null;
240			}
241
242			/**
243			* @throws LogicException
244			* @throws ClientException
245			*/
246			public function authorize()
247			{
248			if ($this->isVaultTransaction()) {
249			Helpers::validateArray($this->toAuthorizeTransactionArray(), ['bank_card_transaction_type', 'token', 'bank_card_transaction_amount']);
250			} else {
251			Helpers::validateArray($this->toAuthorizeTransactionArray(), [
252			'bank_card_transaction_name', 'bank_card_transaction_card_number', 'bank_card_transaction_expiration_month',
253			'bank_card_transaction_expiration_year', 'bank_card_transaction_type', 'bank_card_transaction_amount',
254			]);
255			}
256
257			return $this->processTransaction($this->toAuthorizeTransactionArray());
258			}
259
260			/**
261			* @throws ClientException
262			* @throws LogicException
263			*
264			* @return $this
265			*/
266			public function capture()
267			{
268			Helpers::validateArray($this->toCaptureTransactionArray(), ['bank_card_transaction_id', 'bank_card_transaction_amount', 'bank_card_transaction_type']);
269
270			return $this->processTransaction($this->toCaptureTransactionArray());
271			}
272
273			/**
274			* @throws LogicException
275			* @throws ClientException
276			*/
277			public function createSale()
278			{
279			if ($this->isVaultTransaction()) {
280			Helpers::validateArray($this->toCreateTransactionArray(), ['bank_card_transaction_type', 'token', 'bank_card_transaction_amount']);
281			} else {
282			Helpers::validateArray($this->toCreateTransactionArray(), [
283			'bank_card_transaction_name', 'bank_card_transaction_card_number', 'bank_card_transaction_expiration_month',
284			'bank_card_transaction_expiration_year', 'bank_card_transaction_type', 'bank_card_transaction_amount',
285			]);
286			}
287
288			return $this->processTransaction($this->toCreateTransactionArray());
289			}
290
291			/**
292			* @throws LogicException
293			* @throws ClientException
294			*/
295			public function refundSale()
296			{
297			Helpers::validateArray($this->toRefundTransactionArray(), ['bank_card_transaction_id', 'bank_card_transaction_amount', 'bank_card_transaction_type']);
298
299			return $this->processTransaction($this->toRefundTransactionArray());
300			}
301
302			/**
303			* @param $data
304			*
305			* @throws ClientException
306			*
307			* @return $this
308			*/
309			private function processTransaction($data)
310			{
311			$response = $this->client->postRequest(self::URI_CARD_TRANSACTION, json_encode($data));
312
313			$instance = $this->fromArray($response['bank_card_transaction']);
314
315			$instance->handleMessages($response);
316
317			return $instance;
318			}
319
320			/**
321			* @return array
322			*/
323			private function toRefundTransactionArray(): array
324			{
325			return clear_array([
326			'bank_card_transaction_id' => $this->getTransactionId(),
327			'bank_card_transaction_amount' => $this->getAmount(),
328			'bank_card_transaction_type' => self::TRANSACTION_TYPE_REFUND,
329			]);
330			}
331
332			private function toCaptureTransactionArray(): array
333			{
334			$data = $this->toRefundTransactionArray();
335
336			array_set($data, 'bank_card_transaction_type', self::TRANSACTION_TYPE_CAPTURE);
337
338			return $data;
339			}
340
341			/**
342			* @throws LogicException
343			*
344			* @return array
345			*/
346			private function toCreateTransactionArray(): array
347			{
348			if ($this->isCardTransaction()) {
349			if ($this->isVaultTransaction()) {
350			return clear_array([
351			'bank_card_transaction_type' => self::TRANSACTION_TYPE_SALE,
352			'token' => $this->getCard()->getToken(),
353			'bank_card_transaction_amount' => $this->getAmount(),
354			]);
355			} else {
356			return clear_array([
357			'bank_card_transaction_name' => $this->getCard()->getName(),
358			'bank_card_transaction_card_number' => $this->getCard()->getCardNumber(),
359			'bank_card_transaction_expiration_month' => $this->getCard()->getCardExpirationMonth(),
360			'bank_card_transaction_expiration_year' => $this->getCard()->getCardExpirationYear(),
361			'bank_card_transaction_billing_address' => $this->getCard()->getBillingAddress() ? $this->getCard()->getBillingAddress()->toArray() : null,
362			'bank_card_transaction_type' => self::TRANSACTION_TYPE_SALE,
363			'bank_card_transaction_amount' => $this->getAmount(),
364			]);
365			}
366			} else {
367			throw LogicException::pendingImplementation('ACH Bank Transaction implementation');
368			}
369			}
370
371			/**
372			* @throws LogicException
373			*
374			* @return array
375			*/
376			private function toAuthorizeTransactionArray(): array
377			{
378			if ($this->isCardTransaction()) {
379			$data = $this->toCreateTransactionArray();
380
381			array_set($data, 'bank_card_transaction_type', self::TRANSACTION_TYPE_AUTHORIZE);
382
383			return $data;
384			} else {
385			throw LogicException::methodCallNotSupported('ACH Processing');
386			}
387			}
388
389			private function fromArray(array $data)
390			{
391			$instance = new static();
392
393			$instance->setTransactionId(array_get($data, 'bank_card_transaction_id'));
394			$instance->setStatus(array_get($data, 'bank_card_transaction_status.bank_card_transaction_status_name'));
395			$instance->setAmount(array_get($data, 'bank_card_transaction_amount', 0));
396			$instance->setTipAmount(array_get($data, 'bank_card_transaction_tip_amount', 0));
397			$instance->setTaxAmount(array_get($data, 'bank_card_transaction_tax_amount', 0));
398			$instance->setAuthorizationDate(Carbon::parse(array_get($data, 'bank_card_transaction_authorization_date'))->toDateTime());
399			$instance->setCapturedDate(Carbon::parse(array_get($data, 'bank_card_transaction_capture_date'))->toDateTime());
400			$instance->setTransactionType(array_get($data, 'bank_card_transaction_type.bank_card_transaction_type_name'));
401			$instance->setResponseCode(array_get($data, 'bank_card_transaction_response_code'));
402			$instance->setResponseMessage(array_get($data, 'bank_card_transaction_response_message'));
403
404			return $instance;
405			}
406			}
407

greenlystapp / basecommerce-php

Transaction::toAuthorizeTransactionArray() A last analyzed 2019-09-21 07:12 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Transaction::toAuthorizeTransactionArray() A
last analyzed 2019-09-21 07:12 UTC