AbstractBasePayment.php

<?php

namespace QUI\ERP\Payments\Stripe;

use QUI;
use QUI\ERP\Accounting\Payments\Gateway\Gateway;
use QUI\ERP\Accounting\Payments\Transactions\Factory as TransactionFactory;
use QUI\ERP\Accounting\Payments\Transactions\Transaction;
use QUI\ERP\Order\AbstractOrder;
use QUI\ERP\Order\Handler as OrderHandler;
use Stripe\Exception\ApiErrorException;
use Stripe\PaymentIntent as StripePaymentIntent;
use Stripe\Refund as StripeRefund;

/**
 * Class BasePayment
 *
 * Main Payment class for all Stripe payment methods
 */
abstract class AbstractBasePayment extends QUI\ERP\Accounting\Payments\Api\AbstractPayment
{
    /**
     * Stripe API Order attributes
     */
    const ATTR_STRIPE_PAYMENT_INTENT_ID = 'stripe-PaymentIntentId';
    const ATTR_STRIPE_PAYMENT_METHOD_ID = 'stripe-PaymentMethodId';
    const ATTR_STRIPE_REFUND_ID = 'stripe-RefundId';
    const ATTR_STRIPE_ORDER_SUCCESSFUL = 'stripe-OrderSuccessful';
    const ATTR_STRIPE_BILLING_PLAN_ID = 'stripe-BillingPlanId';
    const ATTR_STRIPE_SUBSCRIPTION_ID = 'stripe-SubscriptionId';
    const ATTR_STRIPE_INVOICE_ID = 'stripe-InvoiceId';

    /**
     * Stripe User attributes
     */
    const USER_ATTR_STRIPE_CUSTOMER_ID = 'quiqqer.payment.stripe.customer_id';

    /**
     * Error codes
     */
    const ERROR_GENERAL = 'error_general';
    const ERROR_REFUND = 'error_refund';
    const ERROR_REFUND_STATUS = 'error_refund_status';
    const ERROR_REFUND_MISSING_PAYMENT_INTENT_ID = 'error_missing_payment_intent_id';

    /**
     * BasePayment constructor.
     */
    public function __construct()
    {
        Provider::setupApi();
    }

    /**
     * Get title for frontend
     *
     * @return string
     */
    abstract public function getFrontendTitle();

    /**
     * Get description for frontend
     *
     * @return string
     */
    abstract public function getFrontendDescription();

    /**
     * Get title for the Payment step (OrderProcess)
     *
     * @return string
     */
    abstract public function getPaymentStepTitle();

    /**
     * Get description step for the Payment step (OrderProcess)
     *
     * @return string
     */
    abstract public function getPaymentStepInfo();

    /**
     * Get type string of Stripe PaymentMethod
     *
     * @return string
     */
    abstract public function getPaymentMethodType();

    /**
     * Is the payment process successful?
     * This method returns the payment success type
     *
     * @param string $hash - Vorgangsnummer - hash number - procedure number
     * @return bool
     */
    public function isSuccessful($hash)
    {
        try {
            $Order = OrderHandler::getInstance()->getOrderByHash($hash);
        } catch (\Exception $Exception) {
            QUI\System\Log::writeException($Exception);
            return false;
        }

        return $Order->getPaymentDataEntry(self::ATTR_STRIPE_ORDER_SUCCESSFUL);
    }

    /**
     * Is the payment a gateway payment?
     *
     * @return bool
     */
    public function isGateway()
    {
        return true;
    }

    /**
     * @return bool
     */
    public function refundSupport()
    {
        return true;
    }

    /**
     * Execute a refund
     *
     * @param QUI\ERP\Accounting\Payments\Transactions\Transaction $Transaction
     * @param int|float $amount
     * @param string $message
     * @param false|string $hash - if a new hash will be used
     * @throws QUI\ERP\Accounting\Payments\Transactions\RefundException
     */
    public function refund(
        Transaction $Transaction,
        $amount,
        $message = '',
        $hash = false
    ) {
        try {
            if ($hash === false) {
                $hash = $Transaction->getHash();
            }

            $this->refundPayment($Transaction, $hash, $amount, $message);
        } catch (StripeException $Exception) {
            QUI\System\Log::writeDebugException($Exception);

            throw new QUI\ERP\Accounting\Payments\Transactions\RefundException([
                'quiqqer/payment-stripe',
                'exception.BasePayment.refund_error_stripe',
                [
                    'stripeError' => $Exception->getMessage()
                ]
            ]);
        } catch (\Exception $Exception) {
            QUI\System\Log::writeException($Exception);

            throw new QUI\ERP\Accounting\Payments\Transactions\RefundException([
                'quiqqer/payment-stripe',
                'exception.BasePayment.refund_error'
            ]);
        }
    }

