oxbasket.php

Go to the documentation of this file.

<?php

class oxBasket extends oxSuperCfg
{

    protected $_aBasketContents = array();

    protected $_iProductsCnt = 0;

    protected $_dItemsCnt = 0.0;

    protected $_dWeight = 0.0;

    protected $_oPrice = null;

    protected $_isCalculationModeNetto = null;

    protected $_dNettoSum = null;

    protected $_dBruttoSum = null;

    protected $_oProductsPriceList = null;

    protected $_aDiscounts = array();

    protected $_aItemDiscounts = array();

    protected $_sOrderId = null;

    protected $_aVouchers = array();

    protected $_aCosts = array();

    protected $_oDiscountProductsPriceList = null;

    protected $_oNotDiscountedProductsPriceList = null;

    protected $_blUpdateNeeded = true;

    protected $_aBasketSummary = null;

    protected $_sPaymentId = null;

    protected $_sShippingSetId = null;

    protected $_oUser = null;

    protected $_oTotalDiscount = null;

    protected $_oVoucherDiscount = null;

    protected $_oCurrency = null;

    protected $_blSkipVouchersAvailabilityChecking = null;

    protected $_dDiscountedProductNettoPrice = null;

    protected $_aDiscountedVats = null;

    protected $_blSkipDiscounts = false;

    protected $_oDeliveryPrice = null;

    protected $_blCheckStock = true;

    protected $_blCalcDiscounts = true;

    protected $_sBasketCategoryId = null;

    protected $_blShowCatChangeWarning = false;

    protected $_sTsProductId = null;

    protected $_blNewITemAdded = null;

    protected $_blDownloadableProducts = null;


    protected $_blSaveToDataBase = null;

    public function enableSaveToDataBase($blSave = true)
    {
        $this->_blSaveToDataBase = $blSave;
    }

    public function isSaveToDataBaseEnabled()
    {
        if (is_null($this->_blSaveToDataBase)) {
            $this->_blSaveToDataBase = (bool) !$this->getConfig()->getConfigParam('blPerfNoBasketSaving');
        }

        return $this->_blSaveToDataBase;
    }


    public function isCalculationModeNetto()
    {
        if ($this->_isCalculationModeNetto === null) {
            $this->setCalculationModeNetto($this->isPriceViewModeNetto());
        }

        return $this->_isCalculationModeNetto;
    }

    public function setCalculationModeNetto($blNettoMode = true)
    {
        $this->_isCalculationModeNetto = (bool) $blNettoMode;
    }

    public function getNettoSum()
    {
        return $this->_dNettoSum;
    }

    public function getBruttoSum()
    {
        return $this->_dBruttoSum;
    }

    public function setNettoSum($dNettoSum)
    {
        $this->_dNettoSum = $dNettoSum;
    }

    public function setBruttoSum($dBruttoSum)
    {
        $this->_dBruttoSum = $dBruttoSum;
    }

    public function isEnabled()
    {
        return !oxRegistry::getUtils()->isSearchEngine();
    }

    protected function _changeBasketItemKey($sOldKey, $sNewKey, $value = null)
    {
        reset($this->_aBasketContents);
        $iOldKeyPlace = 0;
        while (key($this->_aBasketContents) != $sOldKey && next($this->_aBasketContents)) {
            ++$iOldKeyPlace;
        }
        $aNewCopy = array_merge(
            array_slice($this->_aBasketContents, 0, $iOldKeyPlace, true),
            array($sNewKey => $value),
            array_slice($this->_aBasketContents, $iOldKeyPlace + 1, count($this->_aBasketContents) - $iOldKeyPlace, true)
        );
        $this->_aBasketContents = $aNewCopy;
    }

    public function addToBasket($sProductID, $dAmount, $aSel = null, $aPersParam = null, $blOverride = false, $blBundle = false, $sOldBasketItemId = null)
    {
        // enabled ?
        if (!$this->isEnabled()) {
            return null;
        }

        // basket exclude
        if ($this->getConfig()->getConfigParam('blBasketExcludeEnabled')) {
            if (!$this->canAddProductToBasket($sProductID)) {
                $this->setCatChangeWarningState(true);

                return null;
            } else {
                $this->setCatChangeWarningState(false);
            }
        }

        $sItemId = $this->getItemKey($sProductID, $aSel, $aPersParam, $blBundle);
        if ($sOldBasketItemId && (strcmp($sOldBasketItemId, $sItemId) != 0)) {
            if (isset($this->_aBasketContents[$sItemId])) {
                // we are merging, so params will just go to the new key
                unset($this->_aBasketContents[$sOldBasketItemId]);
                // do not override stock
                $blOverride = false;
            } else {
                // value is null - means isset will fail and real values will be filled
                $this->_changeBasketItemKey($sOldBasketItemId, $sItemId);
            }
        }

        // after some checks item must be removed from basket
        $blRemoveItem = false;

        // initialling exception storage
        $oEx = null;

        if (isset($this->_aBasketContents[$sItemId])) {

            //updating existing
            try {
                // setting stock check status
                $this->_aBasketContents[$sItemId]->setStockCheckStatus($this->getStockCheckMode());
                //validate amount
                //possibly throws exception
                $this->_aBasketContents[$sItemId]->setAmount($dAmount, $blOverride, $sItemId);
            } catch (oxOutOfStockException $oEx) {
                // rethrow later
            }

        } else {
            //inserting new
            $oBasketItem = oxNew('oxbasketitem');
            try {
                $oBasketItem->setStockCheckStatus($this->getStockCheckMode());
                $oBasketItem->init($sProductID, $dAmount, $aSel, $aPersParam, $blBundle);
            } catch (oxNoArticleException $oEx) {
                // in this case that the article does not exist remove the item from the basket by setting its amount to 0
                //$oBasketItem->dAmount = 0;
                $blRemoveItem = true;

            } catch (oxOutOfStockException $oEx) {
                // rethrow later
            } catch (oxArticleInputException $oEx) {
                // rethrow later
                $blRemoveItem = true;
            }

            $this->_aBasketContents[$sItemId] = $oBasketItem;
        }

        //in case amount is 0 removing item
        if ($this->_aBasketContents[$sItemId]->getAmount() == 0 || $blRemoveItem) {
            $this->removeItem($sItemId);
        } elseif ($blBundle) {
            //marking bundles
            $this->_aBasketContents[$sItemId]->setBundle(true);
        }

        //calling update method
        $this->onUpdate();

        if ($oEx) {
            throw $oEx;
        }

        // notifying that new basket item was added
        if (!$blBundle) {
            $this->_addedNewItem($sProductID, $dAmount, $aSel, $aPersParam, $blOverride, $blBundle, $sOldBasketItemId);
        }

        // returning basket item object
        return $this->_aBasketContents[$sItemId];
    }

    public function addOrderArticleToBasket($oOrderArticle)
    {
        // adding only if amount > 0
        if ($oOrderArticle->oxorderarticles__oxamount->value > 0 && !$oOrderArticle->isBundle()) {

            $this->_isForOrderRecalculation = true;
            $sItemId = $oOrderArticle->getId();

            //inserting new
            $this->_aBasketContents[$sItemId] = oxNew('oxbasketitem');
            $this->_aBasketContents[$sItemId]->initFromOrderArticle($oOrderArticle);
            $this->_aBasketContents[$sItemId]->setWrapping($oOrderArticle->oxorderarticles__oxwrapid->value);
            $this->_aBasketContents[$sItemId]->setBundle($oOrderArticle->isBundle());

            //calling update method
            $this->onUpdate();

            return $this->_aBasketContents[$sItemId];
        } elseif ($oOrderArticle->isBundle()) {
            // deleting bundles, they are handled automatically
            $oOrderArticle->delete();
        }
    }

    public function setStockCheckMode($blCheck)
    {
        $this->_blCheckStock = $blCheck;
    }

    public function getStockCheckMode()
    {
        return $this->_blCheckStock;
    }

    public function getItemKey($sProductId, $aSel = null, $aPersParam = null, $blBundle = false, $sAdditionalParam = '')
    {
        $aSel = ($aSel != null) ? $aSel : array(0 => '0');

        $sItemKey = md5($sProductId . '|' . serialize($aSel) . '|' . serialize($aPersParam) . '|' . ( int ) $blBundle . '|' . serialize($sAdditionalParam));

        return $sItemKey;
    }


