payment.php

Go to the documentation of this file.

<?php

class Payment extends oxUBase
{

    protected $_oPaymentList = null;

    protected $_iPaymentCnt = null;

    protected $_aAllSets = null;

    protected $_iAllSetsCnt = null;

    protected $_oEmptyPayment = null;

    protected $_sPaymentError = null;

    protected $_sPaymentErrorText = null;

    protected $_aDynValue = null;

    protected $_sCheckedId = null;

    protected $_sCheckedPaymentId = null;

    protected $_aCreditYears = null;

    protected $_sThisTemplate = 'page/checkout/payment.tpl';

    protected $_blIsOrderStep = true;

    protected $_aTsProducts = null;

    protected $_blDynDataFiltered = false;


    public function init()
    {
        $this->_filterDynData();
        parent::init();
    }

    public function render()
    {
        $myConfig = $this->getConfig();

        if ($myConfig->getConfigParam('blPsBasketReservationEnabled')) {
            $this->getSession()->getBasketReservations()->renewExpiration();
        }

        parent::render();

        //if it happens that you are not in SSL
        //then forcing to HTTPS

        //but first checking maybe there were redirection already to prevent infinite redirections
        //due to possible buggy ssl detection on server
        $blAlreadyRedirected = oxRegistry::getConfig()->getRequestParameter('sslredirect') == 'forced';

        if ($this->getIsOrderStep()) {

            //additional check if we really really have a user now
            //and the basket is not empty
            $oBasket = $this->getSession()->getBasket();
            $blPsBasketReservationEnabled = $myConfig->getConfigParam('blPsBasketReservationEnabled');
            if ($blPsBasketReservationEnabled && (!$oBasket || ($oBasket && !$oBasket->getProductsCount()))) {
                oxRegistry::getUtils()->redirect($myConfig->getShopHomeURL() .'cl=basket', true, 302);
            }

            $oUser = $this->getUser();
            if (!$oUser && ($oBasket && $oBasket->getProductsCount() > 0)) {
                oxRegistry::getUtils()->redirect($myConfig->getShopHomeURL() . 'cl=basket', false, 302);
            } elseif (!$oBasket || !$oUser || ($oBasket && !$oBasket->getProductsCount())) {
                oxRegistry::getUtils()->redirect($myConfig->getShopHomeURL() . 'cl=start', false, 302);
            }
        }

        $sFncParameter = oxRegistry::getConfig()->getRequestParameter('fnc');
        if ($myConfig->getCurrentShopURL() != $myConfig->getSSLShopURL() && !$blAlreadyRedirected && !$sFncParameter) {
            $sPayErrorParameter = oxRegistry::getConfig()->getRequestParameter('payerror');
            $sPayErrorTextParameter = oxRegistry::getConfig()->getRequestParameter('payerrortext');
            $shopSecureHomeURL = $myConfig->getShopSecureHomeURL();

            $sPayError = $sPayErrorParameter ?'payerror='.$sPayErrorParameter:'';
            $sPayErrorText = $sPayErrorTextParameter ?'payerrortext='.$sPayErrorTextParameter:'';
            $sRedirectURL = $shopSecureHomeURL .'sslredirect=forced&cl=payment&'.$sPayError."&".$sPayErrorText;
            oxRegistry::getUtils()->redirect($sRedirectURL, true, 302);
        }

        if (!$this->getAllSetsCnt()) {
            // no fitting shipping set found, setting default empty payment
            $this->_setDefaultEmptyPayment();
            oxRegistry::getSession()->setVariable('sShipSet', null);
        }

        $this->_unsetPaymentErrors();

        return $this->_sThisTemplate;
    }

    protected function _setDefaultEmptyPayment()
    {
        // no shipping method there !!
        if ($this->getConfig()->getConfigParam('blOtherCountryOrder')) {
            $oPayment = oxNew('oxpayment');
            if ($oPayment->load('oxempty')) {
                $this->_oEmptyPayment = $oPayment;
            } else {
                // some error with setup ??
                $this->_sPaymentError = -2;
            }
        } else {
            $this->_sPaymentError = -2;
        }
    }

    protected function _unsetPaymentErrors()
    {
        $iPayError = oxRegistry::getConfig()->getRequestParameter('payerror');
        $sPayErrorText = oxRegistry::getConfig()->getRequestParameter('payerrortext');

        if (!($iPayError || $sPayErrorText)) {
            $iPayError = oxRegistry::getSession()->getVariable('payerror');
            $sPayErrorText = oxRegistry::getSession()->getVariable('payerrortext');
        }

        if ($iPayError) {
            oxRegistry::getSession()->deleteVariable('payerror');
            $this->_sPaymentError = $iPayError;
        }
        if ($sPayErrorText) {
            oxRegistry::getSession()->deleteVariable('payerrortext');
            $this->_sPaymentErrorText = $sPayErrorText;
        }
    }

