vendor/omnipay/common/src/Common/Message/AbstractRequest.php

<?php
namespace Omnipay\Common\Message;
 
use Money\Currencies\ISOCurrencies;
use Money\Currency;
use Money\Formatter\DecimalMoneyFormatter;
use Money\Money;
use Money\Number;
use Money\Parser\DecimalMoneyParser;
use Omnipay\Common\CreditCard;
use Omnipay\Common\Exception\InvalidRequestException;
use Omnipay\Common\Exception\RuntimeException;
use Omnipay\Common\Helper;
use Omnipay\Common\Http\Client;
use Omnipay\Common\Http\ClientInterface;
use Omnipay\Common\ItemBag;
use Omnipay\Common\ParametersTrait;
use Symfony\Component\HttpFoundation\ParameterBag;
use Symfony\Component\HttpFoundation\Request as HttpRequest;
 
abstract class AbstractRequest implements RequestInterface
{
    use ParametersTrait {
        setParameter as traitSetParameter;
    }
 
    protected $httpClient;
 
    protected $httpRequest;
 
    protected $response;
 
    protected $currencies;
 
    protected $zeroAmountAllowed = true;
 
    protected $negativeAmountAllowed = false;
 
    public function __construct(ClientInterface $httpClient, HttpRequest $httpRequest)
    {
        $this->httpClient = $httpClient;
        $this->httpRequest = $httpRequest;
        $this->initialize();
    }
 
    public function initialize(array $parameters = array())
    {
        if (null !== $this->response) {
            throw new RuntimeException('Request cannot be modified after it has been sent!');
        }
 
        $this->parameters = new ParameterBag;
 
        Helper::initialize($this, $parameters);
 
        return $this;
    }
 
    protected function setParameter($key, $value)
    {
        if (null !== $this->response) {
            throw new RuntimeException('Request cannot be modified after it has been sent!');
        }
 
        return $this->traitSetParameter($key, $value);
    }
 
    public function getTestMode()
    {
        return $this->getParameter('testMode');
    }
 
    public function setTestMode($value)
    {
        return $this->setParameter('testMode', $value);
    }
 
    public function getCard()
    {
        return $this->getParameter('card');
    }
 
    public function setCard($value)
    {
        if ($value && !$value instanceof CreditCard) {
            $value = new CreditCard($value);
        }
 
        return $this->setParameter('card', $value);
    }
 
    public function getToken()
    {
        return $this->getParameter('token');
    }
 
    public function setToken($value)
    {
        return $this->setParameter('token', $value);
    }
 
    public function getCardReference()
    {
        return $this->getParameter('cardReference');
    }
 
    public function setCardReference($value)
    {
        return $this->setParameter('cardReference', $value);
    }
 
    protected function getCurrencies()
    {
        if ($this->currencies === null) {
            $this->currencies = new ISOCurrencies();
        }
 
        return $this->currencies;
    }
 
    private function getMoney($amount = null)
    {
        $currencyCode = $this->getCurrency() ?: 'USD';
        $currency = new Currency($currencyCode);
 
        $amount = $amount !== null ? $amount : $this->getParameter('amount');
 
        if ($amount === null) {
            return null;
        } elseif ($amount instanceof Money) {
            $money = $amount;
        } elseif (is_integer($amount)) {
            $money = new Money($amount, $currency);
        } else {
            $moneyParser = new DecimalMoneyParser($this->getCurrencies());
 
            $number = Number::fromString($amount);
 
            // Check for rounding that may occur if too many significant decimal digits are supplied.
            $decimal_count = strlen($number->getFractionalPart());
            $subunit = $this->getCurrencies()->subunitFor($currency);
            if ($decimal_count > $subunit) {
                throw new InvalidRequestException('Amount precision is too high for currency.');
            }
 
            $money = $moneyParser->parse((string) $number, $currency);
        }
 
        // Check for a negative amount.
        if (!$this->negativeAmountAllowed && $money->isNegative()) {
            throw new InvalidRequestException('A negative amount is not allowed.');
        }
 
        // Check for a zero amount.
        if (!$this->zeroAmountAllowed && $money->isZero()) {
            throw new InvalidRequestException('A zero amount is not allowed.');
        }
 
        return $money;
    }
 