    public function removeItem($sItemKey)
    {
        if ($this->getConfig()->getConfigParam('blPsBasketReservationEnabled')) {
            if (isset($this->_aBasketContents[$sItemKey])) {
                $sArticleId = $this->_aBasketContents[$sItemKey]->getProductId();
                if ($sArticleId) {
                    $this->getSession()
                        ->getBasketReservations()
                        ->discardArticleReservation($sArticleId);
                }
            }
        }
        unset($this->_aBasketContents[$sItemKey]);

        // basket exclude
        if (!count($this->_aBasketContents) && $this->getConfig()->getConfigParam('blBasketExcludeEnabled')) {
            $this->setBasketRootCatId(null);
        }
    }

    protected function _clearBundles()
    {
        reset($this->_aBasketContents);
        while (list($sItemKey, $oBasketItem) = each($this->_aBasketContents)) {
            if ($oBasketItem->isBundle()) {
                $this->removeItem($sItemKey);
            }
        }
    }

    protected function _getArticleBundles($oBasketItem)
    {
        $aBundles = array();

        if ($oBasketItem->isBundle()) {
            return $aBundles;
        }

        $oArticle = $oBasketItem->getArticle(true);
        if ($oArticle && $oArticle->oxarticles__oxbundleid->value) {
            $aBundles[$oArticle->oxarticles__oxbundleid->value] = 1;
        }

        return $aBundles;
    }


    protected function _getItemBundles($oBasketItem, $aBundles = array())
    {
        if ($oBasketItem->isBundle()) {
            return array();
        }

        // does this object still exists ?
        if ($oArticle = $oBasketItem->getArticle()) {
            $aDiscounts = oxRegistry::get("oxDiscountList")->getBasketItemBundleDiscounts($oArticle, $this, $this->getBasketUser());

            foreach ($aDiscounts as $oDiscount) {

                $iAmnt = $oDiscount->getBundleAmount($oBasketItem->getAmount());
                if ($iAmnt) {
                    //init array element
                    if (!isset($aBundles[$oDiscount->oxdiscount__oxitmartid->value])) {
                        $aBundles[$oDiscount->oxdiscount__oxitmartid->value] = 0;
                    }

                    if ($oDiscount->oxdiscount__oxitmmultiple->value) {
                        $aBundles[$oDiscount->oxdiscount__oxitmartid->value] += $iAmnt;
                    } else {
                        $aBundles[$oDiscount->oxdiscount__oxitmartid->value] = $iAmnt;
                    }
                }
            }
        }

        return $aBundles;
    }

    protected function _getBasketBundles($aBundles = array())
    {
        $aDiscounts = oxRegistry::get("oxDiscountList")->getBasketBundleDiscounts($this, $this->getBasketUser());

        // calculating amount of non bundled/discount items
        $dAmount = 0;
        foreach ($this->_aBasketContents as $oBasketItem) {
            if (!($oBasketItem->isBundle() || $oBasketItem->isDiscountArticle())) {
                $dAmount += $oBasketItem->getAmount();
            }
        }

        foreach ($aDiscounts as $oDiscount) {
            if ($oDiscount->oxdiscount__oxitmartid->value) {
                if (!isset($aBundles[$oDiscount->oxdiscount__oxitmartid->value])) {
                    $aBundles[$oDiscount->oxdiscount__oxitmartid->value] = 0;
                }

                $aBundles[$oDiscount->oxdiscount__oxitmartid->value] += $oDiscount->getBundleAmount($dAmount);
            }
        }

        return $aBundles;
    }

    protected function _addBundles()
    {
        $aBundles = array();
        // iterating through articles and binding bundles
        foreach ($this->_aBasketContents as $key => $oBasketItem) {
            try {
                // adding discount type bundles
                if (!$oBasketItem->isDiscountArticle() && !$oBasketItem->isBundle()) {
                    $aBundles = $this->_getItemBundles($oBasketItem, $aBundles);
                } else {
                    continue;
                }

                // adding item type bundles
                $aArtBundles = $this->_getArticleBundles($oBasketItem);

                // adding bundles to basket
                $this->_addBundlesToBasket($aArtBundles);
            } catch (oxNoArticleException $oEx) {
                $this->removeItem($key);
                oxRegistry::get("oxUtilsView")->addErrorToDisplay($oEx);
            } catch (oxArticleInputException $oEx) {
                $this->removeItem($key);
                oxRegistry::get("oxUtilsView")->addErrorToDisplay($oEx);
            }
        }

        // adding global basket bundles
        $aBundles = $this->_getBasketBundles($aBundles);

        // adding all bundles to basket
        if ($aBundles) {
            $this->_addBundlesToBasket($aBundles);
        }
    }

    protected function _addBundlesToBasket($aBundles)
    {
        foreach ($aBundles as $sBundleId => $dAmount) {
            if ($dAmount) {
                try {
                    if ($oBundleItem = $this->addToBasket($sBundleId, $dAmount, null, null, false, true)) {
                        $oBundleItem->setAsDiscountArticle(true);
                    }
                } catch (oxArticleException $oEx) {
                    // caught and ignored
                }
            }
        }

    }

    protected function _calcItemsPrice()
    {
        // resetting
        $this->setSkipDiscounts(false);
        $this->_iProductsCnt = 0; // count different types
        $this->_dItemsCnt = 0; // count of item units
        $this->_dWeight = 0; // basket weight

        $this->_oProductsPriceList = oxNew('oxpricelist');
        $this->_oDiscountProductsPriceList = oxNew('oxpricelist');
        $this->_oNotDiscountedProductsPriceList = oxNew('oxpricelist');

        $oDiscountList = oxRegistry::get("oxDiscountList");

        foreach ($this->_aBasketContents as $oBasketItem) {
            $this->_iProductsCnt++;
            $this->_dItemsCnt += $oBasketItem->getAmount();
            $this->_dWeight += $oBasketItem->getWeight();

            if (!$oBasketItem->isDiscountArticle() && ($oArticle = $oBasketItem->getArticle(true))) {

                $oBasketPrice = $oArticle->getBasketPrice($oBasketItem->getAmount(), $oBasketItem->getSelList(), $this);
                $oBasketItem->setRegularUnitPrice(clone $oBasketPrice);

                if (!$oArticle->skipDiscounts() && $this->canCalcDiscounts()) {
                    // apply basket type discounts for item
                    $aDiscounts = $oDiscountList->getBasketItemDiscounts($oArticle, $this, $this->getBasketUser());
                    reset($aDiscounts);
                    foreach ($aDiscounts as $oDiscount) {
                        $oBasketPrice->setDiscount($oDiscount->getAddSum(), $oDiscount->getAddSumType());
                    }
                    $oBasketPrice->calculateDiscount();
                } else {
                    $oBasketItem->setSkipDiscounts(true);
                    $this->setSkipDiscounts(true);
                }

                $oBasketItem->setPrice($oBasketPrice);
                $this->_oProductsPriceList->addToPriceList($oBasketItem->getPrice());

                //P collect discount values for basket items which are discountable
                if (!$oArticle->skipDiscounts()) {

                    $this->_oDiscountProductsPriceList->addToPriceList($oBasketItem->getPrice());
                } else {
                    $this->_oNotDiscountedProductsPriceList->addToPriceList($oBasketItem->getPrice());
                    $oBasketItem->setSkipDiscounts(true);
                    $this->setSkipDiscounts(true);
                }
            } elseif ($oBasketItem->isBundle()) {
                // if bundles price is set to zero
                $oPrice = oxNew("oxprice");
                $oBasketItem->setPrice($oPrice);
            }
        }
    }

    public function setDiscountCalcMode($blCalcDiscounts)
    {
        $this->_blCalcDiscounts = $blCalcDiscounts;
    }

    public function canCalcDiscounts()
    {
        return $this->_blCalcDiscounts;
    }

    protected function _mergeDiscounts($aDiscounts, $aItemDiscounts)
    {
        foreach ($aItemDiscounts as $sKey => $oDiscount) {
            // add prices of the same discounts
            if (array_key_exists($sKey, $aDiscounts)) {
                $aDiscounts[$sKey]->dDiscount += $oDiscount->dDiscount;
            } else {
                $aDiscounts[$sKey] = $oDiscount;
            }
        }

        return $aDiscounts;
    }