    public function changeshipping()
    {
        $oSession = $this->getSession();

        $oBasket = $oSession->getBasket();
        $oBasket->setShipping(null);
        $oBasket->onUpdate();
        $oSession->setVariable('sShipSet', $this->getConfig()->getRequestParameter('sShipSet'));
    }

    public function validatePayment()
    {
        $myConfig = $this->getConfig();
        $oSession = $this->getSession();

        //#1308C - check user. Function is executed before render(), and oUser is not set!
        // Set it manually for use in methods getPaymentList(), getShippingSetList()...
        $oUser = $this->getUser();
        if (!$oUser) {
            $oSession->setVariable('payerror', 2);

            return;
        }

        if (!($sShipSetId = oxRegistry::getConfig()->getRequestParameter('sShipSet'))) {
            $sShipSetId = $oSession->getVariable('sShipSet');
        }
        if (!($sPaymentId = oxRegistry::getConfig()->getRequestParameter('paymentid'))) {
            $sPaymentId = $oSession->getVariable('paymentid');
        }
        if (!($aDynvalue = oxRegistry::getConfig()->getRequestParameter('dynvalue'))) {
            $aDynvalue = $oSession->getVariable('dynvalue');
        }

        // A. additional protection
        if (!$myConfig->getConfigParam('blOtherCountryOrder') && $sPaymentId == 'oxempty') {
            $sPaymentId = '';
        }

        //#1308C - check if we have paymentID, and it really exists
        if (!$sPaymentId) {
            $oSession->setVariable('payerror', 1);

            return;
        }

        if ($this->getDynDataFiltered() && $sPaymentId == 'oxidcreditcard') {
            $oSession->setVariable('payerror', 7);

            return;
        }

        $oBasket = $oSession->getBasket();
        $oBasket->setPayment(null);
        $oPayment = oxNew('oxpayment');
        $oPayment->load($sPaymentId);

        // getting basket price for payment calculation
        $dBasketPrice = $oBasket->getPriceForPayment();

        $blOK = $oPayment->isValidPayment($aDynvalue, $myConfig->getShopId(), $oUser, $dBasketPrice, $sShipSetId);

        if ($blOK) {
            $oSession->setVariable('paymentid', $sPaymentId);
            $oSession->setVariable('dynvalue', $aDynvalue);
            if (oxRegistry::getConfig()->getRequestParameter('bltsprotection')) {
                $sTsProductId = oxRegistry::getConfig()->getRequestParameter('stsprotection');
                $oBasket->setTsProductId($sTsProductId);
                $oSession->setVariable('stsprotection', $sTsProductId);
            } else {
                $oSession->deleteVariable('stsprotection');
                $oBasket->setTsProductId(null);
            }
            $oBasket->setShipping($sShipSetId);
            $oSession->deleteVariable('_selected_paymentid');

            return 'order';
        } else {
            $oSession->setVariable('payerror', $oPayment->getPaymentErrorNumber());

            //#1308C - delete paymentid from session, and save selected it just for view
            $oSession->deleteVariable('paymentid');
            $oSession->setVariable('_selected_paymentid', $sPaymentId);
            $oSession->deleteVariable('stsprotection');
            $oBasket->setTsProductId(null);

            return;
        }
    }

    public function getPaymentList()
    {
        if ($this->_oPaymentList === null) {
            $this->_oPaymentList = false;

            $sActShipSet = oxRegistry::getConfig()->getRequestParameter('sShipSet');
            if (!$sActShipSet) {
                $sActShipSet = oxRegistry::getSession()->getVariable('sShipSet');
            }

            $oBasket = $this->getSession()->getBasket();

            // load sets, active set, and active set payment list
            list($aAllSets, $sActShipSet, $aPaymentList) =
                oxRegistry::get("oxDeliverySetList")->getDeliverySetData($sActShipSet, $this->getUser(), $oBasket);

            $oBasket->setShipping($sActShipSet);

            // calculating payment expences for preview for each payment
            $this->_setValues($aPaymentList, $oBasket);
            $this->_oPaymentList = $aPaymentList;
            $this->_aAllSets = $aAllSets;

        }

        return $this->_oPaymentList;
    }

