PreCheckTransaction::getBillingAddress() - Code Metrics - spryker-eco/braintree - Measure and Improve Code Quality continuously with Scrutinizer

PreCheckTransaction::getBillingAddress() A
last analyzed 2021-05-04 10:05 UTC

↳ Parent: PreCheckTransaction
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
rs	10
c	0
b	0
f	0
<?php

/**
 * MIT License
 * For full license information, please view the LICENSE file that was distributed with this source code.
 */

namespace SprykerEco\Zed\Braintree\Business\Payment\Transaction;

use Braintree\PaymentInstrumentType;
use Braintree\Transaction as BraintreeTransaction;
use Generated\Shared\Transfer\AddressTransfer;
filter:
    dependency_paths: ["lib/*"]
use Generated\Shared\Transfer\PaymentTransfer;
filter:
    dependency_paths: ["lib/*"]
use SprykerEco\Shared\Braintree\BraintreeConfig as SharedBraintreeConfig;
use SprykerEco\Zed\Braintree\BraintreeConfig;
use SprykerEco\Zed\Braintree\Business\Payment\Method\ApiConstants;
use SprykerEco\Zed\Braintree\Dependency\Facade\BraintreeToMoneyFacadeInterface;

class PreCheckTransaction extends AbstractTransaction
{
    /**
     * @var \SprykerEco\Zed\Braintree\Dependency\Facade\BraintreeToMoneyFacadeInterface
     */
    protected $moneyFacade;

    /**
     * @param \SprykerEco\Zed\Braintree\BraintreeConfig $brainTreeConfig
     * @param \SprykerEco\Zed\Braintree\Dependency\Facade\BraintreeToMoneyFacadeInterface $moneyFacade
     */
    public function __construct(BraintreeConfig $brainTreeConfig, BraintreeToMoneyFacadeInterface $moneyFacade)
    {
        parent::__construct($brainTreeConfig);

        $this->moneyFacade = $moneyFacade;
    }

    /**
     * @return string
     */
    protected function getTransactionType()
    {
        return ApiConstants::SALE;
    }

    /**
     * PreCheck has no transaction code defined by braintree, added for logging purposes.
     *
     * @return string
     */
    protected function getTransactionCode()
    {
        return ApiConstants::STATUS_CODE_PRE_CHECK;
    }

    /**
     * @return \Braintree\Result\Error|\Braintree\Result\Successful|\Braintree\Transaction
     */
    protected function doTransaction()
    {
        $requestData = $this->getRequestData();

        return $this->preCheck($requestData);
    }

    /**
     * @param array $requestData
     *
     * @return \Braintree\Result\Error|\Braintree\Result\Successful|\Braintree\Transaction
     */
    protected function preCheck(array $requestData)
    {
        return BraintreeTransaction::sale($requestData);
    }

    /**
     * @return array
     */
    protected function getRequestData()
    {
        return [
            'amount' => $this->getAmount(),
            'paymentMethodNonce' => $this->getNonce(),
            'options' => $this->getRequestOptions(),
            'customer' => $this->getCustomerData(),
            'billing' => $this->getCustomerAddressData($this->getBillingAddress()),
            'shipping' => $this->getCustomerAddressData($this->getShippingAddress()),
            'channel' => $this->config->getChannel(),
        ];
    }

    /**
     * @return array
     */
    protected function getRequestOptions()
    {
        return [
            'threeDSecure' => [
                'required' => $this->config->getIs3DSecure(),
            ],
            'storeInVault' => $this->config->getIsVaulted(),
        ];
    }

    /**
     * @return array
     */
    protected function getCustomerData()
    {
        $customerTransfer = $this->getCustomer();
        $billingAddressTransfer = $this->getBillingAddress();

        return [
            'firstName' => $customerTransfer->getFirstName(),
            'lastName' => $customerTransfer->getLastName(),
            'email' => $customerTransfer->getEmail(),
            'company' => $billingAddressTransfer->getCompany(),
            'phone' => $billingAddressTransfer->getPhone(),
        ];
    }