    protected function _calcDeliveryCost()
    {
        if ($this->_oDeliveryPrice !== null) {
            return $this->_oDeliveryPrice;
        }
        $myConfig = $this->getConfig();
        $oDeliveryPrice = oxNew('oxprice');

        if ($this->getConfig()->getConfigParam('blDeliveryVatOnTop')) {
            $oDeliveryPrice->setNettoPriceMode();
        } else {
            $oDeliveryPrice->setBruttoPriceMode();
        }

        // don't calculate if not logged in
        $oUser = $this->getBasketUser();

        if (!$oUser && !$myConfig->getConfigParam('blCalculateDelCostIfNotLoggedIn')) {
            return $oDeliveryPrice;
        }

        $fDelVATPercent = $this->getAdditionalServicesVatPercent();
        $oDeliveryPrice->setVat($fDelVATPercent);

        // list of active delivery costs
        if ($myConfig->getConfigParam('bl_perfLoadDelivery')) {
            $aDeliveryList = oxRegistry::get("oxDeliveryList")->getDeliveryList(
                $this,
                $oUser,
                $this->_findDelivCountry(),
                $this->getShippingId()
            );

            if (count($aDeliveryList) > 0) {
                foreach ($aDeliveryList as $oDelivery) {
                    //debug trace
                    if ($myConfig->getConfigParam('iDebug') == 5) {
                        echo("DelCost : " . $oDelivery->oxdelivery__oxtitle->value . "<br>");
                    }
                    $oDeliveryPrice->addPrice($oDelivery->getDeliveryPrice($fDelVATPercent));
                }
            }
        }

        return $oDeliveryPrice;
    }

    public function getBasketUser()
    {
        if ($this->_oUser == null) {
            return $this->getUser();
        }

        return $this->_oUser;
    }

    public function setBasketUser($oUser)
    {
        $this->_oUser = $oUser;
    }

    //P
    public function getMostUsedVatPercent()
    {
        if ($this->_oProductsPriceList) {
            return $this->_oProductsPriceList->getMostUsedVatPercent();
        }
    }

    public function getAdditionalServicesVatPercent()
    {
        if ($this->_oProductsPriceList) {
            if ($this->getConfig()->getConfigParam('sAdditionalServVATCalcMethod') == 'proportional') {
                return $this->_oProductsPriceList->getProportionalVatPercent();
            } else {
                return $this->_oProductsPriceList->getMostUsedVatPercent();
            }
        }
    }

    public function isProportionalCalculationOn()
    {
        if ($this->getConfig()->getConfigParam('sAdditionalServVATCalcMethod') == 'proportional') {
            return true;
        }

        return false;
    }


    //P
    protected function _calcTotalPrice()
    {
        // 1. add products price
        $dPrice = $this->_dBruttoSum;

        $oTotalPrice = oxNew('oxPrice');
        $oTotalPrice->setBruttoPriceMode();
        $oTotalPrice->setPrice($dPrice);

        // 2. subtract discounts
        if ($dPrice && !$this->isCalculationModeNetto()) {

            // 2.2 applying basket discounts
            $oTotalPrice->subtract($this->_oTotalDiscount->getBruttoPrice());

            // 2.3 applying voucher discounts
            if ($oVoucherDisc = $this->getVoucherDiscount()) {
                $oTotalPrice->subtract($oVoucherDisc->getBruttoPrice());
            }
        }

        // 2.3 add delivery cost
        if (isset($this->_aCosts['oxdelivery'])) {
            $oTotalPrice->add($this->_aCosts['oxdelivery']->getBruttoPrice());
        }

        // 2.4 add wrapping price
        if (isset($this->_aCosts['oxwrapping'])) {
            $oTotalPrice->add($this->_aCosts['oxwrapping']->getBruttoPrice());
        }
        if (isset($this->_aCosts['oxgiftcard'])) {
            $oTotalPrice->add($this->_aCosts['oxgiftcard']->getBruttoPrice());
        }

        // 2.5 add payment price
        if (isset($this->_aCosts['oxpayment'])) {
            $oTotalPrice->add($this->_aCosts['oxpayment']->getBruttoPrice());
        }

        // 2.6 add TS protection price
        if (isset($this->_aCosts['oxtsprotection'])) {
            $oTotalPrice->add($this->_aCosts['oxtsprotection']->getBruttoPrice());
        }

        $this->setPrice($oTotalPrice);
    }

    public function setVoucherDiscount($dDiscount)
    {
        $this->_oVoucherDiscount = oxNew('oxPrice');
        $this->_oVoucherDiscount->setBruttoPriceMode();
        $this->_oVoucherDiscount->add($dDiscount);
    }

    protected function _calcVoucherDiscount()
    {
        if ($this->getConfig()->getConfigParam('bl_showVouchers') && ($this->_oVoucherDiscount === null || ($this->_blUpdateNeeded && !$this->isAdmin()))) {

            $this->_oVoucherDiscount = $this->_getPriceObject();

            // calculating price to apply discount
            $dPrice = $this->_oDiscountProductsPriceList->getSum($this->isCalculationModeNetto()) - $this->_oTotalDiscount->getPrice();

            // recalculating
            if (count($this->_aVouchers)) {
                $oLang = oxRegistry::getLang();
                foreach ($this->_aVouchers as $sVoucherId => $oStdVoucher) {
                    $oVoucher = oxNew('oxvoucher');
                    try { // checking
                        $oVoucher->load($oStdVoucher->sVoucherId);

                        if (!$this->_blSkipVouchersAvailabilityChecking) {
                            $oVoucher->checkBasketVoucherAvailability($this->_aVouchers, $dPrice);
                            $oVoucher->checkUserAvailability($this->getBasketUser());
                        }

                        // assigning real voucher discount value as this is the only place where real value is calculated
                        $dVoucherdiscount = $oVoucher->getDiscountValue($dPrice);

                        if ($dVoucherdiscount > 0) {

                            if ($oVoucher->getDiscountType() == 'absolute') {
                                $dVatPart = ($dPrice - $dVoucherdiscount) / $dPrice * 100;
                            } else {
                                $dVatPart = 100 - $oVoucher->getDiscount();
                            }

                            if (!$this->_aDiscountedVats) {
                                if ($oPriceList = $this->getDiscountProductsPrice()) {
                                    $this->_aDiscountedVats = $oPriceList->getVatInfo($this->isCalculationModeNetto());
                                }
                            }

                            // apply discount to vat
                            foreach ($this->_aDiscountedVats as $sKey => $dVat) {
                                $this->_aDiscountedVats[$sKey] = oxPrice::percent($dVat, $dVatPart);
                            }
                        }

                        // accumulating discount value
                        $this->_oVoucherDiscount->add($dVoucherdiscount);

                        // collecting formatted for preview
                        $oStdVoucher->fVoucherdiscount = $oLang->formatCurrency($dVoucherdiscount, $this->getBasketCurrency());
                        $oStdVoucher->dVoucherdiscount = $dVoucherdiscount;

                        // subtracting voucher discount
                        $dPrice = $dPrice - $dVoucherdiscount;


                    } catch (oxVoucherException $oEx) {

                        // removing voucher on error
                        $oVoucher->unMarkAsReserved();
                        unset($this->_aVouchers[$sVoucherId]);

                        // storing voucher error info
                        oxRegistry::get("oxUtilsView")->addErrorToDisplay($oEx, false, true);
                    }
                }
            }
        }
    }

    protected function _applyDiscounts()
    {
        //apply discounts for brutto price
        $dDiscountedSum = $this->_getDiscountedProductsSum();

        $oUtils = oxRegistry::getUtils();
        $dVatSum = 0;
        foreach ($this->_aDiscountedVats as $dVat) {
            $dVatSum += $oUtils->fRound($dVat, $this->_oCurrency);
        }

        $oNotDiscounted = $this->getNotDiscountProductsPrice();

        if ($this->isCalculationModeNetto()) {
            // netto view mode
            $this->setNettoSum($this->getProductsPrice()->getSum());
            $this->setBruttoSum($oNotDiscounted->getSum(false) + $dDiscountedSum + $dVatSum);
        } else {
            // brutto view mode
            $this->setNettoSum($oNotDiscounted->getSum() + $dDiscountedSum - $dVatSum);
            $this->setBruttoSum($this->getProductsPrice()->getSum(false));
        }
    }