    public function getAllSets()
    {
        if ($this->_aAllSets === null) {
            $this->_aAllSets = false;

            if ($this->getPaymentList()) {
                return $this->_aAllSets;
            }
        }

        return $this->_aAllSets;
    }

    public function getAllSetsCnt()
    {
        if ($this->_iAllSetsCnt === null) {
            $this->_iAllSetsCnt = 0;

            if ($this->getPaymentList()) {
                $this->_iAllSetsCnt = count($this->_aAllSets);
            }
        }

        return $this->_iAllSetsCnt;
    }

    protected function _setValues(& $aPaymentList, $oBasket = null)
    {
        if (is_array($aPaymentList)) {
            foreach ($aPaymentList as $oPayment) {
                $oPayment->calculate($oBasket);
                $oPayment->aDynValues = $oPayment->getDynValues();
                if ($oPayment->oxpayments__oxchecked->value) {
                    $this->_sCheckedId = $oPayment->getId();
                }
            }
        }
    }

    public function getEmptyPayment()
    {
        return $this->_oEmptyPayment;
    }

    public function getPaymentError()
    {
        return $this->_sPaymentError;
    }

    public function getDynDataFiltered()
    {
        return $this->_blDynDataFiltered;
    }

    public function getPaymentErrorText()
    {
        return $this->_sPaymentErrorText;
    }

    public function isOldDebitValidationEnabled()
    {
        return !$this->getConfig()->getConfigParam('blSkipDebitOldBankInfo');
    }

    public function getDynValue()
    {
        if ($this->_aDynValue === null) {
            $this->_aDynValue = false;

            // flyspray#1217 (sarunas)
            if (($aDynValue = oxRegistry::getSession()->getVariable('dynvalue'))) {
                $this->_aDynValue = $aDynValue;
            } else {
                $this->_aDynValue = oxRegistry::getConfig()->getRequestParameter("dynvalue");
            }

            // #701A
            // assign debit note payment params to view data
            $aPaymentList = $this->getPaymentList();
            if (isset($aPaymentList['oxiddebitnote'])) {
                $this->_assignDebitNoteParams();
            }
        }

        return $this->_aDynValue;
    }

    protected function _assignDebitNoteParams()
    {
        // #701A
        $oUserPayment = oxNew('oxuserpayment');
        //such info available ?
        if ($oUserPayment->getPaymentByPaymentType($this->getUser(), 'oxiddebitnote')) {
            $sUserPaymentField = 'oxuserpayments__oxvalue';
            $aAddPaymentData = oxRegistry::getUtils()->assignValuesFromText($oUserPayment->$sUserPaymentField->value);

            //checking if some of values is allready set in session - leave it
            foreach ($aAddPaymentData as $oData) {
                if (!isset($this->_aDynValue[$oData->name]) ||
                    (isset($this->_aDynValue[$oData->name]) && !$this->_aDynValue[$oData->name])
                ) {
                    $this->_aDynValue[$oData->name] = $oData->value;
                }
            }
        }
    }

    public function getCheckedPaymentId()
    {
        if ($this->_sCheckedPaymentId === null) {
            if (!($sPaymentID = oxRegistry::getConfig()->getRequestParameter('paymentid'))) {
                $sPaymentID = oxRegistry::getSession()->getVariable('paymentid');
            }
            if ($sPaymentID) {
                $sCheckedId = $sPaymentID;
            } elseif (($sSelectedPaymentID = oxRegistry::getSession()->getVariable('_selected_paymentid'))) {
                $sCheckedId = $sSelectedPaymentID;
            } else {
                // #1010A.
                if ($oUser = $this->getUser()) {
                    $oOrder = oxNew('oxorder');
                    if (($sLastPaymentId = $oOrder->getLastUserPaymentType($oUser->getId()))) {
                        $sCheckedId = $sLastPaymentId;
                    }
                }
            }

            // #M253 set to selected payment in db
            if (!$sCheckedId && $this->_sCheckedId) {
                $sCheckedId = $this->_sCheckedId;
            }

            // #646
            $oPaymentList = $this->getPaymentList();
            if (isset($oPaymentList) && $oPaymentList && !isset($oPaymentList[$sCheckedId])) {
                end($oPaymentList);
                $sCheckedId = key($oPaymentList);
            }
            $this->_sCheckedPaymentId = $sCheckedId;
        }

        return $this->_sCheckedPaymentId;
    }

    public function getPaymentCnt()
    {
        if ($this->_iPaymentCnt === null) {
            $this->_iPaymentCnt = false;

            if ($oPaymentList = $this->getPaymentList()) {
                $this->_iPaymentCnt = count($oPaymentList);
            }
        }

        return $this->_iPaymentCnt;
    }