    /**
     * If the Payment method is a payment gateway, it can return a gateway display
     *
     * @param AbstractOrder $Order
     * @param QUI\ERP\Order\Controls\OrderProcess\Processing $Step
     * @return string
     *
     * @throws QUI\Exception
     */
    public function getGatewayDisplay(AbstractOrder $Order, $Step = null)
    {
        $type = $this->getPaymentMethodType();

        $Control = new PaymentDisplay([
            'paymentMethod' => $type,
            'infoText' => $this->getPaymentStepInfo()
        ]);

        $Control->setAttribute('Order', $Order);

        $stepTitle = $this->getPaymentStepTitle();
        $Step->setTitle($stepTitle);

        $Engine = QUI::getTemplateManager()->getEngine();

        $Engine->assign([
            'stepTitle' => $stepTitle
        ]);

        $Step->setContent($Engine->fetch(dirname(__FILE__) . '/PaymentDisplay.Header.html'));

        return $Control->create();
    }

    /**
     * Create a Stripe PaymentIntent for an order
     *
     * @param AbstractOrder $Order
     * @param string $paymentMethodId - Stripe PaymentMethod ID
     * @return StripePaymentIntent
     *
     * @throws ApiErrorException
     * @throws QUI\Exception
     */
    public function createPaymentIntent(AbstractOrder $Order, $paymentMethodId)
    {
        if (!empty($Order->getPaymentDataEntry(self::ATTR_STRIPE_PAYMENT_INTENT_ID))) {
            $PaymentIntent = $this->getPaymentIntentByOrder($Order);

            // Re-set PaymentMethod
            if (empty($PaymentIntent->payment_method)) {
                $PaymentIntent = StripePaymentIntent::update($PaymentIntent->id, [
                    'payment_method' => $paymentMethodId
                ]);
            }

            return $PaymentIntent;
        }

        $PaymentIntent = $this->createPaymentIntentForOrder($Order, $paymentMethodId);

        $Order->setPaymentData(self::ATTR_STRIPE_PAYMENT_INTENT_ID, $PaymentIntent->id);
        $this->addOrderHistoryEntry($Order, 'PaymentIntent ' . $PaymentIntent->id . ' created.');

        return $PaymentIntent;
    }

    /**
     * Return attributes for creating a PaymentIntent
     *
     * @param AbstractOrder $Order
     * @param string $paymentMethodId - Stripe PaymentMethod ID
     * @return StripePaymentIntent
     */
    abstract protected function createPaymentIntentForOrder(AbstractOrder $Order, $paymentMethodId);

