Unzer/Modules/Application/Model/Order.php

<?php

namespace D3\Unzer\Modules\Application\Model;

use D3\Unzer\Application\Model\Constants;
use D3\Unzer\Application\Model\Containers\Criterions;
use D3\Unzer\Application\Model\Containers\PrepaymentData;
use D3\Unzer\Application\Model\Factory;
use D3\Unzer\Application\Model\Mail;
use D3\Unzer\Application\Model\Payment\Btobbillpurchase;
use D3\Unzer\Application\Model\Payment\Easycredit;
use D3\Unzer\Application\Model\Payment\Exception\PaymentNotReferencedToUnzerException;
use D3\Unzer\Application\Model\Payment\Invoice\Secured;
use D3\Unzer\Application\Model\Payment\Invoice\Unsecured;
use D3\Unzer\Application\Model\Payment\Payment;
use D3\Unzer\Application\Model\Payment\Prepayment;
use D3\Unzer\Application\Model\Response\Parser;
use D3\Unzer\Application\Model\Transactionlog\Reader\Unzer as TransactionlogReader;
use D3\Unzer\Application\Model\Viewconfig;
use D3\Unzer\Modules\Application\Controller\PaymentController as HPPaymentController;
use D3\ModCfg\Application\Model\Configuration\d3_cfg_mod;
use D3\ModCfg\Application\Model\Exception\d3_cfg_mod_exception;
use D3\ModCfg\Application\Model\Exception\d3ShopCompatibilityAdapterException;
use D3\ModCfg\Application\Model\Transactionlog\d3transactionlog;
use Doctrine\DBAL\DBALException;
use Exception;
use OxidEsales\Eshop\Core\Exception\ArticleInputException;
use OxidEsales\Eshop\Core\Exception\NoArticleException;
use UnzerSDK\Exceptions\UnzerApiException;
use OxidEsales\Eshop\Application\Controller\PaymentController;
use OxidEsales\Eshop\Application\Model\Article;
use OxidEsales\Eshop\Application\Model\Basket;
use OxidEsales\Eshop\Application\Model\Payment as OxidPayment;
use OxidEsales\Eshop\Application\Model\User;
use OxidEsales\Eshop\Application\Model\Voucher;
use OxidEsales\Eshop\Core\Counter;
use OxidEsales\Eshop\Core\DatabaseProvider;
use OxidEsales\Eshop\Core\Email;
use OxidEsales\Eshop\Core\Exception\ArticleException;
use OxidEsales\Eshop\Core\Exception\DatabaseConnectionException;
use OxidEsales\Eshop\Core\Exception\DatabaseErrorException;
use OxidEsales\Eshop\Core\Exception\StandardException;
use OxidEsales\Eshop\Core\Exception\SystemComponentException;
use OxidEsales\Eshop\Core\Registry;
use OxidEsales\Eshop\Core\UtilsObject;
use stdClass;

/**
 */
class Order extends Order_parent
{
    protected $d3HeidelpayIsSurpressEMailSending = false;

