Unzer/Modules/Application/Controller/PaymentController.php

1360 lignes
49 KiB
PHP

<?php
namespace D3\Unzer\Modules\Application\Controller;
use D3\Unzer\Application\Model\Constants;
use D3\Unzer\Application\Model\Factory;
use D3\Unzer\Application\Model\Parameter\Group\CompanyData;
use D3\Unzer\Application\Model\Payment\Btobbillpurchase;
use D3\Unzer\Application\Model\Payment\Directdebit;
use D3\Unzer\Application\Model\Payment\Directdebit\Secured as DirectdebitSecured;
use D3\Unzer\Application\Model\Payment\Easycredit;
use D3\Unzer\Application\Model\Payment\Exception\PaymentNotReferencedToUnzerException;
use D3\Unzer\Application\Model\Payment\Ideal;
use D3\Unzer\Application\Model\Payment\Eps;
use D3\Unzer\Application\Model\Payment\Invoice\Secured;
use D3\Unzer\Application\Model\Payment\Invoice\Unsecured;
use D3\Unzer\Application\Model\Payment\Payment as HeidelpayAbstractPayment;
use D3\Unzer\Application\Model\Payment\Paypal;
use D3\Unzer\Application\Model\Payment\Przelewy24;
use D3\Unzer\Application\Model\Transactionlog\Reader\Unzer as ReaderHeidelpay;
use D3\Unzer\Application\Model\Viewconfig;
use D3\ModCfg\Application\Model\Exception\d3_cfg_mod_exception;
use D3\ModCfg\Application\Model\Exception\d3ShopCompatibilityAdapterException;
use D3\ModCfg\Application\Model\Log\d3log;
use D3\ModCfg\Application\Model\Transactionlog\d3transactionlog;
use Doctrine\DBAL\DBALException;
use RuntimeException;
use UnzerSDK\Constants\PaymentState;
use UnzerSDK\Exceptions\UnzerApiException;
use OxidEsales\Eshop\Application\Model\Address;
use OxidEsales\Eshop\Application\Model\Basket;
use OxidEsales\Eshop\Application\Model\Country;
use OxidEsales\Eshop\Application\Model\Order;
use OxidEsales\Eshop\Application\Model\Payment;
use OxidEsales\Eshop\Application\Model\Shop;
use OxidEsales\Eshop\Application\Model\User;
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\Request;
use OxidEsales\Eshop\Core\UtilsView;
use OxidEsales\Eshop\Core\ViewHelper\JavaScriptRegistrator;
use OxidEsales\Eshop\Core\ViewHelper\StyleRegistrator;
/**
*/
class PaymentController extends PaymentController_parent
{
public const OPTION_DONT_SHOW_DD_MANDATE = 'dontShowDirectDebitMandateCheckbox';
/**
* @var array
*/
protected $d3UnzerMissingUserParameter = [];
/**
* Initiate and register module classes
* intitiate reference number
* reset payment success
*
* @return void
* @throws StandardException
* @throws d3ShopCompatibilityAdapterException
* @throws d3_cfg_mod_exception
* @throws DBALException
* @throws DatabaseConnectionException
* @throws DatabaseErrorException
*/
public function init()
{
parent::init();
/** @var Factory $factory */
$factory = oxNew(Factory::class);
$d3log = $factory->getModuleConfiguration()->d3getLog();
if (! $factory->getModuleConfiguration()->isActive()) {
$d3log->info(
self::class,
__FUNCTION__,
__LINE__,
'module is inactive',
'module is inactive'
);
return;
}
$this->d3HeidelpaySetErrorMessage($factory);
$factory->initReferenceNumber();
$factory->resetPaymentSuccess();
if ($factory->getModuleProvider()->isHeidelpayInterfaceNGWActive()) {
$oUnzerViewConfig = oxNew(
Viewconfig::class,
$factory->getModuleConfiguration(),
Registry::get(Registry::class),
$factory
);
$this->addTplParam('oUnzerViewConfig', $oUnzerViewConfig);
}
if ($factory->getModuleProvider()->isHeidelpayInterfaceMGWRestActive()) {
$session = $factory->getOxidProvider()->getSession();
$d3log->info(
self::class,
__FUNCTION__,
__LINE__,
'mgw: begin session cleanup',
'HeidelpayPaymentIdSessionName: ' . $session->getVariable($factory::HeidelpayPaymentIdSessionName) . PHP_EOL .
'HeidelpayOrderResultSessionOrderID: ' . $session->getVariable($factory::HeidelpayOrderResultSessionOrderID) . PHP_EOL .
'HeidelpayResourceIdSessionName: ' . $session->getVariable($factory::HeidelpayResourceIdSessionName) . PHP_EOL .
'HeidelpayCustomerIdSessionName: ' . $session->getVariable($factory::HeidelpayCustomerIdSessionName) . PHP_EOL
);
Registry::getSession()->deleteVariable(\D3\Unzer\Modules\Application\Model\Order::MGW_ORDERINPROGRESS);
$orderId = $session->getVariable($factory::HeidelpayOrderResultSessionOrderID);
if ($orderId) {
/** @var Order $order */
$order = oxNew(Order::class);
$order->load($orderId);
$this->d3HandleRemainingOrder($order);
}
$this->d3EndSessionCleanup();
}
$paymentId = Registry::getSession()->getBasket()->getPaymentId();
if (empty($paymentId)) {
return;
}
/** @var Payment $payment */
$payment = oxNew(Payment::class);
if (! $payment->load($paymentId)) {
return;
}
if ($factory->getChannelProvider()->isOxPaymentIdAssignedToChannel($payment->getId())) {
Registry::getSession()->deleteVariable('sess_challenge');
}
}
/**
* in case of aborted payment handling (canceled by user or interrupted due technical reasons)
* dependent on the successful handling of the temporary order by Unzer
* delete the order or clear basket to prevent reordering by user
*
*
* @throws DBALException
* @throws DatabaseConnectionException
* @throws DatabaseErrorException
* @throws SystemComponentException
* @throws UnzerApiException
*/
protected function d3HandleRemainingOrder(Order $order)
{
try {
$paymentId = $order->getFieldData('oxtransid');
$factory = oxNew(Factory::class);
$payment = $factory->getMgwResourceHandler()->fetchPaymentByID($paymentId);
$d3log = $factory->getModuleConfiguration()->d3getLog();
if ($payment && in_array($payment->getState(), $this->d3GetOrderNotProcessedStates())) {
// delete the pending order
$message = "Order: ".$order->getId()." was not deleted";
if ($order->delete()) {
$message = "Order: ".$order->getId()." was deleted";
}
$d3log->info(
self::class,
__FUNCTION__,
__LINE__,
$message
);
} elseif ($payment && in_array($payment->getState(), $this->d3GetOrderProcessedStates())) {
// keep processed order, clear basket
$message = "keep already handled order: ".$order->getId();
$d3log->info(
self::class,
__FUNCTION__,
__LINE__,
$message
);
$this->d3EndSessionCleanup();
Registry::getSession()->delBasket();
Registry::getSession()->freeze();
Registry::getUtilsView()->addErrorToDisplay(
Registry::getLang()->translateString('D3UNZER_PAYMENT_MGW_ORDERERR_HANDLEDPAYMENT')
);
Registry::getUtils()->redirect(Registry::getConfig()->getShopHomeUrl());
}
} catch (UnzerApiException $unzerApiException) {
Registry::getUtilsView()->addErrorToDisplay($unzerApiException);
}
}
/**
* @return array
*/
protected function d3GetOrderNotProcessedStates()
{
return [
PaymentState::STATE_PENDING,
PaymentState::STATE_CANCELED
];
}
/**
* @return array
*/
protected function d3GetOrderProcessedStates()
{
return [
PaymentState::STATE_COMPLETED,
PaymentState::STATE_PARTLY,
PaymentState::STATE_CHARGEBACK
];
}
/**
* @throws DBALException
* @throws DatabaseConnectionException
* @throws DatabaseErrorException
*/
protected function d3EndSessionCleanup()
{
$session = Registry::getSession();
$factory = oxNew(Factory::class);
$d3log = $factory->getModuleConfiguration()->d3getLog();
$session->deleteVariable($factory::HeidelpayPaymentIdSessionName);
$session->deleteVariable($factory::HeidelpayOrderResultSessionOrderID);
$session->deleteVariable($factory::HeidelpayResourceIdSessionName);
$session->deleteVariable($factory::HeidelpayCustomerIdSessionName);
$d3log->info(
self::class,
__FUNCTION__,
__LINE__,
'mgw: end session cleanup'
);
}
/**
*
* @throws StandardException
* @throws d3ShopCompatibilityAdapterException
* @throws d3_cfg_mod_exception
* @throws DBALException
* @throws DatabaseConnectionException
* @throws DatabaseErrorException
*/
protected function d3HeidelpaySetErrorMessage(Factory $factory)
{
$oldReference = $factory->getReferenceNumber();
if ($oldReference) {
$oTransAction = $factory->getLatestTransactionByReference($oldReference);
if ($oTransAction instanceof d3transactionlog) {
/** @var ReaderHeidelpay $reader */
$reader = $oTransAction->getTransactiondata();
if ($reader->getResult() === "NOK" && $reader->getReturncode()) {
$string = 'd3heidelpay_' . $reader->getReturncode();
$translation = Registry::getLang()->translateString($string);
if ($translation === $string) {
$factory->getModuleConfiguration()->d3getLog()->error(
self::class,
__FUNCTION__,
__LINE__,
'Translation not found: ' . $string,
$string
);
$translation = Registry::getLang()->translateString('d3heidelpay_execute_error');
}
$exception = oxNew(StandardException::class, $translation);
Registry::get(UtilsView::class)->addErrorToDisplay($exception);
}
}
}
}
/**
* Injects the Trusted Shops Excellence protection into the POST superglobal
*
* @return mixed
* @throws StandardException
* @throws d3ShopCompatibilityAdapterException
* @throws d3_cfg_mod_exception
* @throws DBALException
* @throws DatabaseConnectionException
* @throws DatabaseErrorException
*/
public function validatePayment()
{
$return = parent::validatePayment();
if (empty($return) || false === stristr($return, 'order')) {
return $return;
}
$paymentId = $this->getD3PaymentId();
/** @var Payment $payment */
$payment = oxNew(Payment::class);
$payment->load($paymentId);
/** @var Factory $factory */
$factory = oxNew(Factory::class);
$session = $factory->getOxidProvider()->getSession();
$session->deleteVariable($factory::HeidelpaySurpressEmailStateSessionName);
if (false == $factory->getChannelProvider()->isOxPaymentIdAssignedToChannel($payment->getId())) {
return $return;
}
$heidelPaySettings = $factory->getSettings();
//<editor-fold desc="NGW - part">
$oxUser = $this->getUser();
if ($factory->getModuleProvider()->isHeidelpayInterfaceNGWActive()) {
$heidelPayment = $heidelPaySettings->getPayment($payment);
if ($heidelPayment instanceof Secured
|| $heidelPayment instanceof Unsecured
|| $heidelPayment instanceof DirectdebitSecured
) {
$birthdate = Registry::get(Request::class)->getRequestParameter('d3birthdate');
if ($this->d3HasInvalidBirthdateInput($birthdate, $paymentId)) {
// log message
$factory->getModuleConfiguration()->d3getLog()->warning(
self::class,
__FUNCTION__,
__LINE__,
'birthdate is empty but required',
"user didn't set the birthdate for invoice payment. input: " . var_export($birthdate, true)
);
$this->_sPaymentError = 1;
return null;
}
$oxUser->assign(
['oxbirthdate' => $birthdate[$paymentId]]
);
$oxUser->save();
return $return;
}
if ((
$heidelPayment instanceof Easycredit
|| $heidelPayment instanceof Przelewy24
|| $heidelPayment instanceof Ideal
|| $heidelPayment instanceof Eps
|| $heidelPayment instanceof Paypal
|| $heidelPayment instanceof DirectdebitSecured
|| $heidelPayment instanceof Secured
) && false == Registry::get(Request::class)->getRequestParameter('paymentid')
) {
return false;
}
if ($heidelPayment instanceof Easycredit) {
return $this->handleD3HeidelpayEasyCredit($paymentId);
}
if ($heidelPayment instanceof Btobbillpurchase) {
return $this->handleD3HeidelpayBtobbillpurchase($paymentId);
}
}
//</editor-fold>
if ($factory->getModuleProvider()->isHeidelpayInterfaceMGWRestActive()) {
$d3log = $factory->getModuleConfiguration()->d3getLog();
$d3log->info(
self::class,
__FUNCTION__,
__LINE__,
'mgw: begin validate payment'
);
$heidelPayment = $heidelPaySettings->getPayment($payment);
$d3log->info(
self::class,
__FUNCTION__,
__LINE__,
'mgw: payment is '.$heidelPayment->getPaymentMethod()
);
if ($heidelPayment->isMGWPayment()) {
/** @var Request $request */
$request = oxNew(Request::class);
if (
($heidelPayment instanceof DirectdebitSecured || $heidelPayment instanceof Directdebit) &&
(bool) $factory->getModuleConfiguration()->getValue(self::OPTION_DONT_SHOW_DD_MANDATE) === false
) {
$isSepaValidated = (bool)($request->getRequestParameter('unzerSepaValidation')[$paymentId]);
if (false == $isSepaValidated) {
return 'payment?d3unzersepamandatnotchecked=1';
}
}
$heidelpayResult = $request->getRequestParameter('unzer-result');
$d3log->info(
self::class,
__FUNCTION__,
__LINE__,
'mgw: payment result',
var_export($heidelpayResult, true)
);
$reader = $factory->getMgwReader();
$reader->read($heidelpayResult);
$heidelpayCustomerId = $reader->getCustomerReference();
if (empty($heidelpayCustomerId)) {
$d3log->info(
self::class,
__FUNCTION__,
__LINE__,
'no customer ID recieved'
);
$heidelpayCustomerId = $this->d3UpdateHeidelpayCustomer(
$oxUser,
$factory
);
$d3log->info(
self::class,
__FUNCTION__,
__LINE__,
'create customer + ID recieved',
$heidelpayCustomerId
);
}
$session->setVariable($factory::HeidelpayCustomerIdSessionName, $heidelpayCustomerId);
$heidelpayResourceId = $reader->getId();
if (empty($heidelpayResourceId)) {
$d3log->error(
self::class,
__FUNCTION__,
__LINE__,
'no resource ID received'
);
/** @var StandardException $exception */
$exception = oxNew(StandardException::class, $factory->getOxidProvider()->getLang()->translateString('d3heidelpay_execute_error'));
$factory->getOxidProvider()->getRegistry()->getUtilsView()->addErrorToDisplay($exception);
return false;
}
// update customer with missing fields and send to Unzer
$missingParameter = $this->getD3HeidelpayMissingUserData();
$wasCustomerFormDisplayed = $this->d3ShowCustomerForm(
$factory,
(bool)trim($oxUser->getFieldData('oxcompany'))
);
if (false == empty($missingParameter[$paymentId]) && false == $wasCustomerFormDisplayed) {
$oxUser->assign($missingParameter[$paymentId]);
$oxUser->save();
//set customer Unzer resource id in session
$this->d3UpdateHeidelpayCustomer(
$oxUser,
$factory,
$heidelpayCustomerId
);
}
$this->avoidEmptyCustomerName($factory, $heidelpayCustomerId, $oxUser, $d3log);
$d3log->info(
self::class,
__FUNCTION__,
__LINE__,
'mgw: set resourceID in session',
var_export($heidelpayResourceId, true)
);
$factory->getOxidProvider()->getSession()->setVariable(Factory::HeidelpayResourceIdSessionName, $heidelpayResourceId);
if ($oxUser->hasAccount()) {
$d3log->info(
self::class,
__FUNCTION__,
__LINE__,
'mgw: save d3hpuid',
'payment id: ' . $paymentId
);
$userStoredData = $factory->getStoredDataPlain();
$result = $factory->getMgwResourceHandler()->saveResource(
$userStoredData,
$reader,
$oxUser->getId(),
$paymentId
);
if (false === $result) {
$d3log->warning(
self::class,
__FUNCTION__,
__LINE__,
"mgw: d3hpuid entry couldn't saved"
);
}
}
$d3log->info(
self::class,
__FUNCTION__,
__LINE__,
'mgw: send user to order'
);
return 'order';
}
}
return $return;
}
/**
* @return mixed
*/
protected function getD3PaymentId()
{
$paymentId = Registry::get(Request::class)->getRequestParameter('paymentid');
if (empty($paymentId)) {
return Registry::getSession()->getVariable('paymentid');
}
return $paymentId;
}
/**
* @return array
*/
protected function getD3HeidelpayMissingUserData()
{
return (array)Registry::get(Request::class)->getRequestParameter('d3UnzerMissingUserData');
}
/**
* @param $birthdate
* @param $paymentId
*
* @return bool
*/
protected function d3HasInvalidBirthdateInput($birthdate, $paymentId)
{
return empty($birthdate)
|| empty($birthdate[$paymentId])
|| empty($birthdate[$paymentId]['day'])
|| empty($birthdate[$paymentId]['month'])
|| empty($birthdate[$paymentId]['year']);
}
/**
* @param $paymentId
*
* @return string
* @throws StandardException
* @throws d3ShopCompatibilityAdapterException
* @throws d3_cfg_mod_exception
* @throws DBALException
* @throws DatabaseConnectionException
* @throws DatabaseErrorException
*/
protected function handleD3HeidelpayEasyCredit($paymentId)
{
$easycreditTransactionIds = Registry::get(Request::class)->getRequestParameter(
'd3heidelpayEasycreditTransactionLogid'
);
if (false == is_array($easycreditTransactionIds) || empty($easycreditTransactionIds[$paymentId])) {
return 'payment?d3heidelpayeasycreditnotchecked=1';
}
/** @var Factory $factory */
$factory = oxNew(Factory::class);
$transactionlog = oxNew(d3transactionlog::class, oxNew(ReaderHeidelpay::class));
if (false == $transactionlog->load($easycreditTransactionIds[$paymentId])) {
$factory->getModuleConfiguration()->d3getLog()->error(
self::class,
__FUNCTION__,
__LINE__,
'could not load d3transactionlog',
'd3transactionlogid: ' . var_export($easycreditTransactionIds[$paymentId], true)
);
return 'payment?paymenterror=-99';
}
/** @var ReaderHeidelpay $response */
$response = $transactionlog->getTransactiondata();
$redirectUrl = $response->getRedirecturl();
if (empty($redirectUrl)) {
$factory->getModuleConfiguration()->d3getLog()->error(
self::class,
__FUNCTION__,
__LINE__,
'redirect url is empty:' . $redirectUrl,
var_export($response, true)
);
return 'payment?paymenterror=-99';
}
$factory->getModuleConfiguration()->d3getLog()->info(
self::class,
__FUNCTION__,
__LINE__,
'redirect customer to url:' . $redirectUrl,
$redirectUrl
);
Registry::getConfig()->pageClose();
Registry::getUtils()->redirect($redirectUrl, false, 302);
return '';
}
/**
* @param string $mappedThemeId
*
* @return string
* @throws PaymentNotReferencedToUnzerException
* @throws StandardException
* @throws d3ShopCompatibilityAdapterException
* @throws d3_cfg_mod_exception
* @throws DBALException
* @throws DatabaseConnectionException
* @throws DatabaseErrorException
*/
public function d3GetPaymentFormTemplateName(Payment $payment, $mappedThemeId = '')
{
/** @var Factory $factory */
$factory = oxNew(Factory::class);
if (empty($mappedThemeId)) {
$mappedThemeId = $factory->getModuleConfiguration()->getMappedThemeId();
}
$mappedThemeId = strtolower($mappedThemeId);
/** @var Factory $factory */
$factory = oxNew(Factory::class);
/** @var Viewconfig $unzerViewConfig */
$unzerViewConfig = oxNew(
Viewconfig::class,
$factory->getModuleConfiguration(),
Registry::get(Registry::class),
$factory
);
$settings = $unzerViewConfig->getSettings();
$return = $this->d3GetDefaultPaymentFormTemplateName($payment);
if ($factory->getChannelProvider()->isOxPaymentIdAssignedToChannel($payment->getId())) {
$heidelpayPayment = $settings->getPayment($payment);
$result = $heidelpayPayment->getTemplateName($mappedThemeId, $factory->getModuleProvider()->getHeidelpayInterfaceType());
if (false == empty($result)) {
return $result;
}
}
return $return;
}
/**
* @return string
*/
public function d3GetDefaultPaymentFormTemplateName(Payment $oPayment)
{
$sPaymentId = $oPayment->getId();
if ($sPaymentId == "oxidcashondel") {
return "page/checkout/inc/payment_oxidcashondel.tpl";
}
if ($sPaymentId == "oxiddebitnote") {
return "page/checkout/inc/payment_oxiddebitnote.tpl";
}
return "page/checkout/inc/payment_other.tpl";
}
/**
*
* @return bool
* @throws PaymentNotReferencedToUnzerException
* @throws StandardException
* @throws d3ShopCompatibilityAdapterException
* @throws d3_cfg_mod_exception
* @throws DBALException
* @throws DatabaseConnectionException
* @throws DatabaseErrorException
*/
public function d3IsHeidelpayPaymentMethode(Payment $oPayment)
{
/** @var Factory $factory */
$factory = oxNew(Factory::class);
return $factory->getChannelProvider()->isOxPaymentIdAssignedToChannel($oPayment->getId());
}
/**
* @return string
* @throws DBALException
* @throws DatabaseConnectionException
* @throws DatabaseErrorException
* @throws StandardException
* @throws SystemComponentException
* @throws d3ShopCompatibilityAdapterException
* @throws d3_cfg_mod_exception
*/
public function render()
{
$mReturn = parent::render();
/** @var Factory $factory */
$factory = oxNew(Factory::class);
//<editor-fold desc="NGW - way">
if ($factory->getModuleProvider()->isHeidelpayInterfaceNGWActive()) {
$this->addTplParam('blD3HeidelpayEasycreditNotChecked', $this->isEasyCreditConsentNotConfirmed());
$this->addTplParam('iD3HeidelpayEasycreditLimits', $this->getEasyCreditLimits());
$this->addTplParam(
'blD3HeidelpayAllowEasyCredit',
$this->isHeidelpayEasycreditAllowed(Registry::getSession()->getBasket())
);
$basket = Registry::getSession()->getBasket();
$blD3HeidelpayAllowBtoBBillPurchase = $this->isHeidelpayBtoBBillPurchaseAllowed($basket);
$this->addTplParam('blD3HeidelpayAllowBtoBBillPurchase', $blD3HeidelpayAllowBtoBBillPurchase);
$this->addTplParam('iD3HeidelpayBtoBBillPurchaseLimits', $this->getBtoBBillPurchaseLimits());
$this->addTplParam('blD3HeidelpayAllowPostFinance', $this->isPaymentAllowedForCountryAndCurrency('CH', 'CHF'));
$this->addTplParam('blD3HeidelpayAllowPrzelewy24', $this->isPaymentAllowedForCountryAndCurrency('PL', 'PLN'));
$this->addTplParam('blD3HeidelpayAllowIdeal', $this->isPaymentAllowedForCountryAndCurrency('NL', 'EUR'));
$this->addTplParam('blD3HeidelpayAllowEPS', $this->isPaymentAllowedForCountryAndCurrency('AT', 'EUR'));
$this->addTplParam('iD3HeidelpayInvoiceSecuredLimits', $this->getInvoiceSecuredLimits());
$this->addTplParam('blD3HeidelpayHasSameAdresses', $this->d3HeidelpayHasSameAdresses());
$this->addTplParam(
'blD3HeidelpayAllowInvoiceSecured',
$this->isHeidelpayInvoiceSecuredAllowed(Registry::getSession()->getBasket())
);
$this->addTplParam(
'd3HeidelpayParameters',
Registry::getSession()->getVariable('d3HeidelpayParameters')
);
$this->addHeidelpayFormularParameter();
}
//</editor-fold>
//<editor-fold desc="MGW - way">
if ($factory->getModuleProvider()->isHeidelpayInterfaceMGWRestActive() && $this->hasD3HeidelpayMGWAssignments()) {
$factory->getModuleConfiguration()->d3getLog()->info(
self::class,
__FUNCTION__,
__LINE__,
'mgw: begin set frontend parameter'
);
$this->d3AddHeidelpayCorsHeader();
$this->d3AddHeidelpayFrontendResources();
$this->addTplParam('d3UnzerPublicKey', $factory->getModuleProvider()->getMgwPublicKey());
$this->addTplParam('d3UnzerLanguageLocale', $factory->getLanguageLocale());
$oxUser = $this->getUser();
$userStoredData = $factory->getMgwResourceHandler()->loadUserStoredData(
$oxUser->getId(),
Registry::getConfig()->getShopId()
);
$this->addTplParam('d3HeidelpayResourceIds', $userStoredData);
$this->addTplParam(
'd3UnzerShowSepaGuranteedCustomerFormular',
$this->d3ShowCustomerForm($factory, (bool)trim($oxUser->getFieldData('oxcompany')))
);
$this->addTplParam(
'd3UnzerDontShowDirectDebitMandateCheckbox',
(bool) $factory->getModuleConfiguration()->getValue(self::OPTION_DONT_SHOW_DD_MANDATE)
);
$this->addTplParam('d3HeidelpayMappedThemeId', $factory->getModuleConfiguration()->getMappedThemeId());
$factory->getModuleConfiguration()->d3getLog()->info(
self::class,
__FUNCTION__,
__LINE__,
'mgw: end set frontend parameter'
);
$translateString = $factory->getOxidProvider()->getLang()->translateString(
'D3UNZER_PAYMENT_MGW_SEPA_MANDAT_TEXT'
);
$shopId = $factory->getOxidProvider()->getConfig()->getShopId();
/** @var Shop $shop */
$shop = oxNew(Shop::class);
$shop->load($shopId);
$translateString = str_replace('{NAME_OF_MERCHANT}', $shop->getFieldData('oxcompany'), $translateString);
$this->addTplParam('d3UnzerSepaMandatText', $translateString);
$this->addTplParam('isD3UnzerSepaMandatNotConfirmed', $this->isSepaMandatNotConfirmed());
if ($factory->getModuleProvider()->isHeidelpayInterfaceMGWRestActive()) {
$paymentList = $this->getPaymentList();
$user = $this->getUser();
if ($user && is_array($paymentList) && 1 <= count($paymentList)) {
$heidelPaymentList = $factory->getHeidelPaymentList($paymentList);
$userInputValidator = $factory->getUserInputValidator($user, $heidelPaymentList);
$missingParameter = $userInputValidator->getMissingParameter();
if (false === empty($missingParameter)) {
$this->d3UnzerMissingUserParameter = $missingParameter;
}
}
}
$this->addTplParam('d3UnzerMissingUserParameter', $this->d3UnzerMissingUserParameter);
}
//</editor-fold>
return $mReturn;
}
/**
* @return bool
*/
protected function isEasyCreditConsentNotConfirmed()
{
return (bool)Registry::get(Request::class)->getRequestParameter('d3heidelpayeasycreditnotchecked');
}
/**
* @return bool
*/
protected function isSepaMandatNotConfirmed()
{
return (bool)Registry::get(Request::class)->getRequestParameter('d3unzersepamandatnotchecked');
}
/**
*
* @return bool
* @throws DBALException
* @throws DatabaseConnectionException
* @throws DatabaseErrorException
* @throws SystemComponentException
*/
public function isHeidelpayEasycreditAllowed(Basket $oxBasket)
{
if (false == $this->isPaymentAllowedForCountryAndCurrency('DE', 'EUR')) {
return false;
}
/** @var Easycredit $easyCreditPayment */
$easyCreditPayment = oxNew(Easycredit::class, 'TODO: get the correct oxPaymentId');
if (false == $this->isHeidelpayBasketAmountInLimits($oxBasket, $easyCreditPayment)) {
return false;
}
$basketUser = $oxBasket->getBasketUser();
$possiblePSFields = ['oxfname', 'oxlname', 'oxstreet', 'oxstreetnr', 'oxcity'];
foreach ($possiblePSFields as $field) {
if (false === stristr(strtolower($basketUser->getFieldData($field)), 'packstation')) {
continue;
}
return false;
}
return true;
}
/**
* @param $sCountryIsoAlpha2
* @param $sCurrencyName
*
* @return bool
* @throws SystemComponentException
*/
public function isPaymentAllowedForCountryAndCurrency($sCountryIsoAlpha2, $sCurrencyName)
{
$sCountryId = $this->getUser()->getFieldData('oxcountryid');
/** @var $oCountry Country * */
$oCountry = oxNew(Country::class);
if (!$oCountry->load($sCountryId)) {
return false;
}
if ($oCountry->getFieldData('oxisoalpha2') != $sCountryIsoAlpha2) {
return false;
}
if ($this->getActCurrency()->name != $sCurrencyName) {
return false;
}
return true;
}
/**
* @return bool
* @throws SystemComponentException
*/
protected function d3HeidelpayHasSameAdresses()
{
$oDelAdress = $this->getD3HeidelpayDeliveryAddress();
if (false === $oDelAdress->isLoaded()) {
return true;
}
$oUser = $this->getUser();
$userAdress = [
$oUser->getFieldData('oxfname'),
$oUser->getFieldData('oxlname'),
$oUser->getFieldData('oxcompany'),
$oUser->getFieldData('oxstreet'),
$oUser->getFieldData('oxstreetnr'),
$oUser->getFieldData('oxzip'),
$oUser->getFieldData('oxcity')
];
$deliverAdress = [
$oDelAdress->getFieldData('oxfname'),
$oDelAdress->getFieldData('oxlname'),
$oDelAdress->getFieldData('oxcompany'),
$oDelAdress->getFieldData('oxstreet'),
$oDelAdress->getFieldData('oxstreetnr'),
$oDelAdress->getFieldData('oxzip'),
$oDelAdress->getFieldData('oxcity')
];
return $userAdress === $deliverAdress;
}
/**
*
* @return bool
* @throws DBALException
* @throws DatabaseConnectionException
* @throws DatabaseErrorException
* @throws SystemComponentException
*/
public function isHeidelpayInvoiceSecuredAllowed(Basket $oxBasket)
{
if (false == $this->d3HeidelpayHasSameAdresses()) {
return false;
}
/** @var Secured $InvoicePayment */
$InvoicePayment = oxNew(Secured::class, 'TODO: get the correct oxPaymentId');
return $this->isHeidelpayBasketAmountInLimits($oxBasket, $InvoicePayment);
}
/**
* @return string
* @throws DBALException
* @throws DatabaseConnectionException
* @throws DatabaseErrorException
* @throws SystemComponentException
*/
public function d3GetMessageTemplateName()
{
/** @var Factory $factory */
$factory = oxNew(Factory::class);
$mappedThemeId = $factory->getModuleConfiguration()->getMappedThemeId();
return '@' . Constants::OXID_MODULE_ID . '/'.$mappedThemeId.'/messages.tpl';
}
/**
* @throws DBALException
* @throws DatabaseConnectionException
* @throws DatabaseErrorException
* @throws SystemComponentException
*/
protected function addHeidelpayFormularParameter()
{
$d3hpPaymentFormulars = [];
$paymentList = $this->getPaymentList();
/** @var Factory $factory */
$factory = oxNew(Factory::class);
$settings = $factory->getSettings();
try {
foreach ($paymentList as $paymentId => $payment) {
/** @var $payment Payment */
if ($factory->getChannelProvider()->isOxPaymentIdAssignedToChannel($payment->getId())) {
$d3hpPaymentFormulars[$paymentId] = $settings->getPayment($payment)->getFormularParameter();
}
}
} catch (StandardException) {
}
$this->addTplParam('d3hpPaymentFormulars', $d3hpPaymentFormulars);
}
/**
* @param $paymentId
*
* @return bool
* @throws StandardException
* @throws d3ShopCompatibilityAdapterException
* @throws d3_cfg_mod_exception
* @throws DBALException
* @throws DatabaseConnectionException
* @throws DatabaseErrorException
*/
protected function handleD3HeidelpayBtobbillpurchase($paymentId)
{
/** @var Request $request */
$request = oxNew(Request::class);
$heidelpayParameters = $request->getRequestParameter('d3unzer');
if (false == isset($heidelpayParameters[$paymentId])) {
// fehlende Parameter
return false;
}
/** @var Factory $factory */
$factory = oxNew(Factory::class);
$birthdateParameters = [$paymentId => $heidelpayParameters[$paymentId]['COMPANY.EXECUTIVE.1.BIRTHDATE']];
if (strtolower(CompanyData::COMPANYDATA_REGISTERED) !== strtolower($heidelpayParameters[$paymentId]['COMPANY.REGISTRATIONTYPE'])
&& $this->d3HasInvalidBirthdateInput($birthdateParameters, $paymentId)) {
$factory->getModuleConfiguration()->d3getLog()->warning(
self::class,
__FUNCTION__,
__LINE__,
'birthdate is empty but required',
"user didn't set the birthdate for payment. input: ".var_export($birthdateParameters[$paymentId], true)
);
$this->_sPaymentError = 1;
return false;
}
//write data in Session
Registry::getSession()->setVariable('d3HeidelpayParameters', $heidelpayParameters);
return 'order';
}
/**
* @return bool
* @throws SystemComponentException
*/
protected function isHeidelpayBasketAmountInLimits(Basket $oxBasket, HeidelpayAbstractPayment $payment)
{
/** @var Factory $factory */
$factory = oxNew(Factory::class);
$oxPrice = $oxBasket->getPrice();
$price = $oxPrice->getPrice();
$minPrice = $payment->getMinimumLimit($factory->getModuleProvider());
$maxPrice = $payment->getMaximumLimit($factory->getModuleProvider());
return !(false == ($price >= $minPrice && $maxPrice >= $price));
}
/**
*
* @return bool
* @throws DBALException
* @throws DatabaseConnectionException
* @throws DatabaseErrorException
* @throws SystemComponentException
*/
protected function isHeidelpayBtoBBillPurchaseAllowed(Basket $basket)
{
$isInGermanyAllowed = $this->isPaymentAllowedForCountryAndCurrency('DE', $basket->getBasketCurrency()->name);
$isInAustriaAllowed = $this->isPaymentAllowedForCountryAndCurrency('AT', $basket->getBasketCurrency()->name);
/** @var Btobbillpurchase $bToBBillPurchase */
$bToBBillPurchase = oxNew(Btobbillpurchase::class, 'TODO: get the correct oxPaymentId');
return ($isInGermanyAllowed || $isInAustriaAllowed) && $this->isHeidelpayBasketAmountInLimits($basket, $bToBBillPurchase);
}
/**
* @return array
* @throws SystemComponentException
*/
protected function getEasyCreditLimits()
{
/** @var Easycredit $easyCreditPayment */
$easyCreditPayment = oxNew(Easycredit::class, 'TODO: get the correct oxPaymentId');
/** @var Factory $factory */
$factory = oxNew(Factory::class);
return [
$easyCreditPayment->getMinimumLimit($factory->getModuleProvider()),
$easyCreditPayment->getMaximumLimit($factory->getModuleProvider())
];
}
/**
* @return array
* @throws SystemComponentException
*/
protected function getInvoiceSecuredLimits()
{
/** @var Secured $invoiceSecurePayment */
$invoiceSecurePayment = oxNew(Secured::class, 'TODO: get the correct oxPaymentId');
/** @var Factory $factory */
$factory = oxNew(Factory::class);
return [
$invoiceSecurePayment->getMinimumLimit($factory->getModuleProvider()),
$invoiceSecurePayment->getMaximumLimit($factory->getModuleProvider())
];
}
/**
* @return array
* @throws SystemComponentException
*/
protected function getBtoBBillPurchaseLimits()
{
/** @var Btobbillpurchase $btobbillpurchase */
$btobbillpurchase = oxNew(Btobbillpurchase::class, 'TODO: get the correct oxPaymentId');
/** @var Factory $factory */
$factory = oxNew(Factory::class);
return [
$btobbillpurchase->getMinimumLimit($factory->getModuleProvider()),
$btobbillpurchase->getMaximumLimit($factory->getModuleProvider())
];
}
/**
* @return bool
* @throws DBALException
* @throws DatabaseConnectionException
* @throws DatabaseErrorException
* @throws SystemComponentException
*/
protected function hasD3HeidelpayMGWAssignments()
{
/** @var Factory $factory */
$factory = oxNew(Factory::class);
if (false === $factory->getModuleProvider()->isHeidelpayInterfaceMGWRestActive()) {
return false;
}
$settings = $factory->getSettings();
$paymentList = $this->getPaymentList();
try {
foreach ($paymentList as $payment) {
/** @var $payment Payment */
if ($settings->isAssignedToHeidelPayment($payment)) {
return true;
}
}
} catch (StandardException) {
}
return false;
}
protected function d3AddHeidelpayCorsHeader()
{
Registry::getUtils()->setHeader("Access-Control-Allow-Origin: https://payment.unzer.com");
}
/**
* @throws DBALException
* @throws DatabaseConnectionException
* @throws DatabaseErrorException
* @throws StandardException
* @throws SystemComponentException
* @throws d3ShopCompatibilityAdapterException
* @throws d3_cfg_mod_exception
*/
protected function d3AddHeidelpayFrontendResources()
{
/** @var StyleRegistrator $styleRegistrator */
$styleRegistrator = oxNew(StyleRegistrator::class);
$styleRegistrator->addFile('https://static.unzer.com/v1/unzer.css', null, false);
$fileTime = filemtime($this->getViewConfig()->getModulePath('d3unzer', 'out/src/css/d3unzerMGW.css'));
$fileUrl = $this->getViewConfig()->getModuleUrl('d3unzer', 'out/src/css/d3unzerMGW.css');
if ($fileTime) {
$fileUrl .= '?' . $fileTime;
}
$styleRegistrator->addFile($fileUrl, null, false);
/** @var JavaScriptRegistrator $javaScriptRegistrator */
$javaScriptRegistrator = oxNew(JavaScriptRegistrator::class);
$javaScriptRegistrator->addFile('https://static.unzer.com/v1/unzer.js', 3, false);
$fileTime = filemtime($this->getViewConfig()->getModulePath('d3unzer', 'out/src/js/d3unzer.js'));
$fileUrl = $this->getViewConfig()->getModuleUrl('d3unzer', 'out/src/js/d3unzer.js');
if ($fileTime) {
$fileUrl .= '?' . $fileTime;
}
$javaScriptRegistrator->addFile($fileUrl, 3, false);
}
/**
* @return Address
* @throws SystemComponentException
*/
protected function getD3HeidelpayDeliveryAddress()
{
if (false == ($deliveryOxid = Registry::get(Request::class)->getRequestParameter('deladrid'))) {
$deliveryOxid = Registry::getSession()->getVariable('deladrid');
}
/** @var Address $adress */
$adress = oxNew(Address::class);
if (empty($deliveryOxid) || false === $adress->load($deliveryOxid)) {
return $adress;
}
//get delivery country name from delivery country id
if ($adress->oxaddress__oxcountryid->value && -1 != $adress->oxaddress__oxcountryid->value) {
/** @var Country $country */
$country = oxNew(Country::class);
if ($country->load($adress->oxaddress__oxcountryid->value)) {
$adress->oxaddress__oxcountry = clone $country->oxcountry__oxtitle;
}
}
return $adress;
}
/**
* @todo 2020-07-05 Kristian Hempel: move this into a MgwPaymentController
*
* @param string $heidelpayCustomerId
*
* @return string|null
* @throws DBALException
* @throws DatabaseConnectionException
* @throws DatabaseErrorException
* @throws StandardException
* @throws SystemComponentException
* @throws d3ShopCompatibilityAdapterException
* @throws d3_cfg_mod_exception
*/
protected function d3UpdateHeidelpayCustomer(
User $oxUser,
Factory $factory,
$heidelpayCustomerId = ""
) {
$currentCustomerId = '';
$customerInterface = $factory->getCustomerHeidelpayInterface(
$oxUser,
$this->getD3HeidelpayDeliveryAddress(),
(bool)trim($oxUser->getFieldData('oxcompany')),
$heidelpayCustomerId
);
$d3log = $factory->getModuleConfiguration()->d3getLog();
try {
$newCustomerInterface = $factory->getHeidelpayInterface()
->createOrUpdateCustomer($customerInterface);
$currentCustomerId = $newCustomerInterface->getId();
$d3log->info(
self::class,
__FUNCTION__,
__LINE__,
'mgw: set customer ID in session',
var_export($currentCustomerId, true)
);
$factory->getOxidProvider()->getSession()->setVariable(
Factory::HeidelpayCustomerIdSessionName,
$currentCustomerId
);
} catch (UnzerApiException $e) {
$d3log->error(
self::class,
__FUNCTION__,
__LINE__,
'mgw: update customer failed',
'merchant message: ' . $e->getMerchantMessage()
);
} catch (RuntimeException $e) {
/** @var $e RuntimeException */
$d3log->error(
self::class,
__FUNCTION__,
__LINE__,
'mgw: update customer failed',
'merchant message: ' . $e->getMessage()
);
}
return $currentCustomerId;
}
public function d3ShowCustomerForm($factory, $isB2bUser = false)
{
if ($isB2bUser) {
return true;
}
return $factory->getModuleProvider()->showSepaGuranteedCustomerFormular();
}
/**
* @param $heidelpayCustomerId
*
* @throws DBALException
* @throws DatabaseConnectionException
* @throws DatabaseErrorException
* @throws StandardException
* @throws SystemComponentException
* @throws d3ShopCompatibilityAdapterException
* @throws d3_cfg_mod_exception
*/
protected function avoidEmptyCustomerName(Factory $factory, $heidelpayCustomerId, User $oxUser, d3log $d3log)
{
try {
$heidelpayInterface = $factory->getHeidelpayInterface();
$customerInterface = $heidelpayInterface->fetchCustomerByExtCustomerId($heidelpayCustomerId);
$names = [
strtolower($customerInterface->getFirstname()),
strtolower($customerInterface->getLastname())
];
if (in_array('unknown', $names) || in_array('', $names)) {
$customerInterface->setFirstname($oxUser->getFieldData('oxfname'));
$customerInterface->setLastname($oxUser->getFieldData('oxlname'));
$customerInterface->setSalutation(strtolower($oxUser->getFieldData('oxsal')));
$customerInterface = $heidelpayInterface->createOrUpdateCustomer($customerInterface);
$factory->getOxidProvider()->getSession()->setVariable(
Factory::HeidelpayCustomerIdSessionName,
$customerInterface->getId()
);
}
} catch (UnzerApiException $unzerApiException) {
$d3log->info(
self::class,
__FUNCTION__,
__LINE__,
'mgw: update customer failed',
var_export($unzerApiException->getMessage(), true)
);
}
}
/**
* @return string
*/
public function d3getCountryCode()
{
$user = $this->getUser();
$oCountry = oxNew(Country::class);
$oCountry->load($user->getFieldData("oxcountryid"));
return $oCountry->getFieldData("oxisoalpha2");
}
}