    /**
     * Confirm a Stripe PaymentIntent
     *
     * @param AbstractOrder $Order
     * @param StripePaymentIntent $PaymentIntent
     * @return array - confirmation data
     *
     * @throws ApiErrorException
     */
    public function confirmPaymentIntent(AbstractOrder $Order, StripePaymentIntent $PaymentIntent)
    {
        if (empty($PaymentIntent->payment_method)) {
            $this->addOrderHistoryEntry($Order, 'Payment method validation fail. Re-fetch payment method from user.');
            return ['status' => 'retry_payment_method'];
        }

        if ($Order->getPaymentDataEntry(self::ATTR_STRIPE_ORDER_SUCCESSFUL)) {
            return ['status' => 'success'];
        }

        $this->addOrderHistoryEntry($Order, 'Confirming PaymentIntent.');

        if ($PaymentIntent->status === $PaymentIntent::STATUS_REQUIRES_CONFIRMATION) {
            $PaymentIntent = $PaymentIntent->confirm();
        }

        $confirmData = [];

        if (
            $PaymentIntent->status === $PaymentIntent::STATUS_REQUIRES_ACTION
            && $PaymentIntent->next_action->type === 'use_stripe_sdk'
        ) {
            $confirmData['status'] = 'action_required';
            $confirmData['clientSecret'] = $PaymentIntent->client_secret;

            $this->addOrderHistoryEntry($Order, 'Additional user action required for PaymentIntent confirmation.');
        } elseif ($PaymentIntent->status === $PaymentIntent::STATUS_SUCCEEDED) {
            $confirmData['status'] = 'success';

            $this->addOrderHistoryEntry($Order, 'PaymentIntent successully confirmed.');

            try {
                $Order->setSuccessfulStatus();
                $Order->setPaymentData(self::ATTR_STRIPE_ORDER_SUCCESSFUL, true);

                $this->saveOrder($Order);

                $Transaction = Gateway::getInstance()->purchase(
                    $PaymentIntent->amount_received / 100,
                    QUI\ERP\Currency\Handler::getCurrency(mb_strtoupper($PaymentIntent->currency)),
                    $Order,
                    $this
                );

                $Transaction->setData(
                    self::ATTR_STRIPE_PAYMENT_INTENT_ID,
                    $Order->getPaymentDataEntry(self::ATTR_STRIPE_PAYMENT_INTENT_ID)
                );

                $Transaction->updateData();
            } catch (\Exception $Exception) {
                QUI\System\Log::writeException($Exception);

                $this->addOrderHistoryEntry(
                    $Order,
                    'Error while trying to set order as successful: ' . $Exception->getMessage()
                );
            }
        } else {
            $confirmData['status'] = 'error';
            $this->addOrderHistoryEntry($Order, 'Confirmation error.');
        }

        return $confirmData;
    }

    /**
     * Get Stripe PaymentIntent by order
     *
     * @param AbstractOrder $Order
     * @return false|StripePaymentIntent - PaymentIntent or false if not found
     *
     * @throws ApiErrorException
     * @throws StripeException
     */
    public function getPaymentIntentByOrder(AbstractOrder $Order)
    {
        $paymentIntentId = $Order->getPaymentDataEntry(self::ATTR_STRIPE_PAYMENT_INTENT_ID);

        if (empty($paymentIntentId)) {
            throw new StripeException([
                'quiqqer/payment-stripe',
                'exception.BasePayment.getPaymentIntentByOrder.payment_intent_id_missing',
                [
                    'orderHash' => $Order->getHash()
                ]
            ]);
        }

        return StripePaymentIntent::retrieve($paymentIntentId);
    }