    /**
     * Returns bank transfer data if available
     *
     * @return stdClass|false|array
     * @throws PaymentNotReferencedToUnzerException
     * @throws d3ShopCompatibilityAdapterException
     * @throws d3_cfg_mod_exception
     * @throws DBALException
     * @throws DatabaseConnectionException
     * @throws DatabaseErrorException
     * @throws StandardException
     * @throws UnzerApiException
     */
    public function getHeidelpayBankTransferData()
    {
        /** @var Factory $factory */
        $factory   = oxNew(Factory::class);

        if (false == $factory->getModuleConfiguration()->isActive()) {
            return false;
        }

        $oSettings = $factory->getSettings();
        /** @var OxidPayment $oPayment */
        $oPayment  = oxNew(OxidPayment::class);
        $oPayment->load($this->getFieldData('oxpaymenttype'));
        if (false == $oSettings->isAssignedToHeidelPayment($oPayment)) {
            return false;
        }

        $heidelpayment = $oSettings->getPayment($oPayment);

        if ($factory->getModuleProvider()->isHeidelpayInterfaceNGWActive() && (
            $heidelpayment instanceof Prepayment
            || $heidelpayment instanceof Secured
            || $heidelpayment instanceof Unsecured
            || $heidelpayment instanceof Btobbillpurchase
        )
        ) {
            /** @var PrepaymentData $oPrePaymentData */
            $oPrePaymentData = oxNew(PrepaymentData::class);

            return $oPrePaymentData->getBankTransferData($this, $heidelpayment->getPaymentCode() . '.PA');
        }

        if ($factory->getModuleProvider()->isHeidelpayInterfaceMGWRestActive()
            && $heidelpayment->isMGWPayment()
            && (
                $heidelpayment instanceof Prepayment
                || $heidelpayment instanceof Secured
                || $heidelpayment instanceof Unsecured
                || $heidelpayment instanceof Btobbillpurchase
            )
        ) {
            $paymentId = $this->getFieldData('oxtransid');
            if (!str_contains($paymentId, 's-pay-') && !str_contains($paymentId, 'p-pay-')) {
                return false;
            }

            try {
                $result = $factory->getMgwResourceHandler()->obtainPaymentAuthorizationByPayID($paymentId);
                if (empty($result)) {
                    $result = $factory->getMgwResourceHandler()->obtainPaymentChargesByID($paymentId);
                    $result = $result[0];
                }
            } catch (UnzerApiException $e) {
                $factory->getModuleConfiguration()->d3getLog()->error(
                    self::class,
                    __FUNCTION__,
                    __LINE__,
                    "Unzer api exception: " . PHP_EOL . "client message: " . $e->getClientMessage() //
                    . PHP_EOL . "merchant message: ". $e->getMerchantMessage(),
                    var_export($e, true)
                );
            }

            return $result;
        }

        return false;
    }

    /**
     * @return null
     * @throws PaymentNotReferencedToUnzerException
     * @throws d3ShopCompatibilityAdapterException
     * @throws d3_cfg_mod_exception
     * @throws DBALException
     * @throws DatabaseConnectionException
     * @throws DatabaseErrorException
     * @throws StandardException
     */
    public function getHeidelpayEasyCreditInformations()
    {
        /** @var Factory $factory */
        $factory   = oxNew(Factory::class);

        /** @var OxidPayment $payment */
        $payment = oxNew(OxidPayment::class);
        $payment->load($this->getFieldData('oxpaymenttype'));
        if (false == $factory->getChannelProvider()->isOxPaymentIdAssignedToChannel($payment->getId())) {
            return null;
        }

        $settings = $factory->getSettings();
        $heidelpayment = $settings->getPayment($payment);

        if ($heidelpayment instanceof Easycredit) {
            /** @var d3transactionlog $transaction */
            $transaction = $factory->getLatestTransactionByObject($this);

            if (false === ($transaction instanceof d3transactionlog)) {
                return null;
            }

            /** @var TransactionlogReader $reader */
            /** @var Criterions $criterionContainer */
            $reader             = $transaction->getTransactiondata();
            $criterionContainer = oxNew(Criterions::class, oxNew(Criterions\Easycredit::class));

            return $criterionContainer->getSelectedCriterions($reader->getCriterionTags());
        }

        return null;
    }