    public function isPriceViewModeNetto()
    {
        $blResult = (bool) $this->getConfig()->getConfigParam('blShowNetPrice');
        $oUser = $this->getBasketUser();
        if ($oUser) {
            $blResult = $oUser->isPriceViewModeNetto();
        }

        return $blResult;
    }

    protected function _getPriceObject()
    {
        $oPrice = oxNew('oxPrice');

        if ($this->isCalculationModeNetto()) {
            $oPrice->setNettoPriceMode();
        } else {
            $oPrice->setBruttoPriceMode();
        }

        return $oPrice;
    }

    protected function _calcBasketDiscount()
    {
        // resetting
        $this->_aDiscounts = array();

        // P using prices sum which has discount, not sum of skipped discounts
        $dOldPrice = $this->_oDiscountProductsPriceList->getSum($this->isCalculationModeNetto());

        // add basket discounts
        if ($this->_oTotalDiscount !== null && isset($this->_isForOrderRecalculation) && $this->_isForOrderRecalculation) {
            //if total discount was set on order recalculation
            $oTotalPrice = $this->getTotalDiscount();
            $oDiscount = oxNew('oxDiscount');
            $oDiscount->oxdiscount__oxaddsum = new oxField($oTotalPrice->getPrice());
            $oDiscount->oxdiscount__oxaddsumtype = new oxField('abs');
            $aDiscounts[] = $oDiscount;
        } else {
            // discounts for basket
            $aDiscounts = oxRegistry::get("oxDiscountList")->getBasketDiscounts($this, $this->getBasketUser());
        }

        if ($oPriceList = $this->getDiscountProductsPrice()) {
            $this->_aDiscountedVats = $oPriceList->getVatInfo($this->isCalculationModeNetto());
        }

        foreach ($aDiscounts as $oDiscount) {

            // storing applied discounts
            $oStdDiscount = $oDiscount->getSimpleDiscount();

            // skipping bundle discounts
            if ($oDiscount->oxdiscount__oxaddsumtype->value == 'itm') {
                continue;
            }

            // saving discount info
            $oStdDiscount->dDiscount = $oDiscount->getAbsValue($dOldPrice);

            $dVatPart = 100 - $oDiscount->getPercentage($dOldPrice);

            // if discount is more than basket sum
            if ($dOldPrice < $oStdDiscount->dDiscount) {
                $oStdDiscount->dDiscount = $dOldPrice;
                $dVatPart = 0;
            }

            // apply discount to vat
            foreach ($this->_aDiscountedVats as $sKey => $dVat) {
                $this->_aDiscountedVats[$sKey] = oxPrice::percent($dVat, $dVatPart);
            }

            //storing discount
            if ($oStdDiscount->dDiscount != 0) {
                $this->_aDiscounts[$oDiscount->getId()] = $oStdDiscount;
                // subtracting product price after discount
                $dOldPrice = $dOldPrice - $oStdDiscount->dDiscount;
            }
        }
    }

    protected function _calcBasketTotalDiscount()
    {
        if ($this->_oTotalDiscount === null || (!$this->isAdmin())) {

            $this->_oTotalDiscount = $this->_getPriceObject();

            if (is_array($this->_aDiscounts)) {
                foreach ($this->_aDiscounts as $oDiscount) {

                    // skipping bundle discounts
                    if ($oDiscount->sType == 'itm') {
                        continue;
                    }

                    // add discount value to total basket discount
                    $this->_oTotalDiscount->add($oDiscount->dDiscount);
                }
            }
        }
    }

    protected function _calcBasketWrapping()
    {
        $oWrappingPrices = oxNew('oxPriceList');

        foreach ($this->_aBasketContents as $oBasketItem) {

            if (($oWrapping = $oBasketItem->getWrapping())) {

                $oWrappingPrice = $oWrapping->getWrappingPrice($oBasketItem->getAmount());
                $oWrappingPrice->setVat($oBasketItem->getPrice()->getVat());

                $oWrappingPrices->addToPriceList($oWrappingPrice);
            }
        }

        if ($oWrappingPrices->getCount()) {
            $oWrappingCost = oxNew('oxPrice');
            $oWrappingCost = $oWrappingPrices->calculateToPrice();
        }

        return $oWrappingCost;
    }

    protected function _calcBasketGiftCard()
    {
        $oGiftCardPrice = oxNew('oxPrice');

        if ($this->getConfig()->getConfigParam('blWrappingVatOnTop')) {
            $oGiftCardPrice->setNettoPriceMode();
        } else {
            $oGiftCardPrice->setBruttoPriceMode();
        }

        $dVATPercent = $this->getAdditionalServicesVatPercent();

        $oGiftCardPrice->setVat($dVATPercent);

        // gift card price calculation
        if (($oCard = $this->getCard())) {
            if ($dVATPercent !== null) {
                $oCard->setWrappingVat($dVATPercent);
            }
            $oGiftCardPrice->addPrice($oCard->getWrappingPrice());
        }

        return $oGiftCardPrice;
    }

    protected function _calcPaymentCost()
    {
        // resetting values
        $oPaymentPrice = oxNew('oxPrice');

        // payment
        if (($this->_sPaymentId = $this->getPaymentId())) {

            $oPayment = oxNew('oxPayment');
            $oPayment->load($this->_sPaymentId);

            $oPayment->calculate($this);
            $oPaymentPrice = $oPayment->getPrice();
        }

        return $oPaymentPrice;
    }

    protected function _calcTsProtectionCost()
    {
        if (($this->getTsProductId())) {
            $oTsProtection = oxNew('oxtsprotection');
            $oTsProduct = $oTsProtection->getTsProduct($this->getTsProductId());
            $oProtectionPrice = $oTsProduct->getPrice();
            $oProtectionPrice->setVat($this->getAdditionalServicesVatPercent());
        } else {
            $oProtectionPrice = oxNew('oxPrice');
        }

        return $oProtectionPrice;
    }

    public function setCost($sCostName, $oPrice = null)
    {
        $this->_aCosts[$sCostName] = $oPrice;
    }

    public function calculateBasket($blForceUpdate = false)
    {
        /*
        //would be good to perform the reset of previous calculation
        //at least you can use it for the debug
        $this->_aDiscounts = array();
        $this->_aItemDiscounts = array();
        $this->_oTotalDiscount = null;
        $this->_dDiscountedProductNettoPrice = 0;
        $this->_aDiscountedVats = array();
        $this->_oPrice = null;
        $this->_oNotDiscountedProductsPriceList = null;
        $this->_oProductsPriceList = null;
        $this->_oDiscountProductsPriceList = null;*/

        if (!$this->isEnabled()) {
            return;
        }

        if ($blForceUpdate) {
            $this->onUpdate();
        }

        if (!($this->_blUpdateNeeded || $blForceUpdate)) {
            return;
        }

        $this->_aCosts = array();

        //  1. saving basket to the database
        $this->_save();

        //  2. remove all bundles
        $this->_clearBundles();

        //  3. generate bundle items
        $this->_addBundles();

        // reserve active basket
        if ($this->getConfig()->getConfigParam('blPsBasketReservationEnabled')) {
            $this->getSession()->getBasketReservations()->reserveBasket($this);
        }

        //  4. calculating item prices
        $this->_calcItemsPrice();

        //  5. calculating/applying discounts
        $this->_calcBasketDiscount();

        //  6. calculating basket total discount
        $this->_calcBasketTotalDiscount();

        //  7. check for vouchers
        $this->_calcVoucherDiscount();

        //  8. applies all discounts to pricelist
        $this->_applyDiscounts();

        //  9. calculating additional costs:
        //  9.1: delivery
        $this->setCost('oxdelivery', $this->_calcDeliveryCost());

        //  9.2: adding wrapping and gift card costs
        $this->setCost('oxwrapping', $this->_calcBasketWrapping());

        $this->setCost('oxgiftcard', $this->_calcBasketGiftCard());

        //  9.3: adding payment cost
        $this->setCost('oxpayment', $this->_calcPaymentCost());

        //  9.4: adding TS protection cost
        $this->setCost('oxtsprotection', $this->_calcTsProtectionCost());

        //  10. calculate total price
        $this->_calcTotalPrice();

        //  11. formatting discounts
        $this->formatDiscount();

        //  12.setting to up-to-date status
        $this->afterUpdate();
    }

    public function onUpdate()
    {
        $this->_blUpdateNeeded = true;
    }

    public function afterUpdate()
    {
        $this->_blUpdateNeeded = false;
    }

