AbstractApi.php

Go to the documentation of this file.

<?php
declare(strict_types=1);

namespace Magento\Paypal\Model\Api;

use Magento\Payment\Helper\Formatter;
use Magento\Payment\Model\Method\Logger;

abstract class AbstractApi extends \Magento\Framework\DataObject
{
    use Formatter;

    protected $_config;

    protected $_globalMap = [];

    protected $_exportToRequestFilters = [];

    protected $_importFromRequestFilters = [];

    protected $_lineItemExportItemsFormat = [];

    protected $_lineItemExportItemsFilters = [
        'name' => 'strval'
    ];

    protected $_lineItemTotalExportMap = [];

    protected $_cart;

    protected $_shippingOptionsExportItemsFormat = [];

    protected $_debugReplacePrivateDataKeys = [];

    protected $_customerAddress;

    protected $_logger;

    protected $customLogger;

    protected $_localeResolver;

    protected $_regionFactory;

    public function __construct(
        \Magento\Customer\Helper\Address $customerAddress,
        \Psr\Log\LoggerInterface $logger,
        Logger $customLogger,
        \Magento\Framework\Locale\ResolverInterface $localeResolver,
        \Magento\Directory\Model\RegionFactory $regionFactory,
        array $data = []
    ) {
        $this->_customerAddress = $customerAddress;
        $this->_logger = $logger;
        $this->customLogger = $customLogger;
        $this->_localeResolver = $localeResolver;
        $this->_regionFactory = $regionFactory;
        parent::__construct($data);
    }

    public function getApiUsername()
    {
        return $this->_config->getValue('apiUsername');
    }

    public function getApiPassword()
    {
        return $this->_config->getValue('apiPassword');
    }

    public function getApiSignature()
    {
        return $this->_config->getValue('apiSignature');
    }

    public function getApiCertificate()
    {
        return $this->_config->getApiCertificate();
    }

    public function getBuildNotationCode()
    {
        return $this->_config->getBuildNotationCode();
    }

    public function getUseProxy()
    {
        return $this->_getDataOrConfig('use_proxy', false);
    }

    public function getProxyHost()
    {
        return $this->_getDataOrConfig('proxy_host', '127.0.0.1');
    }

    public function getProxyPort()
    {
        return $this->_getDataOrConfig('proxy_port', '808');
    }

    public function getPageStyle()
    {
        return $this->_getDataOrConfig('page_style');
    }

    public function getHdrimg()
    {
        return $this->_getDataOrConfig('paypal_hdrimg');
    }

    public function getHdrbordercolor()
    {
        return $this->_getDataOrConfig('paypal_hdrbordercolor');
    }

    public function getHdrbackcolor()
    {
        return $this->_getDataOrConfig('paypal_hdrbackcolor');
    }

    public function getPayflowcolor()
    {
        return $this->_getDataOrConfig('paypal_payflowcolor');
    }

    public function getPaymentAction()
    {
        return $this->_getDataOrConfig('payment_action');
    }

    public function getBusinessAccount()
    {
        return $this->_getDataOrConfig('business_account');
    }

    public function import($to, array $publicMap = [])
    {
        return \Magento\Framework\DataObject\Mapper::accumulateByMap([$this, 'getDataUsingMethod'], $to, $publicMap);
    }

    public function export($from, array $publicMap = [])
    {
        \Magento\Framework\DataObject\Mapper::accumulateByMap($from, [$this, 'setDataUsingMethod'], $publicMap);
        return $this;
    }

    public function setPaypalCart(\Magento\Paypal\Model\Cart $cart)
    {
        $this->_cart = $cart;
        return $this;
    }

    public function setConfigObject(\Magento\Paypal\Model\Config $config)
    {
        $this->_config = $config;
        return $this;
    }

    public function getLocale()
    {
        return $this->_localeResolver->getLocale();
    }

    public function getFraudManagementFiltersEnabled()
    {
        return 1;
    }

    protected function &_exportToRequest(array $privateRequestMap, array $request = [])
    {
        $map = [];
        foreach ($privateRequestMap as $key) {
            if (isset($this->_globalMap[$key])) {
                $map[$this->_globalMap[$key]] = $key;
            }
        }
        $result = \Magento\Framework\DataObject\Mapper::accumulateByMap([$this, 'getDataUsingMethod'], $request, $map);
        foreach ($privateRequestMap as $key) {
            if (isset($this->_exportToRequestFilters[$key]) && isset($result[$key])) {
                $callback = $this->_exportToRequestFilters[$key];
                $privateKey = $result[$key];
                $publicKey = $map[$this->_globalMap[$key]];
                $result[$key] = call_user_func([$this, $callback], $privateKey, $publicKey);
            }
        }
        return $result;
    }