    /**
     *
     * @return int|null
     * @throws DBALException
     * @throws Exception
     * @throws DatabaseConnectionException
     * @throws DatabaseErrorException
     */
    public function d3CreateTemporaryOrder(Basket $oBasket, User $oUser)
    {
        /* D3 START disabled - 03.03.2016 - KH <!--
        We can't use the session challenge for this break up.
        We need every "hotfix"- payment->toOrder a new order

        $sGetChallenge = Registry::getSession()->getVariable('sess_challenge');
        if ($this->checkOrderExist($sGetChallenge)) {
            Registry::getUtils()->logger('BLOCKER');
            // we might use this later, this means that somebody clicked like mad on order button
            return self::ORDER_STATE_ORDEREXISTS;
        }

        // if not recalculating order, use sess_challenge id, else leave old order id

        // use this ID
        $this->setId($sGetChallenge);
        --> */

        $this->setId(Registry::get(UtilsObject::class)->generateUId());

        // validating various order/basket parameters before finalizing
        $iOrderState = $this->validateOrder($oBasket, $oUser);
        if ($iOrderState) {
            return $iOrderState;
        }

        // copies user info
        $this->setUser($oUser);

        // copies basket info
        $this->loadFromBasket($oBasket);

        // payment information
        $this->setPayment($oBasket->getPaymentId());

        // set folder information, if order is new
        // #M575 in recalculating order case folder must be the same as it was

        $this->setFolder();

        //#4005: Order creation time is not updated when order processing is complete
        $this->updateOrderDate();

        // marking as not finished
        $this->setOrderStatus('PENDING');

        $aVouchers = $oBasket->getVouchers();
        /** @var Factory $factory */
        $factory = oxNew(Factory::class);
        if (count($aVouchers)) {
            $aVoucherIds  = [];
            $pendingLimit = $factory->getModuleProvider()->getPaymentCollectorOrderPendingTime();
            foreach ($aVouchers as $oStdVoucher) {
                /** @var Voucher $oVoucher */
                $oVoucher = oxNew(Voucher::class);
                if ($oVoucher->load($oStdVoucher->sVoucherId)) {
                    $aVoucherIds[$oStdVoucher->sVoucherId] = $oStdVoucher->sVoucherId;
                    $oVoucher->assign(['oxreserved' => time() + $pendingLimit * 3600]);
                    $oVoucher->save();
                }
            }

            $this->assign(['d3heidelpayvouchers' => implode('|', $aVoucherIds)]);
        }

        //saving all order data to DB
        $this->save();

        if (false == $factory->getModuleProvider()->isUsingZeroOrderNumber() && false == $this->oxorder__oxordernr->value) {
            $this->setNumber();
        }

        // set order ID for thankyou
        $oBasket->setOrderId($this->getId());
        Registry::getSession()->setVariable('sess_challenge', $this->getId());

        return null;
    }

    /**
     * @param string $sStatus
     *
     * @return void
     * @throws PaymentNotReferencedToUnzerException
     * @throws d3ShopCompatibilityAdapterException
     * @throws d3_cfg_mod_exception
     * @throws DBALException
     * @throws DatabaseConnectionException
     * @throws DatabaseErrorException
     * @throws StandardException
     */
    protected function setOrderStatus($sStatus)
    {
        /** @var Factory $factory */
        $factory   = oxNew(Factory::class);

        if (! $factory->getModuleConfiguration()->isActive()) {
            parent::setOrderStatus($sStatus);

            return;
        }

        if ($factory->getModuleProvider()->isHeidelpayInterfaceMGWRestActive()) {
            parent::setOrderStatus($sStatus);

            return;
        }

        if ($factory->getModuleProvider()->isHeidelpayInterfaceNGWActive()) {
            $oDB = DatabaseProvider::getDb();

            $sOldStatus = $oDB->getOne('select oxtransstatus from oxorder where oxid="' . $this->getId() . '"');
            $sPaid      = $oDB->getOne('select oxpaid from oxorder where oxid="' . $this->getId() . '"');
            $sPaymentId = $this->getFieldData('OXPAYMENTTYPE');

            /** @var Factory $factory */
            $factory   = oxNew(Factory::class);

            /** @var OxidPayment $payment */
            $payment = oxNew(OxidPayment::class);
            $payment->load($sPaymentId);

            if (! $factory->getChannelProvider()->isOxPaymentIdAssignedToChannel($payment->getId())) {
                parent::setOrderStatus($sStatus);

                return;
            }

            $settings       = $factory->getSettings();
            $blIsPrepayment = $settings->getPayment($payment) instanceof Prepayment;
            $blIsWaiting    = $sOldStatus == 'PENDING' && $sPaid == '0000-00-00 00:00:00';
            if ($blIsPrepayment && $blIsWaiting) {
                $sStatus = "PENDING";
            }
        }

        parent::setOrderStatus($sStatus);
    }