    public function getBasketSummary()
    {
        if ($this->_blUpdateNeeded || $this->_aBasketSummary === null) {
            $this->_aBasketSummary = new stdclass();
            $this->_aBasketSummary->aArticles = array();
            $this->_aBasketSummary->aCategories = array();
            $this->_aBasketSummary->iArticleCount = 0;
            $this->_aBasketSummary->dArticlePrice = 0;
            $this->_aBasketSummary->dArticleDiscountablePrice = 0;
        }

        if (!$this->isEnabled()) {
            return $this->_aBasketSummary;
        }

        $myConfig = $this->getConfig();
        foreach ($this->_aBasketContents as $oBasketItem) {
            if (!$oBasketItem->isBundle() && $oArticle = $oBasketItem->getArticle(false)) {
                $aCatIds = $oArticle->getCategoryIds();
                //#M530 if price is not loaded for articles
                $dPrice = 0;
                $dDiscountablePrice = 0;
                if (($oPrice = $oArticle->getBasketPrice($oBasketItem->getAmount(), $oBasketItem->getSelList(), $this))) {
                    $dPrice = $oPrice->getPrice();
                    if (!$oArticle->skipDiscounts()) {
                        $dDiscountablePrice = $dPrice;
                    }
                }

                foreach ($aCatIds as $sCatId) {
                    if (!isset($this->_aBasketSummary->aCategories[$sCatId])) {
                        $this->_aBasketSummary->aCategories[$sCatId] = new stdClass();
                    }

                    $this->_aBasketSummary->aCategories[$sCatId]->dPrice += $dPrice * $oBasketItem->getAmount();
                    $this->_aBasketSummary->aCategories[$sCatId]->dDiscountablePrice += $dDiscountablePrice * $oBasketItem->getAmount();
                    $this->_aBasketSummary->aCategories[$sCatId]->dAmount += $oBasketItem->getAmount();
                    $this->_aBasketSummary->aCategories[$sCatId]->iCount++;
                }

                // variant handling
                if (($sParentId = $oArticle->getParentId()) && $myConfig->getConfigParam('blVariantParentBuyable')) {
                    if (!isset($this->_aBasketSummary->aArticles[$sParentId])) {
                        $this->_aBasketSummary->aArticles[$sParentId] = 0;
                    }
                    $this->_aBasketSummary->aArticles[$sParentId] += $oBasketItem->getAmount();
                }

                if (!isset($this->_aBasketSummary->aArticles[$oBasketItem->getProductId()])) {
                    $this->_aBasketSummary->aArticles[$oBasketItem->getProductId()] = 0;
                }

                $this->_aBasketSummary->aArticles[$oBasketItem->getProductId()] += $oBasketItem->getAmount();
                $this->_aBasketSummary->iArticleCount += $oBasketItem->getAmount();
                $this->_aBasketSummary->dArticlePrice += $dPrice * $oBasketItem->getAmount();
                $this->_aBasketSummary->dArticleDiscountablePrice += $dDiscountablePrice * $oBasketItem->getAmount();
            }
        }

        return $this->_aBasketSummary;
    }

    public function addVoucher($sVoucherId)
    {
        // calculating price to check
        // P using prices sum which has discount, not sum of skipped discounts
        $dPrice = 0;
        if ($this->_oDiscountProductsPriceList) {
            $dPrice = $this->_oDiscountProductsPriceList->getSum($this->isCalculationModeNetto());
        }

        try { // trying to load voucher and apply it

            $oVoucher = oxNew('oxvoucher');

            if (!$this->_blSkipVouchersAvailabilityChecking) {
                $oVoucher->getVoucherByNr($sVoucherId, $this->_aVouchers, true);
                $oVoucher->checkVoucherAvailability($this->_aVouchers, $dPrice);
                $oVoucher->checkUserAvailability($this->getBasketUser());
                $oVoucher->markAsReserved();
            } else {
                $oVoucher->load($sVoucherId);
            }

            // saving voucher info
            $this->_aVouchers[$oVoucher->oxvouchers__oxid->value] = $oVoucher->getSimpleVoucher();
        } catch (oxVoucherException $oEx) {

            // problems adding voucher
            oxRegistry::get("oxUtilsView")->addErrorToDisplay($oEx, false, true);
        }

        $this->onUpdate();
    }

    public function removeVoucher($sVoucherId)
    {
        // removing if it exists
        if (isset($this->_aVouchers[$sVoucherId])) {

            $oVoucher = oxNew('oxVoucher');
            $oVoucher->load($sVoucherId);

            $oVoucher->unMarkAsReserved();

            // unset it if exists this voucher in DB or not
            unset($this->_aVouchers[$sVoucherId]);
            $this->onUpdate();
        }

    }

    public function resetUserInfo()
    {
        $this->setPayment(null);
        $this->setShipping(null);
    }

    protected function formatDiscount()
    {
        // discount information
        // formatting discount value
        $this->aDiscounts = $this->getDiscounts();
        if (count($this->aDiscounts) > 0) {
            $oLang = oxRegistry::getLang();
            foreach ($this->aDiscounts as $oDiscount) {
                $oDiscount->fDiscount = $oLang->formatCurrency($oDiscount->dDiscount, $this->getBasketCurrency());
            }
        }
    }

    protected function _canSaveBasket()
    {
        return $this->isSaveToDataBaseEnabled();
    }

    public function load()
    {
        $oUser = $this->getBasketUser();
        if (!$oUser) {
            return;
        }

        $oBasket = $oUser->getBasket('savedbasket');

        // restoring from saved history
        $aSavedItems = $oBasket->getItems();
        foreach ($aSavedItems as $oItem) {
            try {
                $oSelList = $oItem->getSelList();

                $this->addToBasket($oItem->oxuserbasketitems__oxartid->value, $oItem->oxuserbasketitems__oxamount->value, $oSelList, $oItem->getPersParams(), true);
            } catch (oxArticleException $oEx) {
                // caught and ignored
            }
        }
    }

    protected function _save()
    {
        if ($this->isSaveToDataBaseEnabled()) {

            if ($oUser = $this->getBasketUser()) {
                //first delete all contents
                //#2039
                $oSavedBasket = $oUser->getBasket('savedbasket');
                $oSavedBasket->delete();

                //then save
                foreach ($this->_aBasketContents as $oBasketItem) {
                    // discount or bundled products will be added automatically if available
                    if (!$oBasketItem->isBundle() && !$oBasketItem->isDiscountArticle()) {
                        $oSavedBasket->addItemToBasket($oBasketItem->getProductId(), $oBasketItem->getAmount(), $oBasketItem->getSelList(), true, $oBasketItem->getPersParams());
                    }
                }
            }
        }
    }

    protected function _deleteSavedBasket()
    {
        // deleting basket if session user available
        if ($oUser = $this->getBasketUser()) {
            $oUser->getBasket('savedbasket')->delete();
        }

        // basket exclude
        if ($this->getConfig()->getConfigParam('blBasketExcludeEnabled')) {
            $this->setBasketRootCatId(null);
        }
    }

    protected function _findDelivCountry()
    {
        $myConfig = $this->getConfig();
        $oUser = $this->getBasketUser();

        $sDeliveryCountry = null;

        if (!$oUser) {
            // don't calculate if not logged in unless specified otherwise
            $aHomeCountry = $myConfig->getConfigParam('aHomeCountry');
            if ($myConfig->getConfigParam('blCalculateDelCostIfNotLoggedIn') && is_array($aHomeCountry)) {
                $sDeliveryCountry = current($aHomeCountry);
            }
        } else {

            // ok, logged in
            if ($sCountryId = $myConfig->getGlobalParameter('delcountryid')) {
                $sDeliveryCountry = $sCountryId;
            } elseif ($sAddressId = oxRegistry::getSession()->getVariable('deladrid')) {

                $oDeliveryAddress = oxNew('oxAddress');
                if ($oDeliveryAddress->load($sAddressId)) {
                    $sDeliveryCountry = $oDeliveryAddress->oxaddress__oxcountryid->value;
                }
            }

            // still not found ?
            if (!$sDeliveryCountry) {
                $sDeliveryCountry = $oUser->oxuser__oxcountryid->value;
            }
        }

        return $sDeliveryCountry;
    }