    protected function _importFromResponse(array $privateResponseMap, array $response)
    {
        $map = [];
        foreach ($privateResponseMap as $key) {
            if (isset($this->_globalMap[$key])) {
                $map[$key] = $this->_globalMap[$key];
            }
            if (isset($response[$key]) && isset($this->_importFromRequestFilters[$key])) {
                $callback = $this->_importFromRequestFilters[$key];
                $response[$key] = call_user_func([$this, $callback], $response[$key], $key, $map[$key]);
            }
        }
        \Magento\Framework\DataObject\Mapper::accumulateByMap($response, [$this, 'setDataUsingMethod'], $map);
    }

    protected function _exportLineItems(array &$request, $i = 0)
    {
        if (!$this->_cart) {
            return;
        }

        // always add cart totals, even if line items are not requested
        if ($this->_lineItemTotalExportMap) {
            foreach ($this->_cart->getAmounts() as $key => $total) {
                if (isset($this->_lineItemTotalExportMap[$key])) {
                    // !empty($total)
                    $privateKey = $this->_lineItemTotalExportMap[$key];
                    $total = round($total, 2);
                    $request[$privateKey] = $this->formatPrice($total);
                }
            }
        }

        // add cart line items
        $items = $this->_cart->getAllItems();
        if (empty($items) || !$this->getIsLineItemsEnabled()) {
            return;
        }
        $result = null;
        foreach ($items as $item) {
            foreach ($this->_lineItemExportItemsFormat as $publicKey => $privateFormat) {
                $result = true;
                $value = $item->getDataUsingMethod($publicKey);
                $request[sprintf($privateFormat, $i)] = $this->formatValue($value, $publicKey);
            }
            $i++;
        }
        return $result;
    }

    protected function _exportShippingOptions(array &$request, $i = 0)
    {
        $options = $this->getShippingOptions();
        if (empty($options)) {
            return false;
        }
        foreach ($options as $option) {
            foreach ($this->_shippingOptionsExportItemsFormat as $publicKey => $privateFormat) {
                $value = $option->getDataUsingMethod($publicKey);
                if (is_float($value)) {
                    $value = $this->formatPrice($value);
                }
                if (is_bool($value)) {
                    $value = $this->_filterBool($value);
                }
                $request[sprintf($privateFormat, $i)] = $value;
            }
            $i++;
        }
        return true;
    }

    protected function _filterBool($value)
    {
        return $value ? 'true' : 'false';
    }

    protected function _filterInt($value)
    {
        return (int)$value;
    }

    protected function _getDataOrConfig($key, $default = null)
    {
        if ($this->hasData($key)) {
            return $this->getData($key);
        }
        return $this->_config->getValue($key) ? $this->_config->getValue($key) : $default;
    }

    protected function _lookupRegionCodeFromAddress(\Magento\Framework\DataObject $address)
    {
        $regionId = $address->getData('region_id');
        if ($regionId) {
            $region = $this->_regionFactory->create()->load($regionId);
            if ($region->getId()) {
                return $region->getCode();
            }
        }
        return '';
    }

    protected function _importStreetFromAddress(\Magento\Framework\DataObject $address, array &$to)
    {
        $keys = func_get_args();
        array_shift($keys);
        array_shift($keys);
        $street = $address->getStreet();
        if (!$keys || !$street || !is_array($street)) {
            return;
        }

        $street = $this->_customerAddress->convertStreetLines($address->getStreet(), count($keys));

        $i = 0;
        foreach ($keys as $key) {
            $to[$key] = isset($street[$i]) ? $street[$i] : '';
            $i++;
        }
    }

    protected function _buildQuery($request)
    {
        return http_build_query($request);
    }

    protected function _filterQty($value)
    {
        return intval($value);
    }

    protected function _debug($debugData)
    {
        $this->customLogger->debug(
            $debugData,
            (array)$this->getDebugReplacePrivateDataKeys(),
            (bool)$this->getDebugFlag()
        );
    }

    public function getDebugFlag()
    {
        return $this->_config->getValue('debug');
    }

    public function getUseCertAuthentication()
    {
        return (bool)$this->_config->getValue('apiAuthentication');
    }

    public function getDebugReplacePrivateDataKeys()
    {
        return $this->_debugReplacePrivateDataKeys;
    }

    private function formatValue($value, $publicKey)
    {
        if (!empty($this->_lineItemExportItemsFilters[$publicKey])) {
            $callback = $this->_lineItemExportItemsFilters[$publicKey];
            $value = method_exists($this, $callback) ? $this->{$callback}($value) : $callback($value);
        }

        if (is_float($value)) {
            $value = $this->formatPrice($value);
        }

        return $value;
    }
}