AbstractMapper::getCaptureType() - Code Metrics - Inspection of "Merge branch 'feature/eco-3623-payone-pay-u-poland..." - spryker-eco/computop - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — bugfix/cc-14473-computop-notif... ( c35c28...8de63e )

by Roman
created 2021-09-17 08:06 UTC
AbstractMapper::getCaptureType() A

↳ Parent: AbstractMapper
Complexity

Conditions	1
Paths	1
Size

Total Lines	5
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

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

/**
 * MIT License
 * Use of this software requires acceptance of the Evaluation License Agreement. See LICENSE file.
 */

namespace SprykerEco\Yves\Computop\Mapper\Init;

use Generated\Shared\Transfer\AddressTransfer;
filter:
    dependency_paths: ["lib/*"]
use Generated\Shared\Transfer\ComputopAddressLineTransfer;
filter:
    dependency_paths: ["lib/*"]
use Generated\Shared\Transfer\ComputopAddressTransfer;
filter:
    dependency_paths: ["lib/*"]
use Generated\Shared\Transfer\ComputopApiRequestTransfer;
filter:
    dependency_paths: ["lib/*"]
use Generated\Shared\Transfer\ComputopCountryTransfer;
filter:
    dependency_paths: ["lib/*"]
use Generated\Shared\Transfer\CountryCollectionTransfer;
filter:
    dependency_paths: ["lib/*"]
use Generated\Shared\Transfer\CountryTransfer;
filter:
    dependency_paths: ["lib/*"]
use Generated\Shared\Transfer\QuoteTransfer;
filter:
    dependency_paths: ["lib/*"]
use Spryker\Shared\Kernel\Transfer\TransferInterface;
use Spryker\Yves\Router\Router\Router;
use Spryker\Yves\Router\Router\RouterInterface;
use SprykerEco\Service\ComputopApi\ComputopApiServiceInterface;
use SprykerEco\Shared\Computop\Config\ComputopApiConfig;
use SprykerEco\Yves\Computop\ComputopConfig;
use SprykerEco\Yves\Computop\ComputopConfigInterface;
use SprykerEco\Yves\Computop\Dependency\Client\ComputopToCountryClientInterface;
use SprykerEco\Yves\Computop\Dependency\ComputopToStoreInterface;
use SprykerEco\Yves\Computop\Dependency\Service\ComputopToUtilEncodingServiceInterface;
use SprykerEco\Yves\Computop\Plugin\Router\ComputopRouteProviderPlugin;
use Symfony\Component\HttpFoundation\Request;

abstract class AbstractMapper implements MapperInterface
{
    /**
     * @var \SprykerEco\Service\ComputopApi\ComputopApiServiceInterface
     */
    protected $computopApiService;

    /**
     * @var \Spryker\Yves\Router\Router\RouterInterface
     */
    protected $router;

    /**
     * @var \SprykerEco\Yves\Computop\Dependency\ComputopToStoreInterface
     */
    protected $store;

    /**
     * @var \SprykerEco\Yves\Computop\ComputopConfigInterface
     */
    protected $config;

    /**
     * @var \Symfony\Component\HttpFoundation\Request
     */
    protected $request;

    /**
     * @var \SprykerEco\Yves\Computop\Dependency\Service\ComputopToUtilEncodingServiceInterface
     */
    protected $utilEncodingService;

    /**
     * @var \SprykerEco\Yves\Computop\Dependency\Client\ComputopToCountryClientInterface
     */
    protected $countryClient;

    /**
     * @var array
     */
    protected $decryptedValues;

    /**
     * @param \Generated\Shared\Transfer\QuoteTransfer $quoteTransfer
     *
     * @return \Spryker\Shared\Kernel\Transfer\TransferInterface
     */
    abstract protected function createTransferWithUnencryptedValues(QuoteTransfer $quoteTransfer);