    public function deleteBasket()
    {
        $this->_aBasketContents = array();
        $this->getSession()->delBasket();

        if ($this->getConfig()->getConfigParam('blPsBasketReservationEnabled')) {
            $this->getSession()->getBasketReservations()->discardReservations();
        }

        // merging basket history
        $this->_deleteSavedBasket();
    }

    public function setPayment($sPaymentId = null)
    {
        $this->_sPaymentId = $sPaymentId;
    }

    public function getPaymentId()
    {
        if (!$this->_sPaymentId) {
            $this->_sPaymentId = oxRegistry::getSession()->getVariable('paymentid');
        }

        return $this->_sPaymentId;
    }

    public function setShipping($sShippingSetId = null)
    {
        $this->_sShippingSetId = $sShippingSetId;
        oxRegistry::getSession()->setVariable('sShipSet', $sShippingSetId);
    }

    public function setDeliveryPrice($oShippingPrice = null)
    {
        $this->_oDeliveryPrice = $oShippingPrice;
    }

    public function getShippingId()
    {
        if (!$this->_sShippingSetId) {
            $this->_sShippingSetId = oxRegistry::getSession()->getVariable('sShipSet');
        }

        $sActPaymentId = $this->getPaymentId();
        // setting default if none is set
        if (!$this->_sShippingSetId && $sActPaymentId != 'oxempty') {
            $oUser = $this->getUser();

            // choosing first preferred delivery set
            list(, $sActShipSet) = oxRegistry::get("oxDeliverySetList")->getDeliverySetData(null, $oUser, $this);
            // in case nothing was found and no user set - choosing default
            $this->_sShippingSetId = $sActShipSet ? $sActShipSet : ($oUser ? null : 'oxidstandard');
        } elseif (!$this->isAdmin() && $sActPaymentId == 'oxempty') {
            // in case 'oxempty' is payment id - delivery set must be reset
            $this->_sShippingSetId = null;
        }

        return $this->_sShippingSetId;
    }

    public function getBasketArticles()
    {
        $aBasketArticles = array();

        foreach ($this->_aBasketContents as $sItemKey => $oBasketItem) {
            try {
                $oProduct = $oBasketItem->getArticle(true);

                if ($this->getConfig()->getConfigParam('bl_perfLoadSelectLists')) {
                    // marking chosen select list
                    $aSelList = $oBasketItem->getSelList();
                    if (is_array($aSelList) && ($aSelectlist = $oProduct->getSelectLists($sItemKey))) {
                        reset($aSelList);
                        while (list($conkey, $iSel) = each($aSelList)) {
                            $aSelectlist[$conkey][$iSel] = $aSelectlist[$conkey][$iSel];
                            $aSelectlist[$conkey][$iSel]->selected = 1;
                        }
                        $oProduct->setSelectlist($aSelectlist);
                    }
                }
            } catch (oxNoArticleException $oEx) {
                oxRegistry::get("oxUtilsView")->addErrorToDisplay($oEx);
                $this->removeItem($sItemKey);
                $this->calculateBasket(true);
                continue;
            } catch (oxArticleInputException $oEx) {
                oxRegistry::get("oxUtilsView")->addErrorToDisplay($oEx);
                $this->removeItem($sItemKey);
                $this->calculateBasket(true);
                continue;
            }

            $aBasketArticles[$sItemKey] = $oProduct;
        }

        return $aBasketArticles;
    }

    public function getDiscountProductsPrice()
    {
        return $this->_oDiscountProductsPriceList;
    }

    public function getProductsPrice()
    {
        if (is_null($this->_oProductsPriceList)) {
            $this->_oProductsPriceList = oxNew('oxPriceList');
        }

        return $this->_oProductsPriceList;
    }

    public function getPrice()
    {
        if (is_null($this->_oPrice)) {
            $this->setPrice(oxNew('oxPrice'));
        }

        return $this->_oPrice;
    }

    public function setPrice($oPrice)
    {
        $this->_oPrice = $oPrice;
    }


    public function getOrderId()
    {
        return $this->_sOrderId;
    }

    public function setOrderId($sId)
    {
        $this->_sOrderId = $sId;
    }

    public function getCosts($sId = null)
    {
        // if user want some specific cost - return it
        if ($sId) {
            return isset($this->_aCosts[$sId]) ? $this->_aCosts[$sId] : null;
        }

        return $this->_aCosts;
    }

    public function getVouchers()
    {
        return $this->_aVouchers;
    }

    public function getProductsCount()
    {
        return $this->_iProductsCnt;
    }

    public function getItemsCount()
    {
        return $this->_dItemsCnt;
    }

    public function getWeight()
    {
        return $this->_dWeight;
    }

    public function getContents()
    {
        return $this->_aBasketContents;
    }

    public function getProductVats($blFormatCurrency = true)
    {
        if (!$this->_oNotDiscountedProductsPriceList) {
            return array();
        }

        $aVats = $this->_oNotDiscountedProductsPriceList->getVatInfo($this->isCalculationModeNetto());

        $oUtils = oxRegistry::getUtils();
        foreach ($this->_aDiscountedVats as $sKey => $dVat) {
            if (!isset($aVats[$sKey])) {
                $aVats[$sKey] = 0;
            }
            // add prices of the same discounts
            $aVats[$sKey] += $oUtils->fRound($dVat, $this->_oCurrency);
        }

        if ($blFormatCurrency) {
            $oLang = oxRegistry::getLang();
            foreach ($aVats as $sKey => $dVat) {
                $aVats[$sKey] = $oLang->formatCurrency($dVat, $this->getBasketCurrency());
            }
        }

        return $aVats;
    }

    public function setCardMessage($sMessage)
    {
        $this->_sCardMessage = $sMessage;
    }

    public function getCardMessage()
    {
        return $this->_sCardMessage;
    }

    public function setCardId($sCardId)
    {
        $this->_sCardId = $sCardId;
    }

    public function getCardId()
    {
        return $this->_sCardId;
    }

    public function getCard()
    {
        $oCard = null;
        if ($sCardId = $this->getCardId()) {
            $oCard = oxNew('oxWrapping');
            $oCard->load($sCardId);
            $oCard->setWrappingVat($this->getAdditionalServicesVatPercent());
        }

        return $oCard;
    }

    public function getTotalDiscount()
    {
        return $this->_oTotalDiscount;
    }

    public function getDiscounts()
    {
        if ($this->getTotalDiscount() && $this->getTotalDiscount()->getBruttoPrice() == 0 && count($this->_aItemDiscounts) == 0) {
            return null;
        }

        return array_merge($this->_aItemDiscounts, $this->_aDiscounts);
    }

    public function getVoucherDiscount()
    {
        if ($this->getConfig()->getConfigParam('bl_showVouchers')) {
            return $this->_oVoucherDiscount;
        }

        return null;
    }

    public function setBasketCurrency($oCurrency)
    {
        $this->_oCurrency = $oCurrency;
    }

    public function getBasketCurrency()
    {
        if ($this->_oCurrency === null) {
            $this->_oCurrency = $this->getConfig()->getActShopCurrencyObject();
        }

        return $this->_oCurrency;
    }

    public function setSkipVouchersChecking($blSkipChecking = null)
    {
        $this->_blSkipVouchersAvailabilityChecking = $blSkipChecking;
    }

    public function hasSkipedDiscount()
    {
        return $this->_blSkipDiscounts;
    }

    public function setSkipDiscounts($blSkip)
    {
        $this->_blSkipDiscounts = $blSkip;
    }

    public function getProductsNetPrice()
    {
        return oxRegistry::getLang()->formatCurrency($this->getNettoSum(), $this->getBasketCurrency());
    }

    public function getFProductsPrice()
    {
        return oxRegistry::getLang()->formatCurrency($this->getBruttoSum(), $this->getBasketCurrency());
    }

    public function getDelCostVatPercent()
    {
        return $this->getCosts('oxdelivery')->getVat();
    }

    public function getDelCostVat()
    {
        $dDelVAT = $this->getCosts('oxdelivery')->getVatValue();

        // blShowVATForDelivery option will be used, only for displaying, but not calculation
        if ($dDelVAT > 0 && $this->getConfig()->getConfigParam('blShowVATForDelivery')) {
            return oxRegistry::getLang()->formatCurrency($dDelVAT, $this->getBasketCurrency());
        }

        return false;
    }

