Agreement.php

Go to the documentation of this file.

<?php
namespace Magento\Paypal\Model\Method;

use Magento\Payment\Model\InfoInterface;
use Magento\Sales\Model\Order\Payment;
use Magento\Store\Model\Store;

class Agreement extends \Magento\Paypal\Model\Payment\Method\Billing\AbstractAgreement implements
    \Magento\Paypal\Model\Billing\Agreement\MethodInterface
{
    protected $_code = \Magento\Paypal\Model\Config::METHOD_BILLING_AGREEMENT;

    protected $_canAuthorize = true;

    protected $_canCapture = true;

    protected $_canCapturePartial = true;

    protected $_canRefund = true;

    protected $_canRefundInvoicePartial = true;

    protected $_canVoid = true;

    protected $_canUseCheckout = true;

    protected $_canUseInternal = true;

    protected $_canFetchTransactionInfo = true;

    protected $_canReviewPayment = true;

    protected $_pro;

    protected $_storeManager;

    protected $_urlBuilder;

    protected $_cartFactory;

    public function __construct(
        \Magento\Framework\Model\Context $context,
        \Magento\Framework\Registry $registry,
        \Magento\Framework\Api\ExtensionAttributesFactory $extensionFactory,
        \Magento\Framework\Api\AttributeValueFactory $customAttributeFactory,
        \Magento\Payment\Helper\Data $paymentData,
        \Magento\Framework\App\Config\ScopeConfigInterface $scopeConfig,
        \Magento\Payment\Model\Method\Logger $logger,
        \Magento\Paypal\Model\Billing\AgreementFactory $agreementFactory,
        \Magento\Store\Model\StoreManagerInterface $storeManager,
        \Magento\Paypal\Model\ProFactory $proFactory,
        \Magento\Framework\UrlInterface $urlBuilder,
        \Magento\Paypal\Model\CartFactory $cartFactory,
        \Magento\Framework\Model\ResourceModel\AbstractResource $resource = null,
        \Magento\Framework\Data\Collection\AbstractDb $resourceCollection = null,
        array $data = []
    ) {
        $this->_storeManager = $storeManager;
        $this->_urlBuilder = $urlBuilder;
        $this->_cartFactory = $cartFactory;
        parent::__construct(
            $context,
            $registry,
            $extensionFactory,
            $customAttributeFactory,
            $paymentData,
            $scopeConfig,
            $logger,
            $agreementFactory,
            $resource,
            $resourceCollection,
            $data
        );
        $proInstance = array_shift($data);
        if ($proInstance && $proInstance instanceof \Magento\Paypal\Model\Pro) {
            $this->_pro = $proInstance;
        } else {
            $this->_pro = $proFactory->create();
        }
        $this->_pro->setMethod($this->_code);
    }

    public function setStore($store)
    {
        $this->setData('store', $store);
        if (null === $store) {
            $store = $this->_storeManager->getStore()->getId();
        }
        $this->_pro->getConfig()->setStoreId(is_object($store) ? $store->getId() : $store);
        return $this;
    }

    public function initBillingAgreementToken(\Magento\Paypal\Model\Billing\AbstractAgreement $agreement)
    {
        $api = $this->_pro->getApi()->setReturnUrl(
            $agreement->getReturnUrl()
        )->setCancelUrl(
            $agreement->getCancelUrl()
        )->setBillingType(
            $this->_pro->getApi()->getBillingAgreementType()
        );

        $api->callSetCustomerBillingAgreement();
        $agreement->setRedirectUrl($this->_pro->getConfig()->getStartBillingAgreementUrl($api->getToken()));
        return $this;
    }

    public function getBillingAgreementTokenInfo(\Magento\Paypal\Model\Billing\AbstractAgreement $agreement)
    {
        $api = $this->_pro->getApi()->setToken($agreement->getToken());
        $api->callGetBillingAgreementCustomerDetails();
        $responseData = [
            'token' => $api->getData('token'),
            'email' => $api->getData('email'),
            'payer_id' => $api->getData('payer_id'),
            'payer_status' => $api->getData('payer_status'),
        ];
        $agreement->addData($responseData);
        return $responseData;
    }

    public function placeBillingAgreement(\Magento\Paypal\Model\Billing\AbstractAgreement $agreement)
    {
        $api = $this->_pro->getApi()->setToken($agreement->getToken());
        $api->callCreateBillingAgreement();
        $agreement->setBillingAgreementId($api->getData('billing_agreement_id'));
        return $this;
    }

    public function updateBillingAgreementStatus(\Magento\Paypal\Model\Billing\AbstractAgreement $agreement)
    {
        $targetStatus = $agreement->getStatus();
        $api = $this->_pro->getApi()->setReferenceId(
            $agreement->getReferenceId()
        )->setBillingAgreementStatus(
            $targetStatus
        );
        try {
            $api->callUpdateBillingAgreement();
        } catch (\Magento\Framework\Exception\LocalizedException $e) {
            // when BA was already canceled, just pretend that the operation succeeded
            if (!(\Magento\Paypal\Model\Billing\Agreement::STATUS_CANCELED == $targetStatus &&
                $api->getIsBillingAgreementAlreadyCancelled())
            ) {
                throw $e;
            }
        }
        return $this;
    }

    public function authorize(\Magento\Payment\Model\InfoInterface $payment, $amount)
    {
        return $this->_placeOrder($payment, $amount);
    }

    public function void(\Magento\Payment\Model\InfoInterface $payment)
    {
        $this->_pro->void($payment);
        return $this;
    }

    public function capture(\Magento\Payment\Model\InfoInterface $payment, $amount)
    {
        if (false === $this->_pro->capture($payment, $amount)) {
            $this->_placeOrder($payment, $amount);
        }
        return $this;
    }

    public function refund(\Magento\Payment\Model\InfoInterface $payment, $amount)
    {
        $this->_pro->refund($payment, $amount);
        return $this;
    }

    public function cancel(\Magento\Payment\Model\InfoInterface $payment)
    {
        $this->_pro->cancel($payment);
        return $this;
    }

    public function canReviewPayment()
    {
        return parent::canReviewPayment() && $this->_pro->canReviewPayment($this->getInfoInstance());
    }

    public function acceptPayment(InfoInterface $payment)
    {
        parent::acceptPayment($payment);
        return $this->_pro->reviewPayment($payment, \Magento\Paypal\Model\Pro::PAYMENT_REVIEW_ACCEPT);
    }

    public function denyPayment(InfoInterface $payment)
    {
        parent::denyPayment($payment);
        return $this->_pro->reviewPayment($payment, \Magento\Paypal\Model\Pro::PAYMENT_REVIEW_DENY);
    }

    public function fetchTransactionInfo(InfoInterface $payment, $transactionId)
    {
        return $this->_pro->fetchTransactionInfo($payment, $transactionId);
    }

    protected function _placeOrder(Payment $payment, $amount)
    {
        $order = $payment->getOrder();
        $billingAgreement = $this->_agreementFactory->create()->load(
            $payment->getAdditionalInformation(
                \Magento\Paypal\Model\Payment\Method\Billing\AbstractAgreement::TRANSPORT_BILLING_AGREEMENT_ID
            )
        );

        $cart = $this->_cartFactory->create(['salesModel' => $order]);

        $proConfig = $this->_pro->getConfig();
        $api = $this->_pro->getApi()->setReferenceId(
            $billingAgreement->getReferenceId()
        )->setPaymentAction(
            $proConfig->getValue('paymentAction')
        )->setAmount(
            $amount
        )->setCurrencyCode(
            $payment->getOrder()->getBaseCurrencyCode()
        )->setNotifyUrl(
            $this->_urlBuilder->getUrl('paypal/ipn/')
        )->setPaypalCart(
            $cart
        )->setIsLineItemsEnabled(
            $proConfig->getValue('lineItemsEnabled')
        )->setInvNum(
            $order->getIncrementId()
        );

        // call api and import transaction and other payment information
        $api->callDoReferenceTransaction();
        $this->_pro->importPaymentInfo($api, $payment);
        $api->callGetTransactionDetails();
        $this->_pro->importPaymentInfo($api, $payment);

        $payment->setTransactionId($api->getTransactionId())->setIsTransactionClosed(0);

        if ($api->getBillingAgreementId()) {
            $order->addRelatedObject($billingAgreement);
            $billingAgreement->setIsObjectChanged(true);
            $billingAgreement->addOrderRelation($order);
        }

        return $this;
    }

    protected function _isAvailable($quote)
    {
        return $this->_pro->getConfig()->isMethodAvailable($this->_code);
    }

    public function getConfigPaymentAction()
    {
        return $this->_pro->getConfig()->getPaymentAction();
    }
}