    /**
     *
     * @return bool|int
     * @throws d3ShopCompatibilityAdapterException
     * @throws d3_cfg_mod_exception
     * @throws DBALException
     * @throws DatabaseConnectionException
     * @throws DatabaseErrorException
     * @throws StandardException
     * @throws Exception
     */
    public function d3FinalizeTemporaryOrder(Basket $oBasket, User $oUser)
    {
        /** @var Factory $factory */
        $factory            = oxNew(Factory::class);
        $registry           = Registry::get(Registry::class);
        $modulConfiguration = $factory->getModuleConfiguration();

        $oUserPayment = $this->setPayment($oBasket->getPaymentId());
        // executing payment (on failure deletes order and returns error code)
        // in case when recalculating order, payment execution is skipped

        $blRet = $this->executePayment($oBasket, $oUserPayment);
        if ($blRet !== true) {
            return $blRet;
        }

        if (!$this->oxorder__oxordernr->value) {
            $this->setNumber();
        } else {
            /** @var Counter $counter */
            $counter = oxNew(Counter::class);
            $counter->update($this->getCounterIdent(), $this->oxorder__oxordernr->value);
        }

        // deleting remark info only when order is finished
        Registry::getSession()->deleteVariable('ordrem');

        //#4005: Order creation time is not updated when order processing is complete
        //$this->updateOrderDate();

        // updating order trans status (success status)
        $this->setOrderStatus('OK');

        // store orderid
        $oBasket->setOrderId($this->getId());

        // updating wish lists
        $this->updateWishlist($oBasket->getContents(), $oUser);

        // updating users notice list
        $this->updateNoticeList($oBasket->getContents(), $oUser);

        // marking vouchers as used and sets them to $this->aVoucherList (will be used in order email)
        // skipping this action in case of order recalculation
        $this->markVouchers($oBasket, $oUser);

        // send order by email to shop owner and current user
        // skipping this action in case of order recalculation
        $iRet = $this->sendOrderByEmail($oUser, $oBasket, $oUserPayment);

        // the negative case shouldn't be possible
        $this->d3VerifyBasketSameAmount($oBasket, $modulConfiguration, $registry);

        return $iRet;
    }

    /**
     * TODO: outsource this in a own model
     *
     *
     * @return null
     * @throws d3ShopCompatibilityAdapterException
     * @throws d3_cfg_mod_exception
     * @throws DBALException
     * @throws DatabaseConnectionException
     * @throws DatabaseErrorException
     * @throws StandardException
     */
    protected function d3VerifyBasketSameAmount(Basket $oxBasket, d3_cfg_mod $modulConfiguration, Registry $registry)
    {
        $transaction = $this->d3GetLastHeidelpayTransaction($oxBasket, $modulConfiguration);

        if (is_null($transaction)) {
            return null;
        }

        /** @var TransactionlogReader $reader */
        $reader = $transaction->getTransactiondata();
        $amount = $reader->getAmount();
        if ($amount !== $this->getTotalOrderSum()) {
            /** @var Factory $factory */
            $factory = oxNew(Factory::class);

            $transStatusError = $factory->getModuleProvider()->getOxTransStatusErrorState();
            if (empty($transStatusError)) {
                $transStatusError = 'ERROR';
            }

            $this->setD3HPTransactionStatusError($transStatusError);
            $this->d3SendHPErrorMessage($modulConfiguration, $registry, $reader, $this->getTotalOrderSum());
        }

        return null;
    }