    public function getDelCostNet()
    {
        $oConfig = $this->getConfig();

        // blShowVATForDelivery option will be used, only for displaying, but not calculation
        if ($oConfig->getConfigParam('blShowVATForDelivery') && ($this->getBasketUser() || $oConfig->getConfigParam('blCalculateDelCostIfNotLoggedIn'))) {
            $dNetPrice = $this->getCosts('oxdelivery')->getNettoPrice();
            if ($dNetPrice > 0) {
                return oxRegistry::getLang()->formatCurrency($dNetPrice, $this->getBasketCurrency());
            }
        }

        return false;
    }

    public function getPayCostVatPercent()
    {
        return $this->getCosts('oxpayment')->getVat();
    }

    public function getPayCostVat()
    {
        $dPayVAT = $this->getCosts('oxpayment')->getVatValue();

        // blShowVATForPayCharge option will be used, only for displaying, but not calculation
        if ($dPayVAT > 0 && $this->getConfig()->getConfigParam('blShowVATForPayCharge')) {
            return oxRegistry::getLang()->formatCurrency($dPayVAT, $this->getBasketCurrency());
        }

        return false;
    }

    public function getPayCostNet()
    {
        // blShowVATForPayCharge option will be used, only for displaying, but not calculation
        if ($this->getConfig()->getConfigParam('blShowVATForPayCharge')) {
            $oPaymentCost = $this->getCosts('oxpayment');
            if ($oPaymentCost && $oPaymentCost->getNettoPrice()) {
                return oxRegistry::getLang()->formatCurrency($this->getCosts('oxpayment')->getNettoPrice(), $this->getBasketCurrency());
            }
        }

        return false;
    }

    public function getPaymentCosts()
    {
        $oPaymentCost = $this->getCosts('oxpayment');
        if ($oPaymentCost && $oPaymentCost->getBruttoPrice()) {
            return $oPaymentCost->getBruttoPrice();
        }
    }

    public function getPaymentCost()
    {
        return $this->getCosts('oxpayment');
    }

    public function getFPaymentCosts()
    {
        $oPaymentCost = $this->getCosts('oxpayment');
        if ($oPaymentCost && $oPaymentCost->getBruttoPrice()) {
            return oxRegistry::getLang()->formatCurrency($oPaymentCost->getBruttoPrice(), $this->getBasketCurrency());
        }

        return false;
    }

    public function getVoucherDiscValue()
    {
        if ($this->getVoucherDiscount()) {
            return $this->getVoucherDiscount()->getBruttoPrice();
        }

        return false;
    }

    public function getFVoucherDiscountValue()
    {
        if ($oVoucherDiscount = $this->getVoucherDiscount()) {
            if ($oVoucherDiscount->getBruttoPrice()) {
                return oxRegistry::getLang()->formatCurrency($oVoucherDiscount->getBruttoPrice(), $this->getBasketCurrency());
            }
        }

        return false;
    }


    public function getWrappCostVatPercent()
    {
        return $this->getCosts('oxwrapping')->getVat();
    }


    public function getGiftCardCostVatPercent()
    {
        return $this->getCosts('oxgiftcard')->getVat();
    }

    public function getWrappCostVat()
    {
        // blShowVATForWrapping option will be used, only for displaying, but not calculation
        if ($this->getConfig()->getConfigParam('blShowVATForWrapping')) {
            $oPrice = $this->getCosts('oxwrapping');

            if ($oPrice && $oPrice->getVatValue() > 0) {
                return oxRegistry::getLang()->formatCurrency($oPrice->getVatValue(), $this->getBasketCurrency());
            }
        }

        return false;
    }

    public function getWrappCostNet()
    {
        // blShowVATForWrapping option will be used, only for displaying, but not calculation
        if ($this->getConfig()->getConfigParam('blShowVATForWrapping')) {
            $oPrice = $this->getCosts('oxwrapping');

            if ($oPrice && $oPrice->getNettoPrice() > 0) {
                return oxRegistry::getLang()->formatCurrency($oPrice->getNettoPrice(), $this->getBasketCurrency());
            }
        }

        return false;
    }

    public function getFWrappingCosts()
    {
        $oPrice = $this->getCosts('oxwrapping');

        if ($oPrice && $oPrice->getBruttoPrice()) {
            return oxRegistry::getLang()->formatCurrency($oPrice->getBruttoPrice(), $this->getBasketCurrency());
        }

        return false;
    }

    public function getWrappingCost()
    {
        return $this->getCosts('oxwrapping');
    }

    public function getGiftCardCostVat()
    {
        // blShowVATForWrapping option will be used, only for displaying, but not calculation
        if ($this->getConfig()->getConfigParam('blShowVATForWrapping')) {
            $oPrice = $this->getCosts('oxgiftcard');

            if ($oPrice && $oPrice->getVatValue() > 0) {
                return oxRegistry::getLang()->formatCurrency($oPrice->getVatValue(), $this->getBasketCurrency());
            }
        }

        return false;

    }

    public function getGiftCardCostNet()
    {
        // blShowVATForWrapping option will be used, only for displaying, but not calculation
        if ($this->getConfig()->getConfigParam('blShowVATForWrapping')) {
            $oPrice = $this->getCosts('oxgiftcard');

            if ($oPrice && $oPrice->getNettoPrice() > 0) {
                return oxRegistry::getLang()->formatCurrency($oPrice->getNettoPrice(), $this->getBasketCurrency());
            }
        }

        return false;
    }

    public function getFGiftCardCosts()
    {
        $oPrice = $this->getCosts('oxgiftcard');

        if ($oPrice && $oPrice->getBruttoPrice()) {
            return oxRegistry::getLang()->formatCurrency($oPrice->getBruttoPrice(), $this->getBasketCurrency());
        }

        return false;
    }

    public function getGiftCardCost()
    {
        return $this->getCosts('oxgiftcard');
    }

    public function getFPrice()
    {
        return oxRegistry::getLang()->formatCurrency($this->getPrice()->getBruttoPrice(), $this->getBasketCurrency());
    }

    public function getFDeliveryCosts()
    {
        $oPrice = $this->getCosts('oxdelivery');

        if ($oPrice && ($this->getBasketUser() || $this->getConfig()->getConfigParam('blCalculateDelCostIfNotLoggedIn'))) {
            return oxRegistry::getLang()->formatCurrency($oPrice->getBruttoPrice(), $this->getBasketCurrency());
        }

        return false;
    }

    public function getDeliveryCosts()
    {
        if ($oDeliveryCost = $this->getCosts('oxdelivery')) {
            return $oDeliveryCost->getBruttoPrice();
        }

        return false;
    }

    public function getDeliveryCost()
    {
        return $this->getCosts('oxdelivery');
    }

    public function setTotalDiscount($dDiscount)
    {
        $this->_oTotalDiscount = oxNew('oxPrice');
        $this->_oTotalDiscount->setBruttoPriceMode();
        $this->_oTotalDiscount->add($dDiscount);
    }

    public function getPriceForPayment()
    {
        $dPrice = $this->getDiscountedProductsBruttoPrice();
        //#1905 not discounted products should be included in payment amount calculation
        if ($oPriceList = $this->getNotDiscountProductsPrice()) {
            $dPrice += $oPriceList->getBruttoSum();
        }

        // adding delivery price to final price
        if ($oDeliveryPrice = $this->_aCosts['oxdelivery']) {
            $dPrice += $oDeliveryPrice->getBruttoPrice();
        }

        return $dPrice;
    }


    public function _getDiscountedProductsSum()
    {
        if ($oProductsPrice = $this->getDiscountProductsPrice()) {
            $dPrice = $oProductsPrice->getSum($this->isCalculationModeNetto());
        }

        // subtracting total discount
        if ($oPrice = $this->getTotalDiscount()) {
            $dPrice -= $oPrice->getPrice();
        }

        if ($oVoucherPrice = $this->getVoucherDiscount()) {
            $dPrice -= $oVoucherPrice->getPrice();
        }

        return $dPrice;
    }

    public function getTotalDiscountSum()
    {
        $dPrice = 0;
        // subtracting total discount
        if ($oPrice = $this->getTotalDiscount()) {
            $dPrice += $oPrice->getPrice();
        }

        if ($oVoucherPrice = $this->getVoucherDiscount()) {
            $dPrice += $oVoucherPrice->getPrice();
        }

        return $dPrice;
    }