    /**
     * @param \Generated\Shared\Transfer\AddressTransfer $addressTransfer
     *
     * @return array
     */
    protected function getCustomerAddressData(AddressTransfer $addressTransfer)
    {
        return [
            'firstName' => $addressTransfer->getFirstName(),
            'lastName' => $addressTransfer->getLastName(),
            'company' => $addressTransfer->getCompany(),
            'streetAddress' => trim(sprintf('%s %s', $addressTransfer->getAddress1(), $addressTransfer->getAddress2())),
            'extendedAddress' => $addressTransfer->getAddress3(),
            'locality' => $addressTransfer->getCity(),
            'region' => $addressTransfer->getRegion(),
            'postalCode' => $addressTransfer->getZipCode(),
            'countryCodeAlpha2' => $addressTransfer->getIso2Code(),
        ];
    }

    /**
     * @return float
     */
    protected function getAmount()
    {
        $grandTotal = $this->getQuote()->requireTotals()->getTotals()->getGrandTotal();

        return $this->moneyFacade->convertIntegerToDecimal($grandTotal);
    }

    /**
     * @return string
     */
    protected function getNonce()
    {
        return $this->getBraintreePayment()->requireNonce()->getNonce();
    }

    /**
     * @return \Generated\Shared\Transfer\BraintreePaymentTransfer
filter:
    dependency_paths: ["lib/*"]
     */
    protected function getBraintreePayment()
    {
        return $this->getPayment()->requireBraintree()->getBraintree();
    }

    /**
     * @return string
     */
    protected function getPaymentSelection()
    {
        return $this->getPayment()->requirePaymentSelection()->getPaymentSelection();
    }

    /**
     * Customer is not required for guest checkout, so no `requireCustomer()`
     *
     * @return \Generated\Shared\Transfer\CustomerTransfer
filter:
    dependency_paths: ["lib/*"]
     */
    protected function getCustomer()
    {
        return $this->getQuote()->getCustomer();
    }

    /**
     * @return \Generated\Shared\Transfer\PaymentTransfer
     */
    protected function getPayment()
    {
        return $this->getQuote()->requirePayment()->getPayment();
    }

    /**
     * @return \Generated\Shared\Transfer\QuoteTransfer
filter:
    dependency_paths: ["lib/*"]
     */
    protected function getQuote()
    {
        return $this->transactionMetaTransfer->requireQuote()->getQuote();
    }

    /**
     * @return \Generated\Shared\Transfer\AddressTransfer
     */
    protected function getBillingAddress()
    {
        return $this->getQuote()->requireBillingAddress()->getBillingAddress();
    }

    /**
     * @return \Generated\Shared\Transfer\AddressTransfer
     */
    protected function getShippingAddress()
    {
        return $this->getQuote()->requireShippingAddress()->getShippingAddress();
    }

    /**
     * Prevent logging
     *
     * @return void
     */
    protected function beforeTransaction()
    {
    }

    /**
     * @param \Braintree\Result\Successful|\Braintree\Result\Error|\Braintree\Transaction $response
     *
     * @return \Generated\Shared\Transfer\BraintreeTransactionResponseTransfer
filter:
    dependency_paths: ["lib/*"]
     */
    protected function afterTransaction($response)
    {
        if ($this->isTransactionSuccessful($response)) {
            $this->updatePaymentForSuccessfulResponse($response);
            $this->updatePaymentForSuccessfulResponse(/** @scrutinizer ignore-type */ $response);
            $transaction = $response->transaction;
            $braintreeTransactionResponseTransfer = $this->getSuccessResponseTransfer($response);
            $braintreeTransactionResponseTransfer = $this->getSuccessResponseTransfer(/** @scrutinizer ignore-type */ $response);
            $braintreeTransactionResponseTransfer->setCode($transaction->processorSettlementResponseCode);
            $braintreeTransactionResponseTransfer->setCreditCardType($transaction->creditCardDetails->cardType);
            $braintreeTransactionResponseTransfer->setPaymentType($transaction->paymentInstrumentType);

            return $braintreeTransactionResponseTransfer;
        }

        $this->updatePaymentForErrorResponse($response);
        $this->updatePaymentForErrorResponse(/** @scrutinizer ignore-type */ $response);

        $braintreeTransactionResponseTransfer = $this->getErrorResponseTransfer($response);
        $braintreeTransactionResponseTransfer = $this->getErrorResponseTransfer(/** @scrutinizer ignore-type */ $response);

        return $braintreeTransactionResponseTransfer;
    }

