AbstractResponseParserConverter::convertAddressToTransfer() - Code Metrics - Inspection of "MISC change license name" - spryker-eco/amazon-pay - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( a2100c...af4f13 )

by Andrey
created 2018-02-22 09:11 UTC
convertAddressToTransfer() D

↳ Parent: AbstractResponseParserConverter
Complexity

Conditions	8
Paths	128
Size

Total Lines	37
Code Lines	19
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	8
eloc	19
nc	128
nop	1
dl	0
loc	37
rs	4.6666
c	0
b	0
f	0
<?php

/**
 * Apache OSL-2
 * Use of this software requires acceptance of the Evaluation License Agreement. See LICENSE file.
 */

namespace SprykerEco\Zed\Amazonpay\Business\Api\Converter;

use Generated\Shared\Transfer\AddressTransfer;
filter:
    dependency_paths: ["lib/*"]
use Generated\Shared\Transfer\AmazonpayResponseConstraintTransfer;
filter:
    dependency_paths: ["lib/*"]
use Generated\Shared\Transfer\AmazonpayResponseHeaderTransfer;
filter:
    dependency_paths: ["lib/*"]
use PayWithAmazon\ResponseInterface;
use Spryker\Shared\Kernel\Transfer\AbstractTransfer;

abstract class AbstractResponseParserConverter extends AbstractConverter implements ResponseParserConverterInterface
{

    const STATUS_CODE_SUCCESS = 200;

    /**
     * @var string
     */
    protected $resultKeyName;

    /**
     * @return string
     */
    abstract protected function getResponseType();

    /**
     * @return \Spryker\Shared\Kernel\Transfer\AbstractTransfer
     */
    abstract protected function createTransferObject();

    /**
     * @param \Spryker\Shared\Kernel\Transfer\AbstractTransfer $responseTransfer
     * @param \PayWithAmazon\ResponseInterface $responseParser
     *
     * @return \Spryker\Shared\Kernel\Transfer\AbstractTransfer
     */
    protected function setBody(AbstractTransfer $responseTransfer, ResponseInterface $responseParser)
    {
        return $responseTransfer;
    }