    public function getDiscountedProductsBruttoPrice()
    {
        if ($oProductsPrice = $this->getDiscountProductsPrice()) {
            $dPrice = $oProductsPrice->getBruttoSum();
        }

        // subtracting total discount
        if ($oPrice = $this->getTotalDiscount()) {
            $dPrice -= $oPrice->getBruttoPrice();
        }

        if ($oVoucherPrice = $this->getVoucherDiscount()) {
            $dPrice -= $oVoucherPrice->getBruttoPrice();
        }

        return $dPrice;
    }

    public function isBelowMinOrderPrice()
    {
        $blIsBelowMinOrderPrice = false;
        $sConfValue = $this->getConfig()->getConfigParam('iMinOrderPrice');
        if (is_numeric($sConfValue) && $this->getProductsCount()) {
            $dMinOrderPrice = oxPrice::getPriceInActCurrency(( double ) $sConfValue);
            $dNotDiscountedProductPrice = 0;
            if ($oPrice = $this->getNotDiscountProductsPrice()) {
                $dNotDiscountedProductPrice = $oPrice->getBruttoSum();
            }
            $blIsBelowMinOrderPrice = ($dMinOrderPrice > ($this->getDiscountedProductsBruttoPrice() + $dNotDiscountedProductPrice));
        }

        return $blIsBelowMinOrderPrice;

    }

    public function getArtStockInBasket($sArtId, $sExpiredArtId = null)
    {
        $dArtStock = 0;
        foreach ($this->_aBasketContents as $sItemKey => $oOrderArticle) {
            if ($oOrderArticle && ($sExpiredArtId == null || $sExpiredArtId != $sItemKey)) {
                if ($oOrderArticle->getArticle(true)->getId() == $sArtId) {
                    $dArtStock += $oOrderArticle->getAmount();
                }
            }
        }

        return $dArtStock;
    }

    public function canAddProductToBasket($sProductId)
    {
        $blCanAdd = null;

        // if basket category is not set..
        if ($this->_sBasketCategoryId === null) {
            $oCat = null;

            // request category
            if ($oView = $this->getConfig()->getActiveView()) {
                if ($oCat = $oView->getActiveCategory()) {
                    if (!$this->_isProductInRootCategory($sProductId, $oCat->oxcategories__oxrootid->value)) {
                        $oCat = null;
                    } else {
                        $blCanAdd = true;
                    }
                }
            }

            // product main category
            if (!$oCat) {
                $oProduct = oxNew("oxArticle");
                if ($oProduct->load($sProductId)) {
                    $oCat = $oProduct->getCategory();
                }
            }

            // root category id
            if ($oCat) {
                $this->setBasketRootCatId($oCat->oxcategories__oxrootid->value);
            }
        }

        // avoiding double check..
        if ($blCanAdd === null) {
            $blCanAdd = $this->_sBasketCategoryId ? $this->_isProductInRootCategory($sProductId, $this->getBasketRootCatId()) : true;
        }

        return $blCanAdd;
    }

    protected function _isProductInRootCategory($sProductId, $sRootCatId)
    {
        $sO2CTable = getViewName('oxobject2category');
        $sCatTable = getViewName('oxcategories');

        $oDb = oxDb::getDb();
        $sParentId = $oDb->getOne("select oxparentid from oxarticles where oxid = " . $oDb->quote($sProductId));
        $sProductId = $sParentId ? $sParentId : $sProductId;

        $sQ = "select 1 from {$sO2CTable}
                 left join {$sCatTable} on {$sCatTable}.oxid = {$sO2CTable}.oxcatnid
                 where {$sO2CTable}.oxobjectid = " . $oDb->quote($sProductId) . " and
                       {$sCatTable}.oxrootid = " . $oDb->quote($sRootCatId);

        return (bool) $oDb->getOne($sQ);
    }

    public function setBasketRootCatId($sRoot)
    {
        $this->_sBasketCategoryId = $sRoot;
    }

    public function getBasketRootCatId()
    {
        return $this->_sBasketCategoryId;
    }

    public function setCatChangeWarningState($blShow)
    {
        $this->_blShowCatChangeWarning = $blShow;
    }

    public function showCatChangeWarning()
    {
        return $this->_blShowCatChangeWarning;
    }

    public function setTsProductId($sProductId)
    {
        $this->_sTsProductId = $sProductId;
    }

    public function getTsProductId()
    {
        return $this->_sTsProductId;
    }

    public function getFTsProtectionCosts()
    {
        $oProtectionCost = $this->getCosts('oxtsprotection');
        if ($oProtectionCost && $oProtectionCost->getBruttoPrice()) {
            return oxRegistry::getLang()->formatCurrency($oProtectionCost->getBruttoPrice(), $this->getBasketCurrency());
        }

        return false;
    }

    public function getTsProtectionVatPercent()
    {
        return $this->getCosts('oxtsprotection')->getVat();
    }

    public function getTsProtectionVat()
    {
        $dProtectionVAT = $this->getCosts('oxtsprotection')->getVatValue();
        // blShowVATForPayCharge option will be used, only for displaying, but not calculation
        if ($dProtectionVAT > 0 && $this->getConfig()->getConfigParam('blShowVATForPayCharge')) {
            return oxRegistry::getLang()->formatCurrency($dProtectionVAT, $this->getBasketCurrency());
        }

        return false;
    }

    public function getTsProtectionNet()
    {
        // blShowVATForPayCharge option will be used, only for displaying, but not calculation
        if ($this->getConfig()->getConfigParam('blShowVATForPayCharge')) {
            return oxRegistry::getLang()->formatCurrency($this->getCosts('oxtsprotection')->getNettoPrice(), $this->getBasketCurrency());
        }

        return false;
    }

    public function getTsProtectionCosts()
    {
        $oProtection = $this->getCosts('oxtsprotection');
        if ($oProtection) {
            return $oProtection->getBruttoPrice();
        }

        return false;
    }

    public function getTrustedShopProtectionCost()
    {
        return $this->getCosts('oxtsprotection');
    }


    public function getNotDiscountProductsPrice()
    {
        return $this->_oNotDiscountedProductsPriceList;
    }

    protected function _addedNewItem($sProductID, $dAmount, $aSel, $aPersParam, $blOverride, $blBundle, $sOldBasketItemId)
    {
        if (!$blOverride) {
            $this->_blNewITemAdded = null;
            oxRegistry::getSession()->setVariable("blAddedNewItem", true);
        }
    }

    public function __wakeUp()
    {
        $this->_blNewITemAdded = null;
        $this->_isCalculationModeNetto = null;
    }

    public function isNewItemAdded()
    {
        if ($this->_blNewITemAdded == null) {
            $this->_blNewITemAdded = (bool) oxRegistry::getSession()->getVariable("blAddedNewItem");
            oxRegistry::getSession()->deleteVariable("blAddedNewItem");
        }

        return $this->_blNewITemAdded;
    }

    public function hasDownloadableProducts()
    {
        $this->_blDownloadableProducts = false;
        foreach ($this->_aBasketContents as $oBasketItem) {
            if ($oBasketItem->getArticle(false) && $oBasketItem->getArticle(false)->isDownloadable()) {
                $this->_blDownloadableProducts = true;
                break;
            }
        }

        return $this->_blDownloadableProducts;
    }

    public function hasArticlesWithIntangibleAgreement()
    {
        $blHasArticlesWithIntangibleAgreement = false;

        foreach ($this->_aBasketContents as $oBasketItem) {
            if ($oBasketItem->getArticle(false) && $oBasketItem->getArticle(false)->hasIntangibleAgreement()) {
                $blHasArticlesWithIntangibleAgreement = true;
                break;
            }
        }

        return $blHasArticlesWithIntangibleAgreement;
    }

    public function hasArticlesWithDownloadableAgreement()
    {
        $blHasArticlesWithIntangibleAgreement = false;

        foreach ($this->_aBasketContents as $oBasketItem) {
            if ($oBasketItem->getArticle(false) && $oBasketItem->getArticle(false)->hasDownloadableAgreement()) {
                $blHasArticlesWithIntangibleAgreement = true;
                break;
            }
        }

        return $blHasArticlesWithIntangibleAgreement;
    }

    public function getMinOrderPrice()
    {
        return oxPrice::getPriceInActCurrency($this->getConfig()->getConfigParam('iMinOrderPrice'));
    }

    public function getTsInsuredSum()
    {
        return $this->getPrice()->getBruttoPrice() - $this->getCosts('oxtsprotection')->getBruttoPrice();
    }
}