    /**
     * @param \Braintree\Result\Successful|\Braintree\Result\Error|\Braintree\Transaction $response
     *
     * @return bool
     */
    protected function isTransactionSuccessful($response)
    {
        return ($response->success && $this->isValidPaymentType($response));
        return ($response->success && $this->isValidPaymentType(/** @scrutinizer ignore-type */ $response));
    }

    /**
     * @param \Braintree\Result\Successful $response
     *
     * @return void
     */
    protected function updatePaymentForSuccessfulResponse($response)
    {
        $braintreePaymentTransfer = $this->getBraintreePayment();
        $braintreePaymentTransfer->setPaymentType($response->transaction->paymentInstrumentType);

        if ($braintreePaymentTransfer->getPaymentType() === PaymentInstrumentType::PAYPAL_ACCOUNT) {
            $this->setPaypalPaymentMethod($this->getPayment());
        } elseif ($braintreePaymentTransfer->getPaymentType() === PaymentInstrumentType::CREDIT_CARD) {
            $this->setCreditCardMethod($this->getPayment());
        }
    }

    /**
     * When error occurs unset nonce, so this cannot be used anymore
     *
     * @param \Braintree\Result\Error $response
     *
     * @return void
     */
    protected function updatePaymentForErrorResponse($response)
    protected function updatePaymentForErrorResponse(/** @scrutinizer ignore-unused */ $response)
    {
        $this->getBraintreePayment()->setNonce('');
    }

    /**
     * @param \Braintree\Result\Successful $response
     *
     * @return bool
     */
    protected function isValidPaymentType($response)
    {
        $returnedType = $response->transaction->paymentInstrumentType;

        $matching = [
            SharedBraintreeConfig::PAYMENT_METHOD_PAY_PAL => PaymentInstrumentType::PAYPAL_ACCOUNT,
            SharedBraintreeConfig::PAYMENT_METHOD_CREDIT_CARD => PaymentInstrumentType::CREDIT_CARD,
            SharedBraintreeConfig::PAYMENT_METHOD_PAY_PAL_EXPRESS => PaymentInstrumentType::PAYPAL_ACCOUNT,
        ];

        return ($matching[$this->getPaymentSelection()] === $returnedType);
    }

    /**
     * @param \Generated\Shared\Transfer\PaymentTransfer $paymentTransfer
     *
     * @return \Generated\Shared\Transfer\PaymentTransfer
     */
    protected function setPaypalPaymentMethod(PaymentTransfer $paymentTransfer): PaymentTransfer
    {
        $paymentTransfer->setPaymentProvider(SharedBraintreeConfig::PROVIDER_NAME);
        $paymentTransfer->setPaymentMethod(PaymentTransfer::BRAINTREE_PAY_PAL);

        if ($this->transactionMetaTransfer->getQuote()->getPayment()->getPaymentSelection() === PaymentTransfer::BRAINTREE_PAY_PAL_EXPRESS) {
            $paymentTransfer->setPaymentMethod(PaymentTransfer::BRAINTREE_PAY_PAL_EXPRESS);
            $paymentTransfer->setPaymentSelection(PaymentTransfer::BRAINTREE_PAY_PAL_EXPRESS);
        }

        return $paymentTransfer;
    }

    /**
     * @param \Generated\Shared\Transfer\PaymentTransfer $paymentTransfer
     *
     * @return \Generated\Shared\Transfer\PaymentTransfer
     */
    protected function setCreditCardMethod(PaymentTransfer $paymentTransfer): PaymentTransfer
    {
        $paymentTransfer->setPaymentMethod(PaymentTransfer::BRAINTREE_CREDIT_CARD);
        $paymentTransfer->setPaymentProvider(SharedBraintreeConfig::PROVIDER_NAME);
        $paymentTransfer->setPaymentSelection(PaymentTransfer::BRAINTREE_CREDIT_CARD);

        return $paymentTransfer;
    }
}

spryker-eco / braintree

PreCheckTransaction::getBillingAddress() A last analyzed 2021-05-04 10:05 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

PreCheckTransaction::getBillingAddress() A
last analyzed 2021-05-04 10:05 UTC