    /**
     * @param \SprykerEco\Service\ComputopApi\ComputopApiServiceInterface $computopApiService
     * @param \Spryker\Yves\Router\Router\RouterInterface $router
     * @param \SprykerEco\Yves\Computop\Dependency\ComputopToStoreInterface $store
     * @param \SprykerEco\Yves\Computop\ComputopConfigInterface $config
     * @param \Symfony\Component\HttpFoundation\Request $request
     * @param \SprykerEco\Yves\Computop\Dependency\Service\ComputopToUtilEncodingServiceInterface $utilEncodingService
     * @param \SprykerEco\Yves\Computop\Dependency\Client\ComputopToCountryClientInterface $countryClient
     */
    public function __construct(
        ComputopApiServiceInterface $computopApiService,
        RouterInterface $router,
        ComputopToStoreInterface $store,
        ComputopConfigInterface $config,
        Request $request,
        ComputopToUtilEncodingServiceInterface $utilEncodingService,
        ComputopToCountryClientInterface $countryClient
    ) {
        $this->computopApiService = $computopApiService;
        $this->router = $router;
        $this->store = $store;
        $this->config = $config;
        $this->request = $request;
        $this->utilEncodingService = $utilEncodingService;
        $this->countryClient = $countryClient;
    }

    /**
     * @param \Generated\Shared\Transfer\QuoteTransfer $quoteTransfer
     *
     * @return \Spryker\Shared\Kernel\Transfer\TransferInterface
     */
    public function createComputopPaymentTransfer(QuoteTransfer $quoteTransfer)
    {
        /** @var \Generated\Shared\Transfer\ComputopCreditCardPaymentTransfer $computopPaymentTransfer */
        $computopPaymentTransfer = $this->createTransferWithUnencryptedValues($quoteTransfer);
        $computopPaymentTransfer->setMerchantId($this->config->getMerchantId());
        $computopPaymentTransfer->setAmount($quoteTransfer->getTotals()->getGrandTotal());
        $computopPaymentTransfer->setCurrency($this->store->getCurrencyIsoCode());
        if ($quoteTransfer->getCurrency() && $quoteTransfer->getCurrency()->getCode() !== $computopPaymentTransfer->getCurrency()) {
            $computopPaymentTransfer->setCurrency($quoteTransfer->getCurrency()->getCode());
        }
        $computopPaymentTransfer->setResponse(ComputopConfig::RESPONSE_ENCRYPT_TYPE);
        $computopPaymentTransfer->setClientIp($this->getClientIp());
        $computopPaymentTransfer->setReqId($this->computopApiService->generateReqIdFromQuoteTransfer($quoteTransfer));
        $computopPaymentTransfer->setUrlFailure(
            $this->router->generate(ComputopRouteProviderPlugin::FAILURE_PATH_NAME, [], Router::ABSOLUTE_URL)
        );
        $computopPaymentTransfer->setUrlNotify(
            $this->router->generate(ComputopRouteProviderPlugin::NOTIFY_PATH_NAME, [], Router::ABSOLUTE_URL)
        );
        $computopPaymentTransfer->setShippingZip($this->getZipCode($quoteTransfer));

        return $computopPaymentTransfer;
    }

    /**
     * @param \Generated\Shared\Transfer\QuoteTransfer $quoteTransfer
     *
     * @return string
     */
    protected function generateTransId(QuoteTransfer $quoteTransfer)
    {
        return $this->computopApiService->generateTransId($quoteTransfer);
    }

    /**
     * @param \Generated\Shared\Transfer\QuoteTransfer $quoteTransfer
     * @param int $limit
     *
     * @return string
     */
    protected function getLimitedTransId(QuoteTransfer $quoteTransfer, $limit)
    {
        return substr($this->generateTransId($quoteTransfer), 0, $limit);
    }

    /**
     * @param string $path
     *
     * @return string
     */
    protected function getAbsoluteUrl($path)
    {
        return $this->config->getBaseUrlSsl() . $path;
    }

    /**
     * @return string
     */
    protected function getClientIp()
    {
        return $this->request->getClientIp();
    }

    /**
     * @param string $url
     * @param array $queryData
     *
     * @return string
     */
    protected function getActionUrl($url, $queryData)
    {
        return $url . '?' . http_build_query($queryData);
    }

    /**
     * @param string $merchantId
     * @param string $data
     * @param int $length
     *
     * @return array
     */
    protected function getQueryParameters($merchantId, $data, $length)
    {
        return [
            ComputopApiConfig::MERCHANT_ID => $merchantId,
            ComputopApiConfig::DATA => $data,
            ComputopApiConfig::LENGTH => $length,
            ComputopApiConfig::URL_BACK => $this->router->generate(
                $this->config->getCallbackFailureRedirectPath(),
                [],
                Router::ABSOLUTE_URL
            ),
        ];
    }