    public function getAmount()
    {
        $money = $this->getMoney();
 
        if ($money !== null) {
            $moneyFormatter = new DecimalMoneyFormatter($this->getCurrencies());
 
            return $moneyFormatter->format($money);
        }
    }
 
    public function setAmount($value)
    {
        return $this->setParameter('amount', $value !== null ? (string) $value : null);
    }
 
    public function getAmountInteger()
    {
        $money = $this->getMoney();
 
        if ($money !== null) {
            return (int) $money->getAmount();
        }
    }
 
    public function setAmountInteger($value)
    {
        return $this->setParameter('amount', (int) $value);
    }
 
    public function setMoney(Money $value)
    {
        $currency = $value->getCurrency()->getCode();
 
        $this->setCurrency($currency);
 
        return $this->setParameter('amount', $value);
    }
 
    public function getCurrency()
    {
        return $this->getParameter('currency');
    }
 
    public function setCurrency($value)
    {
        if ($value !== null) {
            $value = strtoupper($value);
        }
        return $this->setParameter('currency', $value);
    }
 
    public function getCurrencyNumeric()
    {
        if (! $this->getCurrency()) {
            return null;
        }
 
        $currency = new Currency($this->getCurrency());
 
        if ($this->getCurrencies()->contains($currency)) {
            return (string) $this->getCurrencies()->numericCodeFor($currency);
        }
    }
 
    public function getCurrencyDecimalPlaces()
    {
        if ($this->getCurrency()) {
            $currency = new Currency($this->getCurrency());
            if ($this->getCurrencies()->contains($currency)) {
                return $this->getCurrencies()->subunitFor($currency);
            }
        }
 
        return 2;
    }
 
    public function formatCurrency($amount)
    {
        $money = $this->getMoney((string) $amount);
        $formatter = new DecimalMoneyFormatter($this->getCurrencies());
 
        return $formatter->format($money);
    }
 
    public function getDescription()
    {
        return $this->getParameter('description');
    }
 
    public function setDescription($value)
    {
        return $this->setParameter('description', $value);
    }
 
    public function getTransactionId()
    {
        return $this->getParameter('transactionId');
    }
 
    public function setTransactionId($value)
    {
        return $this->setParameter('transactionId', $value);
    }
 
    public function getTransactionReference()
    {
        return $this->getParameter('transactionReference');
    }
 
    public function setTransactionReference($value)
    {
        return $this->setParameter('transactionReference', $value);
    }
 
    public function getItems()
    {
        return $this->getParameter('items');
    }
 
    public function setItems($items)
    {
        if ($items && !$items instanceof ItemBag) {
            $items = new ItemBag($items);
        }
 
        return $this->setParameter('items', $items);
    }
 
    public function getClientIp()
    {
        return $this->getParameter('clientIp');
    }
 
    public function setClientIp($value)
    {
        return $this->setParameter('clientIp', $value);
    }
 
    public function getReturnUrl()
    {
        return $this->getParameter('returnUrl');
    }
 
    public function setReturnUrl($value)
    {
        return $this->setParameter('returnUrl', $value);
    }
 
    public function getCancelUrl()
    {
        return $this->getParameter('cancelUrl');
    }
 
    public function setCancelUrl($value)
    {
        return $this->setParameter('cancelUrl', $value);
    }
 
    public function getNotifyUrl()
    {
        return $this->getParameter('notifyUrl');
    }
 
    public function setNotifyUrl($value)
    {
        return $this->setParameter('notifyUrl', $value);
    }
 
    public function getIssuer()
    {
        return $this->getParameter('issuer');
    }
 
    public function setIssuer($value)
    {
        return $this->setParameter('issuer', $value);
    }
 
    public function getPaymentMethod()
    {
        return $this->getParameter('paymentMethod');
    }
 
    public function setPaymentMethod($value)
    {
        return $this->setParameter('paymentMethod', $value);
    }
 
    public function send()
    {
        $data = $this->getData();
 
        return $this->sendData($data);
    }
 
    public function getResponse()
    {
        if (null === $this->response) {
            throw new RuntimeException('You must call send() before accessing the Response!');
        }
 
        return $this->response;
    }
}