    /**
     * Refund partial or full payment of an Order
     *
     * @param QUI\ERP\Accounting\Payments\Transactions\Transaction $Transaction
     * @param string $refundHash - Hash of the refund Transaction
     * @param float $amount - The amount to be refunded
     * @param string $reason (optional) - The reason for the refund [default: none; max. 255 characters]
     * @return void
     *
     * @throws StripeException
     * @throws QUI\Exception
     */
    public function refundPayment(Transaction $Transaction, $refundHash, $amount, $reason = '')
    {
        $Process = new QUI\ERP\Process($Transaction->getGlobalProcessId());
        $Process->addHistory('Stripe :: Start refund for transaction #' . $Transaction->getTxId());

        if (!$Transaction->getData(self::ATTR_STRIPE_PAYMENT_INTENT_ID)) {
            $Process->addHistory(
                'PayPal :: Transaction cannot be refunded because it is not yet captured / completed.'
            );

            $this->throwStripeException(
                self::ERROR_REFUND_MISSING_PAYMENT_INTENT_ID,
                [
                    'globalProcessingId' => $Transaction->getGlobalProcessId()
                ]
            );

            return;
        }

        $paymentIntentId = $Transaction->getData(self::ATTR_STRIPE_PAYMENT_INTENT_ID);
        $Currency = $Transaction->getCurrency();

        // Create a refund transaction (QUIQQER)
        $RefundTransaction = TransactionFactory::createPaymentRefundTransaction(
            $amount,
            $Currency,
            $refundHash,
            $Transaction->getPayment()->getName(),
            [
                'isRefund' => 1,
                'message' => $reason
            ],
            null,
            false,
            $Transaction->getGlobalProcessId()
        );

        $RefundTransaction->pending();

        // Create refund (Stripe)
        try {
            $PaymentIntent = StripePaymentIntent::retrieve($paymentIntentId);
            $AmountValue = new QUI\ERP\Accounting\CalculationValue($amount, $Transaction->getCurrency(), 2);
            $refundAmount = $AmountValue->get() * 100; // convert to smallest currency unit

            $Refund = StripeRefund::create([
                'charge' => $PaymentIntent->charges->data[0]->id,
                'amount' => $refundAmount,
//                'reason'   => StripeRefund::REASON_REQUESTED_BY_CUSTOMER,
                'metadata' => [
                    'refundTxId' => $RefundTransaction->getTxId()
                ]
            ]);
        } catch (\Exception $Exception) {
            QUI\System\Log::writeException($Exception);

            $RefundTransaction->error();

            $Process->addHistory(
                QUI::getLocale()->get(
                    'quiqqer/payment-stripe',
                    'history.refund.error_api',
                    [
                        'amount' => $amount,
                        'currency' => $Currency->getCode(),
                        'txId' => $Transaction->getTxId()
                    ]
                )
            );

            return;
        }

        switch ($Refund->status) {
            case StripeRefund::STATUS_SUCCEEDED:
                $RefundTransaction->complete();
                $RefundTransaction->setData(self::ATTR_STRIPE_REFUND_ID, $Refund->id);
                $RefundTransaction->updateData();

                $Process->addHistory(
                    QUI::getLocale()->get(
                        'quiqqer/payment-stripe',
                        'history.refund.success',
                        [
                            'refundId' => $Refund->id,
                            'amount' => $amount,
                            'currency' => $Currency->getCode(),
                            'txId' => $Transaction->getTxId()
                        ]
                    )
                );

                QUI::getEvents()->fireEvent('transactionSuccessfullyRefunded', [
                    $RefundTransaction,
                    $this
                ]);
                break;

            case StripeRefund::STATUS_PENDING:
                $RefundTransaction->pending();
                $RefundTransaction->setData(self::ATTR_STRIPE_REFUND_ID, $Refund->id);
                $RefundTransaction->updateData();

                $Process->addHistory(
                    QUI::getLocale()->get(
                        'quiqqer/payment-stripe',
                        'history.refund.pending',
                        [
                            'refundId' => $Refund->id,
                            'amount' => $amount,
                            'currency' => $Currency->getCode(),
                            'txId' => $Transaction->getTxId()
                        ]
                    )
                );
                break;

            // FAILURE
            default:
                $RefundTransaction->error();

                $stripeFailureReason = '';

                if (!empty($Refund->failure_reason)) {
                    $stripeFailureReason = $Refund->failure_reason;
                }

                $Process->addHistory(
                    QUI::getLocale()->get(
                        'quiqqer/payment-stripe',
                        'history.refund.error_status',
                        [
                            'refundId' => $Refund->id,
                            'refundStatus' => $Refund->status,
                            'failureReason' => $stripeFailureReason,
                            'amount' => $amount,
                            'currency' => $Currency->getCode(),
                            'txId' => $Transaction->getTxId()
                        ]
                    )
                );

                $this->throwStripeException(self::ERROR_REFUND_STATUS, ['refundStatus' => $Refund->status]);
        }
    }

    /**
     * Add history entry for current Order
     *
     * @param AbstractOrder $Order
     * @param string $msg
     * @return void
     */
    protected function addOrderHistoryEntry(AbstractOrder $Order, $msg)
    {
        $Order->addHistory('Stripe :: ' . $msg);
        $this->saveOrder($Order);
    }

    /**
     * Throw StripeException for specific PayPal API Error
     *
     * @param string $errorCode (optional) - default: general error message
     * @param array $exceptionAttributes (optional) - Additional Exception attributes that may be relevant for the Frontend
     * @return string
     *
     * @throws StripeException
     */
    protected function throwStripeException($errorCode = self::ERROR_GENERAL, $exceptionAttributes = [])
    {
        $L = $this->getLocale();
        $lg = 'quiqqer/payment-stripe';
        $msg = $L->get($lg, 'exception.BasePayment.' . $errorCode);

        $Exception = new StripeException($msg);
        $Exception->setAttributes($exceptionAttributes);

        throw $Exception;
    }

    /**
     * Save Order with SystemUser
     *
     * @param AbstractOrder $Order
     * @return void
     */
    protected function saveOrder(AbstractOrder $Order)
    {
        $Order->update(QUI::getUsers()->getSystemUser());
    }
}