    /**
     * @param \Spryker\Shared\Kernel\Transfer\TransferInterface $computopPaymentTransfer
     *
     * @return \Generated\Shared\Transfer\ComputopApiRequestTransfer
     */
    protected function createRequestTransfer(TransferInterface $computopPaymentTransfer)
    {
        return (new ComputopApiRequestTransfer())
            ->fromArray($computopPaymentTransfer->toArray(), true);
    }

    /**
     * @param string $method
     *
     * @return string
     */
    protected function getCaptureType(string $method): string
    {
        $paymentMethodsCaptureTypes = $this->config->getPaymentMethodsCaptureTypes();

        return $paymentMethodsCaptureTypes[$method] ?? '';
    }

    /**
     * @param \Generated\Shared\Transfer\QuoteTransfer $quoteTransfer
     *
     * @return string
     */
    protected function getZipCode(QuoteTransfer $quoteTransfer): string
    {
        if ($quoteTransfer->getBillingSameAsShipping()) {
            return $quoteTransfer->getBillingAddress()->getZipCode();
        }

        $addressTransfer = $this->getShippingAddressFromQuote($quoteTransfer);

        return $addressTransfer->getZipCode();
    }

    /**
     * @param array $requestParameterData
     *
     * @return string
     */
    protected function encodeRequestParameterData(array $requestParameterData): string
    {
        $requestParameterData = $this->removeRedundantParams($requestParameterData);

        return base64_encode($this->utilEncodingService->encodeJson($requestParameterData));
        return base64_encode(/** @scrutinizer ignore-type */ $this->utilEncodingService->encodeJson($requestParameterData));
    }

    /**
     * @param array $data
     *
     * @return array
     */
    protected function removeRedundantParams(array $data): array
    {
        $data = array_filter($data);

        foreach ($data as $key => $value) {
            if (is_array($value)) {
                $data[$key] = $this->removeRedundantParams($value);
            }
        }

        return $data;
    }

    /**
     * @param \Generated\Shared\Transfer\QuoteTransfer $quoteTransfer
     *
     * @return \Generated\Shared\Transfer\AddressTransfer
     */
    protected function getShippingAddressFromQuote(QuoteTransfer $quoteTransfer): AddressTransfer
    {
        foreach ($quoteTransfer->getItems() as $itemTransfer) {
            if ($itemTransfer->getShipment() && $itemTransfer->getShipment()->getShippingAddress()) {
                return $itemTransfer->getShipment()->getShippingAddress();
            }
        }

        return $quoteTransfer->getShippingAddressOrFail();
    }

    /**
     * @param \Generated\Shared\Transfer\AddressTransfer $addressTransfer
     *
     * @return \Generated\Shared\Transfer\ComputopCountryTransfer
     */
    protected function getComputopCountryTransferFromQuote(AddressTransfer $addressTransfer): ComputopCountryTransfer
    {
        $countryTransfer = (new CountryTransfer())
            ->setIso2Code($addressTransfer->getIso2Code());

        $countryCollectionTransfer = (new CountryCollectionTransfer())
            ->addCountries($countryTransfer);

        $countryCollectionTransfer = $this->countryClient->findCountriesByIso2Codes($countryCollectionTransfer);

        return (new ComputopCountryTransfer())
            ->setCountryA3($countryCollectionTransfer->getCountries()->offsetGet(0)->getIso3Code());
    }

    /**
     * @param \Generated\Shared\Transfer\AddressTransfer $addressTransfer
     *
     * @return \Generated\Shared\Transfer\ComputopAddressTransfer
     */
    protected function getComputopAddressTransferByAddressTransfer(AddressTransfer $addressTransfer): ComputopAddressTransfer
    {
        $computopAddressLineTransfer = (new ComputopAddressLineTransfer())
            ->setStreet($addressTransfer->getAddress1())
            ->setStreetNumber($addressTransfer->getAddress2());

        return (new ComputopAddressTransfer())
            ->setCity($addressTransfer->getCity())
            ->setCountry($this->getComputopCountryTransferFromQuote($addressTransfer))
            ->setAddressLine1($computopAddressLineTransfer)
            ->setPostalCode($addressTransfer->getZipCode());
    }
}

spryker-eco / computop

Push — bugfix/cc-14473-computop-notif... ( c35c28...8de63e )

AbstractMapper::getCaptureType() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