    /**
     *
     * @return d3transactionlog|null |null
     * @throws d3ShopCompatibilityAdapterException
     * @throws d3_cfg_mod_exception
     * @throws DBALException
     * @throws DatabaseConnectionException
     * @throws DatabaseErrorException
     * @throws StandardException
     */
    protected function d3GetLastHeidelpayTransaction(Basket $oxBasket, d3_cfg_mod $modulConfiguration)
    {
        /** @var OxidPayment $oPayment */
        $oPayment = oxNew(OxidPayment::class);
        $oPayment->load($oxBasket->getPaymentId());

        /** @var Factory $factory */
        $factory = oxNew(Factory::class);

        try {
            /** @var Payment $heidelPayment */
            $heidelPayment = $factory->getSettings()->getPayment($oPayment);
        } catch (PaymentNotReferencedToUnzerException) {
            return null;
        }

        if (false == $heidelPayment instanceof Payment) {
            return null;
        }

        $refrenceNumber = $factory->getReferenceNumber();
        if (empty($refrenceNumber)) {
            $modulConfiguration->d3getLog()->error(
                self::class,
                __FUNCTION__,
                __LINE__,
                "no reference but Unzer payment! payment is: " . var_export($heidelPayment, true)
            );

            return null;
        }

        $transaction = $factory->getLatestTransactionByReference($refrenceNumber);

        if (false == $transaction) {
            $modulConfiguration->d3getLog()->warning(
                self::class,
                __FUNCTION__,
                __LINE__,
                'no transaction found but Unzer payment and referencenumber',
                $refrenceNumber
            );

            return null;
        }

        return $transaction;
    }

    /**
     * @param      $transStatusError
     * @param bool $resetPaidDate
     */
    public function setD3HPTransactionStatusError($transStatusError, $resetPaidDate = true)
    {
        $aAssignment                  = [];
        $aAssignment['oxtransstatus'] = $transStatusError;
        if ($resetPaidDate) {
            $aAssignment['oxpaid'] = '0000-00-00 00:00:00';
        }

        $this->assign($aAssignment);
        $this->save();
    }

    /**
     *  TODO refactor into separate class
     *
     * @param                                                      $basketAmount
     *
     * @throws d3ShopCompatibilityAdapterException
     * @throws d3_cfg_mod_exception
     * @throws DBALException
     * @throws DatabaseConnectionException
     * @throws DatabaseErrorException
     * @throws StandardException
     */
    public function d3SendHPErrorMessage(d3_cfg_mod $modulConfiguration, Registry $registry, TransactionlogReader $reader, $basketAmount)
    {
        $text    = $registry->getLang()->translateString(
            'D3UNZER_DIFFERENCE_IN_ORDER_ERRRORMESSAGE',
            Registry::getLang()->getBaseLanguage(),
            true
        );
        $message = sprintf($text, $this->getFieldData('oxordernr'), $reader->getUniqueid(), $reader->getAmount(), $basketAmount);
        $message .= PHP_EOL. "ordernr: ". $this->getFieldData('oxordernr');
        $message .= PHP_EOL. "uniqueid: ". $reader->getUniqueid();
        $message .= PHP_EOL. "Unzer amount: ".$reader->getAmount();
        $message .= PHP_EOL. "basket amount: ". $basketAmount;

        $subject = $registry->getLang()->translateString(
            'D3UNZER_DIFFERENCE_IN_ORDER_SUBJECT',
            Registry::getLang()->getBaseLanguage(),
            true
        );
        $subject .= $this->getFieldData('oxordernr');

        /** @var Factory $factory */
        $factory = oxNew(Factory::class);

        /** @var Mail $email */
        $email = oxNew(Mail::class, oxNew(Email::class), $modulConfiguration, Registry::getConfig()->getActiveShop());
        $email->setSubject($subject)->setMessage($message)->sendMail($factory);
    }