    public function getCreditYears()
    {
        if ($this->_aCreditYears === null) {
            $this->_aCreditYears = false;

            $this->_aCreditYears = range(date('Y'), date('Y') + 10);
        }

        return $this->_aCreditYears;
    }

    protected function _checkArrValuesEmpty($aData, $aKeys)
    {
        if (!is_array($aKeys) || count($aKeys) < 1) {
            return false;
        }

        foreach ($aKeys as $sKey) {
            if (isset($aData[$sKey]) && !empty($aData[$sKey])) {
                return false;
            }
        }

        return true;
    }


    protected function _filterDynData()
    {
        //in case we actually ARE allowed to store the data
        if (oxRegistry::getConfig()->getConfigParam("blStoreCreditCardInfo")) {
            //then do nothing and reset _blDynDataFiltered
            $this->_blDynDataFiltered = false;

            return;
        }

        $aDynData = $this->getSession()->getVariable("dynvalue");

        $aFields = array("kktype", "kknumber", "kkname", "kkmonth", "kkyear", "kkpruef");

        if ($aDynData) {
            if (!$this->_checkArrValuesEmpty($aDynData, $aFields)) {
                $this->_blDynDataFiltered = true;
            }
            $aDynData["kktype"] = null;
            $aDynData["kknumber"] = null;
            $aDynData["kkname"] = null;
            $aDynData["kkmonth"] = null;
            $aDynData["kkyear"] = null;
            $aDynData["kkpruef"] = null;
            oxRegistry::getSession()->setVariable("dynvalue", $aDynData);
        }

        if (!$this->_checkArrValuesEmpty($_REQUEST["dynvalue"], $aFields) ||
            !$this->_checkArrValuesEmpty($_POST["dynvalue"], $aFields) ||
            !$this->_checkArrValuesEmpty($_GET["dynvalue"], $aFields)
        ) {
            $this->_blDynDataFiltered = true;
        }

        unset($_REQUEST["dynvalue"]["kktype"]);
        unset($_REQUEST["dynvalue"]["kknumber"]);
        unset($_REQUEST["dynvalue"]["kkname"]);
        unset($_REQUEST["dynvalue"]["kkmonth"]);
        unset($_REQUEST["dynvalue"]["kkyear"]);
        unset($_REQUEST["dynvalue"]["kkpruef"]);

        unset($_POST["dynvalue"]["kktype"]);
        unset($_POST["dynvalue"]["kknumber"]);
        unset($_POST["dynvalue"]["kkname"]);
        unset($_POST["dynvalue"]["kkmonth"]);
        unset($_POST["dynvalue"]["kkyear"]);
        unset($_POST["dynvalue"]["kkpruef"]);

        unset($_GET["dynvalue"]["kktype"]);
        unset($_GET["dynvalue"]["kknumber"]);
        unset($_GET["dynvalue"]["kkname"]);
        unset($_GET["dynvalue"]["kkmonth"]);
        unset($_GET["dynvalue"]["kkyear"]);
        unset($_GET["dynvalue"]["kkpruef"]);

    }

    public function getTsProtections()
    {
        if ($this->_aTsProducts === null) {
            $oBasket = $this->getSession()->getBasket();
            $dVat = $oBasket->getAdditionalServicesVatPercent();
            if ($dPrice = $oBasket->getPrice()->getBruttoPrice()) {
                $oTsProtection = oxNew('oxtsprotection');
                $oTsProtection->setVat($dVat);
                $this->_aTsProducts = $oTsProtection->getTsProducts($dPrice);
            }
        }

        return $this->_aTsProducts;
    }

    public function getCheckedTsProductId()
    {
        if ($this->_sCheckedProductId === null) {
            $this->_sCheckedProductId = false;
            if ($sId = oxRegistry::getConfig()->getRequestParameter('stsprotection')) {
                $this->_sCheckedProductId = $sId;
            }
        }

        return $this->_sCheckedProductId;
    }

    public function getBreadCrumb()
    {
        $aPaths = array();
        $aPath = array();


        $iBaseLanguage = oxRegistry::getLang()->getBaseLanguage();
        $aPath['title'] = oxRegistry::getLang()->translateString('PAY', $iBaseLanguage, false);
        $aPath['link'] = $this->getLink();

        $aPaths[] = $aPath;

        return $aPaths;
    }

    public function isPaymentVatSplitted()
    {
        return $this->getConfig()->getConfigParam('blShowVATForPayCharge');
    }
}