    /**
     * @param \Spryker\Shared\Kernel\Transfer\AbstractTransfer $responseTransfer
     * @param \PayWithAmazon\ResponseInterface $responseParser
     *
     * @return \Spryker\Shared\Kernel\Transfer\AbstractTransfer
     */
    protected function setResponseDataToTransfer(AbstractTransfer $responseTransfer, ResponseInterface $responseParser)
    {
        $responseTransfer->setHeader($this->extractHeader($responseParser));
                           setHeader($this->extractHeader($responseParser));
        if ($responseTransfer->getHeader()->getIsSuccess()) {
        if ($responseTransfer->/** @scrutinizer ignore-call */ getHeader()->getIsSuccess()) {
            return $this->setBody($responseTransfer, $responseParser);
        }

        return $responseTransfer;
    }

    /**
     * @param \PayWithAmazon\ResponseInterface $responseParser
     *
     * @return \Spryker\Shared\Kernel\Transfer\AbstractTransfer
     */
    public function convert(ResponseInterface $responseParser)
    {
        return $this->setResponseDataToTransfer($this->createTransferObject(), $responseParser);
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    /**
     * @param \PayWithAmazon\ResponseInterface $responseParser
     *
     * @return array
     */
    protected function extractMetadata(ResponseInterface $responseParser)
    {
        return empty($responseParser->toArray()['ResponseMetadata'])
            ? []
            : $responseParser->toArray()['ResponseMetadata'];
    }

    /**
     * @param \PayWithAmazon\ResponseInterface $responseParser
     *
     * @return int
     */
    protected function extractStatusCode(ResponseInterface $responseParser)
    {
        return (int)$responseParser->toArray()['ResponseStatus'];
    }

    /**
     * @param \PayWithAmazon\ResponseInterface $responseParser
     *
     * @return \Generated\Shared\Transfer\AmazonpayResponseHeaderTransfer
     */
    protected function extractHeader(ResponseInterface $responseParser)
    {
        $statusCode = $this->extractStatusCode($responseParser);
        $metadata = $this->extractMetadata($responseParser);
        $constraints = $this->extractConstraints($responseParser);

        $header = new AmazonpayResponseHeaderTransfer();
        $header->setIsSuccess($this->isSuccess($responseParser));
        $header->setStatusCode($statusCode);

        if ($metadata) {

            $header->setRequestId($metadata['RequestId']);
        }

        if (!empty($responseParser->toArray()['Error'])) {
            $header->setErrorMessage($responseParser->toArray()['Error']['Message']);
            $header->setErrorCode($responseParser->toArray()['Error']['Code']);
            $header->setRequestId($responseParser->toArray()['RequestId']);

            return $header;
        }

        if ($constraints) {

            $header->setConstraints($constraints);
        }

        return $header;
    }

    /**
     * @param \PayWithAmazon\ResponseInterface $responseParser
     *
     * @return bool
     */
    protected function isSuccess(ResponseInterface $responseParser)
    {
        return
            $this->extractStatusCode($responseParser) == self::STATUS_CODE_SUCCESS
            && empty($this->extractConstraints($responseParser));
    }

    /**
     * @param \PayWithAmazon\ResponseInterface $responseParser
     *
     * @return array
     */
    protected function extractResult(ResponseInterface $responseParser)
    {
        $responseType = $this->getResponseType();

        return !empty($responseParser->toArray()[$responseType])
            ? $responseParser->toArray()[$responseType]
            : [];
    }

    /**
     * @param \PayWithAmazon\ResponseInterface $responseParser
     *
     * @return \Generated\Shared\Transfer\AmazonpayResponseConstraintTransfer[]
     */
    protected function extractConstraints(ResponseInterface $responseParser)
    {
        $result = $this->extractResult($responseParser);

        if (empty($result['OrderReferenceDetails']['Constraints'])) {
            return [];
        }

        $constraintTransfers = [];

        if (count($result['OrderReferenceDetails']['Constraints']) === 1) {
            $constraints = array_values($result['OrderReferenceDetails']['Constraints']);
        } else {
            $constraints = $result['OrderReferenceDetails']['Constraints'];
        }

        foreach ($constraints as $constraint) {
            $constraintTransfer = new AmazonpayResponseConstraintTransfer();
            $constraintTransfer->setConstraintId($constraint['ConstraintID']);
            $constraintTransfer->setConstraintId($constraint['Description']);

            $constraintTransfers[] = $constraintTransfer;
        }

        return $constraintTransfers;
    }

    /**
     * @param \PayWithAmazon\ResponseInterface $responseParser
     *
     * @return \Generated\Shared\Transfer\AddressTransfer
     */
    protected function extractShippingAddress(ResponseInterface $responseParser)
    {
        $address = new AddressTransfer();

        if (!$this->isSuccess($responseParser)) {
            return $address;
        }

        $aResponseAddress =
            $this->extractResult($responseParser)['OrderReferenceDetails']['Destination']['PhysicalDestination'];

        return $this->convertAddressToTransfer($aResponseAddress);
    }

    /**
     * @param array $addressData
     *
     * @return \Generated\Shared\Transfer\AddressTransfer
     */
    protected function convertAddressToTransfer(array $addressData)
    {
        $address = new AddressTransfer();

        $address->setCity($addressData['City']);
        $address->setIso2Code($addressData['CountryCode']);
        $address->setZipCode($addressData['PostalCode']);

        if (!empty($addressData['Name'])) {
            $address = $this->updateNameData($address, $addressData['Name']);
        }

        if (!empty($addressData['AddressLine1'])) {
            $address->setAddress1($addressData['AddressLine1']);
                      setAddress1($addressData['AddressLine1']);
        }

        if (!empty($addressData['AddressLine2'])) {
            $address->setAddress2($addressData['AddressLine2']);
                      setAddress2($addressData['AddressLine2']);
        }

        if (!empty($addressData['AddressLine3'])) {
            $address->setAddress3($addressData['AddressLine3']);
                      setAddress3($addressData['AddressLine3']);
        }

        if (!empty($addressData['District'])) {
            $address->setRegion($addressData['District']);
                      setRegion($addressData['District']);
        }

        if (!empty($addressData['StateOrRegion'])) {
            $address->setState($addressData['StateOrRegion']);
                      setState($addressData['StateOrRegion']);
        }

        if (!empty($addressData['Phone'])) {
            $address->setPhone($addressData['Phone']);
                      setPhone($addressData['Phone']);
        }

        return $address;

    }

}

spryker-eco / amazon-pay

Push — master ( a2100c...af4f13 )

convertAddressToTransfer() D

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