    /**
     * @return Basket
     * @throws ArticleException
     * @throws ArticleInputException
     * @throws NoArticleException
     * @throws SystemComponentException
     */
    public function d3GetOrderBasket()
    {
        $this->reloadDelivery(false);
        $this->reloadDiscount(false);
        $oBasket = $this->getOrderBasket(false);

        foreach ($this->getOrderArticles() as $oOrderArticle) {
            $oBasket->addOrderArticleToBasket($oOrderArticle);
        }

        /* D3 START added - #4998 - 29.04.2016 - KH */
        $aVouchers = explode('|', $this->getFieldData('d3heidelpayvouchers'));
        $oBasket->setSkipVouchersChecking(true);
        foreach ($aVouchers as $sVoucherId) {
            $oVoucher = oxNew(Voucher::class);
            if ($oVoucher->load($sVoucherId)) {
                $oBasket->addVoucher($sVoucherId);
            }
        }

        /* D3 END   added - #4998 - 29.04.2016 - KH */

        //$oBasket->setVoucherDiscount($this->oxorder__oxvoucherdiscount->value);
        $oBasket->calculateBasket();

        foreach ($oBasket->getContents() as $oBasketItem) {
            /** @var BasketItem $oBasketItem */
            /** @var Article $oArticle */
            $oArticle = oxNew(Article::class);
            $oArticle->loadInLang($this->oxorder__oxlang->value, $oBasketItem->getArticle()->getProductId());
            $oBasketItem->d3SetArticle($oArticle);
        }

        return $oBasket;
    }

    /**
     * @param Basket $oxBasket
     * @param object $oxUser
     * @param bool   $blRecalculatingOrder
     *
     * @return int
     * @throws d3_cfg_mod_exception
     * @throws Exception
     */
    public function finalizeOrder(Basket $oBasket, $oUser, $blRecalculatingOrder = false)
    {
        /** @var Factory $factory */
        $factory            = oxNew(Factory::class);
        $registry           = $factory->getOxidProvider()->getRegistry();
        $modulConfiguration = $factory->getModuleConfiguration();

        if (false == $blRecalculatingOrder && $modulConfiguration->isActive() && $factory->getModuleProvider()->isHeidelpayInterfaceMGWRestActive()) {
            $sPaymentid = $oBasket->getPaymentId();
            /** @var OxidPayment $payment */
            $payment = oxNew(OxidPayment::class);
            $heidelPaySettings = $factory->getSettings();

            if ($payment->load($sPaymentid) && $heidelPaySettings->isAssignedToHeidelPayment($payment)) {
                Registry::getSession()->setVariable(Constants::MGW_ORDERINPROGRESS, true);

                $factory->getModuleConfiguration()->d3getLog()->info(
                    self::class,
                    __FUNCTION__,
                    __LINE__,
                    'mgw: begin surpressing e-mail sendind'
                );
                $this->setD3HeidelpayIsSurpressEMailSending($factory);
                $factory->getModuleConfiguration()->d3getLog()->info(
                    self::class,
                    __FUNCTION__,
                    __LINE__,
                    'mgw: end surpressing e-mail sendind'
                );
            }
        }

        if ($factory->getModuleProvider()->isHeidelpayInterfaceNGWActive()) {
            try {
                $paymentId = $oBasket->getPaymentId();
                $payment = oxNew(OxidPayment::class);
                $payment->load($paymentId);

                /** @var Viewconfig $heidelpayViewConfig */
                $heidelpayViewConfig = oxNew(
                    Viewconfig::class,
                    d3_cfg_mod::get('d3unzer'),
                    Registry::get(Registry::class),
                    $factory
                );
                $settings = $heidelpayViewConfig->getSettings();

                $heidelPayment = $settings->getPayment($payment);

                if ($heidelPayment instanceof Secured) {
                    /** @var HPPaymentController $paymentController */
                    $paymentController = oxNew(PaymentController::class);
                    if (false == $paymentController->isHeidelpayInvoiceSecuredAllowed($oBasket)) {
                        return self::ORDER_STATE_PAYMENTERROR;
                    }
                }
            } catch (PaymentNotReferencedToUnzerException) {
                // ignore exception, because it's handled already before
            }
        }


        $return             = parent::finalizeOrder($oBasket, $oUser, $blRecalculatingOrder);

        if (false == $modulConfiguration->isActive() || $registry->getConfig()->isAdmin()) {
            return $return;
        }

        if ($factory->getModuleProvider()->isHeidelpayInterfaceMGWRestActive()) {
            $factory->getModuleConfiguration()->d3getLog()->info(
                self::class,
                __FUNCTION__,
                __LINE__,
                'mgw: return: '.$return
            );
            return $return;
        }

        $this->d3VerifyBasketSameAmount($oBasket, $modulConfiguration, $registry);
        $this->d3SetWaitingState($oBasket, $modulConfiguration);

        return $return;
    }

    /**
     * @param          $modulConfiguration
     *
     * @return null
     * @throws DBALException
     * @throws DatabaseConnectionException
     * @throws DatabaseErrorException
     * @throws StandardException
     * @throws SystemComponentException
     * @throws d3ShopCompatibilityAdapterException
     * @throws d3_cfg_mod_exception
     */
    protected function d3SetWaitingState(Basket $basket, $modulConfiguration)
    {
        $transaction = $this->d3GetLastHeidelpayTransaction($basket, $modulConfiguration);
        if (false  == ($transaction instanceof d3transactionlog)) {
            return null;
        }

        /** @var Parser $oParser */
        $oParser = oxNew(Parser::class, $transaction->getTransactiondata());

        if ('OK' !== $this->getFieldData('oxtransstatus') || false === $oParser->isWaiting()) {
            return null;
        }

        $this->setD3HPTransactionStatusError('PENDING', true);

        return null;
    }

    protected function sendOrderByEmail($oUser = null, $oBasket = null, $oPayment = null)
    {
        $return = self::ORDER_STATE_OK;

        $this->oUser = $oUser;
        $this->oBasket = $oBasket;
        $this->oPayment = $oPayment;

        if (false == $this->d3HeidelpayIsSurpressEMailSending) {
            return parent::sendOrderByEmail($oUser, $oBasket, $oPayment);
        }

        return $return;
    }

    /**
     *
     * @return bool
     * @throws DBALException
     * @throws StandardException
     */
    public function d3HeidelpaySendOrderByEmail(Basket $basket, User $user)
    {
        $oUserPayment = $this->setPayment($basket->getPaymentId());
        /** @var Factory $factory */
        $factory            = oxNew(Factory::class);
        $factory->getModuleConfiguration()->d3getLog()->info(
            self::class,
            __FUNCTION__,
            __LINE__,
            'mgw: send order mail'
        );
        return parent::sendOrderByEmail($user, $basket, $oUserPayment);
    }

    /**
     * @throws SystemComponentException
     */
    public function setD3HeidelpayIsSurpressEMailSending(Factory $factory)
    {
        $factory->getOxidProvider()->getSession()->setVariable($factory::HeidelpaySurpressEmailStateSessionName, true);
        $this->d3HeidelpayIsSurpressEMailSending = true;
    }

    /**
     * @param $payId
     * @param $orderId
     *
     * @throws DatabaseConnectionException
     * @throws StandardException
     */
    public function d3GetOrderByMgwPayId($payId, $orderId)
    {
        $query = "SELECT oxid FROM ".$this->getViewName()." WHERE oxtransid = ? AND oxordernr = ?";

        $oxid = DatabaseProvider::getDb()->getOne($query, [$payId, $orderId]);

        if (false == $oxid || false == $this->load($oxid)) {
            throw oxNew(StandardException::class, 'no order loadable by transid = '.$payId.' and ordernr = '.$orderId);
        }
    }
}