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 $_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 $_blBasketMerged = false;

    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;

    public function isEnabled()
    {
        return !oxUtils::getInstance()->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;

        // initialting 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();

        // updating basket history
        if ( !$blBundle ) {
            $this->_addItemToSavedBasket( $sProductID, $dAmount, $aSel, $blOverride );
        }

        if ( $oEx ) {
            throw $oEx;
        }
        return $this->_aBasketContents[$sItemId];
    }

    public function addOrderArticleToBasket( $oOrderArticle )
    {
        // adding only if amount > 0
        if ( $oOrderArticle->oxorderarticles__oxamount->value > 0 ) {
            $sItemId = $oOrderArticle->getId();

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

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

            return $this->_aBasketContents[$sItemId];
        }
    }

    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();
        if ( $oArticle && $oArticle->oxarticles__oxbundleid->value ) {
            $aBundles[$oArticle->oxarticles__oxbundleid->value] = 1;
        }

        return $aBundles;
    }

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

        $aBundles = array();

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

            foreach ( $aDiscounts as $oDiscount ) {

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

                $aBundles[$oDiscount->oxdiscount__oxitmartid->value] += $oDiscount->getBundleAmount( $oBasketItem->getAmount() );

            }
        }

        return $aBundles;
    }

    protected function _getBasketBundles()
    {
        $aBundles = array();
        $aDiscounts = oxDiscountList::getInstance()->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()
    {
        // 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 );
                } else {
                    continue;
                }

                $this->_addBundlesToBasket( $aBundles );

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

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

        // adding global basket bundles
        if ( $aBundles = $this->_getBasketBundles() ) {
            $this->_addBundlesToBasket( $aBundles );
        }

    }

    protected function _addBundlesToBasket( $aBundles )
    {
        foreach ( $aBundles as $sBundleId => $dAmount ) {
            try {
                if ( $oBundleItem = $this->addToBasket( $sBundleId, $dAmount, null, null, true, 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

        // resetting
        $this->_aItemDiscounts = array();

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

        $oDiscountList = oxDiscountList::getInstance();

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

            if ( !$oBasketItem->isDiscountArticle() && ( $oArticle = $oBasketItem->getArticle() ) ) {
                $oBasketPrice = $oArticle->getBasketPrice( $oBasketItem->getAmount(), $oBasketItem->getSelList(), $this );
                $oBasketItem->setPrice( $oBasketPrice );
                //P adding product price
                $this->_oProductsPriceList->addToPriceList( $oBasketItem->getPrice() );

                $oBasketPrice->setBruttoPriceMode();
                if ( !$oArticle->skipDiscounts() && $this->canCalcDiscounts() ) {
                    // apply basket type discounts
                    $aItemDiscounts = $oDiscountList->applyBasketDiscounts( $oBasketPrice, $oDiscountList->getBasketItemDiscounts( $oArticle, $this, $this->getBasketUser() ), $oBasketItem->getAmount() );
                    if ( is_array($this->_aItemDiscounts) && is_array($aItemDiscounts) ) {
                        $this->_aItemDiscounts = $this->_mergeDiscounts( $this->_aItemDiscounts, $aItemDiscounts);
                    }
                } else {
                    $oBasketItem->setSkipDiscounts( true );
                    $this->setSkipDiscounts( true );
                }
                $oBasketPrice->multiply( $oBasketItem->getAmount() );

                //P collect discount values for basket items which are discountable
                if ( !$oArticle->skipDiscounts() ) {
                    $this->_oDiscountProductsPriceList->addToPriceList( $oBasketPrice );
                } else {
                    $this->_oNotDiscountedProductsPriceList->addToPriceList( $oBasketPrice );
                    $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' );
        $oDeliveryPrice->setBruttoPriceMode();

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

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

        // VAT for delivery ?
        $fDelVATPercent = 0;
        if ( $myConfig->getConfigParam( 'blCalcVATForDelivery' ) ) {
            $fDelVATPercent = $this->getMostUsedVatPercent();
            $oDeliveryPrice->setVat( $fDelVATPercent );
        }

        // list of active delivery costs
        if ( $myConfig->getConfigParam('bl_perfLoadDelivery') ) {
            $aDeliveryList = oxDeliveryList::getInstance()->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()
    {
        return $this->_oProductsPriceList->getMostUsedVatPercent();
    }

    //P
    protected function _calcTotalPrice()
    {
        // 1. add products price
        $dprice = $this->_oProductsPriceList->getBruttoSum();
        $this->_oPrice->setPrice( $dprice );

        // 2. substract discounts
        if ( $dprice ) {

            // 2.1 applying basket item discounts
            foreach ( $this->_aItemDiscounts as $oDiscount ) {

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

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

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

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

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

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

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

    }

    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 = oxNew( 'oxPrice' );
            $this->_oVoucherDiscount->setBruttoPriceMode();


            // calculating price to apply discount
            $dPrice = $this->_oDiscountProductsPriceList->getBruttoSum() - $this->_oTotalDiscount->getBruttoPrice();

            // recalculating
            if ( count( $this->_aVouchers ) ) {
                $oLang = oxLang::getInstance();
                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 );

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

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

                        // substracting voucher discount
                        $dPrice -= $dVoucherdiscount;
                    } catch ( oxVoucherException $oEx ) {

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

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

    //V
    protected function _applyDiscounts()
    {
        $dBruttoPrice = 0;
        $this->_aDiscountedVats = array();
        if ( $oPriceList = $this->getDiscountProductsPrice() ) {
            $dBruttoPrice = $oPriceList->getBruttoSum();
            $this->_aDiscountedVats = $oPriceList->getVatInfo();
        }

        //apply discounts for brutto price
        $dDiscountedBruttoPrice = $this->getDiscountedProductsBruttoPrice();
        $oTotalDiscount   = $this->getTotalDiscount();
        $oVoucherDiscount = $this->getVoucherDiscount();

        //apply discount for VATs
        if ( $dBruttoPrice &&
             ( ( $oTotalDiscount && $oTotalDiscount->getBruttoPrice() ) ||
               ( $oVoucherDiscount && $oVoucherDiscount->getBruttoPrice() )
             )
           ) {
            $dPercent = ( $dDiscountedBruttoPrice / $dBruttoPrice) * 100;
            foreach ( $this->_aDiscountedVats as $sKey => $dVat ) {
                $this->_aDiscountedVats[$sKey] = oxPrice::percent( $dVat, $dPercent);
            }
        }

        $oUtils = oxUtils::getInstance();
        $dDiscVatSum = 0;
        foreach ( $this->_aDiscountedVats as $dVat ) {
            $dDiscVatSum += $oUtils->fRound( -$dVat, $this->_oCurrency);
        }
        //calculate netto price with discounts
        $this->_dDiscountedProductNettoPrice = $dDiscountedBruttoPrice + $dDiscVatSum;
    }

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

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

        // add basket discounts
        $aDiscounts = oxDiscountList::getInstance()->getBasketDiscounts( $this, $this->getBasketUser() );

        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 );
            if ($dOldprice < $oStdDiscount->dDiscount) {
                $oStdDiscount->dDiscount = $dOldprice;
            }

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

    protected function _calcBasketTotalDiscount()
    {
        if ( $this->_oTotalDiscount === null || ( $this->_blUpdateNeeded && !$this->isAdmin() ) ) {
            $this->_oTotalDiscount = oxNew( 'oxPrice' );
            $this->_oTotalDiscount->setBruttoPriceMode();

            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()
    {
        $myConfig = $this->getConfig();
        $oWrappingPrice = oxNew( 'oxPrice' );
        $oWrappingPrice->setBruttoPriceMode();

        // wrapping VAT
        if ( $myConfig->getConfigParam( 'blCalcVatForWrapping' ) ) {
            $oWrappingPrice->setVat( $this->getMostUsedVatPercent() );
        }

        // calculating basket items wrapping
        foreach ( $this->_aBasketContents as $oBasketItem ) {

            if ( ( $oWrapping = $oBasketItem->getWrapping() ) ) {
                $oWrapPrice = $oWrapping->getWrappingPrice( $oBasketItem->getAmount() );
                $oWrappingPrice->add( $oWrapPrice->getBruttoPrice() );
            }
        }

        // gift card price calculation
        if ( ( $oCard = $this->getCard() ) ) {
            $oCardPrice = $oCard->getWrappingPrice();
            $oWrappingPrice->add( $oCardPrice->getBruttoPrice() );
        }

        return $oWrappingPrice;
    }

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

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

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

            $oPaymentPrice = $oPayment->getPaymentPrice( $this );
        }

        return $oPaymentPrice;
    }

    protected function _calcTsProtectionCost()
    {
        // resetting values
        $oProtectionPrice = oxNew( 'oxPrice' );
        $oProtectionPrice->setBruttoPriceMode();

        // payment
        if ( ( $this->_sTsProductId = $this->getTsProductId() ) ) {

            $oTsProtection = oxNew('oxtsprotection');
            $oTsProduct = $oTsProtection->getTsProduct( $this->_sTsProductId );

            $oProtectionPrice = $oTsProduct->oPrice;
        }
        return $oProtectionPrice;
    }

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

    public function calculateBasket( $blForceUpdate = false )
    {
        if ( !$this->isEnabled() ) {
            return;
        }

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

        $this->_aCosts = array();

        $this->_oPrice = oxNew( 'oxprice' );
        $this->_oPrice->setBruttoPriceMode();

        //  1. merging basket history
        $this->_mergeSavedBasket();

        //  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 costs
        $this->setCost( 'oxwrapping', $this->_calcBasketWrapping() );

        //  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. setting deprecated values
        $this->_setDeprecatedValues();

        //  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 Oxstdclass();
            $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->getPrice( $oBasketItem->getAmount() ) ) ) {
                    $dPrice = $oPrice->getBruttoPrice();
                    if ( !$oArticle->skipDiscounts() ) {
                        $dDiscountablePrice = $dPrice;
                    }
                }

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

                    $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->getProductParentId()) && $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->getBruttoSum();
        }

        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
            oxUtilsView::getInstance()->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();

            // unsetting 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 _setDeprecatedValues()
    {
        $this->dproductsprice    = $this->_oProductsPriceList->getBruttoSum(); // products brutto price
        $this->dproductsnetprice = $this->getDiscountedNettoPrice();  // products netto price();

        //P sum vat values
        $this->dVAT = array_sum( $this->_oProductsPriceList->getVatInfo() );
        $oLang = oxLang::getInstance();

        // formatting final values
        $this->fproductsprice    = $this->getFProductsPrice();
        $this->fproductsnetprice = $this->getProductsNetPrice();
        $this->fVAT = $oLang->formatCurrency( $this->dVAT, $this->getBasketCurrency());

        // delivery costs
        if ( $oDeliveryCost = $this->getCosts( 'oxdelivery' ) ) {

            $this->ddeliverycost    = $oDeliveryCost->getBruttoPrice();
            $this->ddeliverynetcost = $oDeliveryCost->getNettoPrice();
            $this->dDelVAT          = $oDeliveryCost->getVatValue();
            $this->fDelVATPercent   = $oDeliveryCost->getVat() / 100; // needed to divide, because in template value is multyplied by 100

            // formating values
            $this->fdeliverycost    = $oLang->formatCurrency( $this->ddeliverycost, $this->getBasketCurrency() );
            $this->fdeliverynetcost = $oLang->formatCurrency( $this->ddeliverynetcost, $this->getBasketCurrency() );
            $this->fDelVAT          = $this->getDelCostVat();
        }

        //P
        // wrapping costs
        if ( $oWrappingCost = $this->getCosts( 'oxwrapping' ) ) {

            $this->dWrappingPrice = $oWrappingCost->getBruttoPrice();
            $this->dWrappingNetto = $oWrappingCost->getNettoPrice();
            $this->dWrappingVAT   = $oWrappingCost->getVatValue();

            //formating values
            $this->fWrappingPrice      = $oLang->formatCurrency( $this->dWrappingPrice, $this->getBasketCurrency() );
            $this->fWrappingNetto      = $this->getWrappCostNet();
            $this->fWrappingVAT        = $this->getWrappCostVat();
            $this->fWrappingVATPercent = $this->getWrappCostVatPercent();
        }

        //P
        // payment costs
        if ( $oPaymentCost = $this->getCosts( 'oxpayment' ) ) {

            $this->dAddPaymentSum    = $this->getPaymentCosts();
            $this->dAddPaymentSumVAT = $oPaymentCost->getVatValue();

            //formating values
            $this->fAddPaymentSum    = $oLang->formatCurrency( $this->dAddPaymentSum, $this->getBasketCurrency() );
            $this->fAddPaymentSumVAT = $this->getPayCostVat();
            $this->fAddPaymentSumVATPercent = $this->getPayCostVatPercent();
            $this->fAddPaymentNetSum = $this->getPayCostNet();
        }

        //P
        // basket total prices
        $this->dprice = $this->_oPrice->getBruttoPrice();
        $this->fprice = $oLang->formatCurrency( $this->dprice, $this->getBasketCurrency() );

        // product info
        $this->iCntProducts = $this->getProductsCount();
        $this->dCntItems    = $this->getItemsCount();
        $this->aVATs        = $this->getProductVats();
        $this->aBasketContents = $this->getContents();

        // setting gift card information
        $this->giftmessage = $this->getCardMessage();
        $this->chosencard  = $this->getCardId();

        $this->oCard = $this->getCard();

        // discount information
        // formating discount value
        $this->aDiscounts = $this->getDiscounts();
        if ( count($this->aDiscounts) > 0 ) {
            foreach ($this->aDiscounts as $oDiscount) {
                $oDiscount->fDiscount = $oLang->formatCurrency( $oDiscount->dDiscount, $this->getBasketCurrency() );
            }
        }
        $this->dDiscount  = $this->getTotalDiscount()->getBruttoPrice();

        // voucher info
        $this->aVouchers = $this->getVouchers();
        $this->dVoucherDiscount = $this->getVoucherDiscValue();
        $this->fVoucherDiscount = $oLang->formatCurrency( $this->dVoucherDiscount, $this->getBasketCurrency() );
        $this->dSkippedDiscount = $this->hasSkipedDiscount();

    }


    protected function _canMergeBasket()
    {
        $blCan = true;
        if ( $this->getConfig()->getConfigParam( 'blPerfNoBasketSaving' ) ||
             $this->_blBasketMerged || $this->isAdmin() ) {
            $blCan = false;
        }
        return $blCan;
    }

    protected function _mergeSavedBasket()
    {
        if ( $this->_canMergeBasket() ) {

            $oUser = $this->getBasketUser();
            if ( !$oUser ) {
                $this->_blBasketMerged = false;
                return;
            }

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

            // restoring from saved history
            $aSavedItems = $oBasket->getItems();
            foreach ( $aSavedItems as $oItem ) {
                try {
                    $this->addToBasket( $oItem->oxuserbasketitems__oxartid->value, $oItem->oxuserbasketitems__oxamount->value, $oItem->getSelList(), null, true );
                } catch( oxArticleException $oEx ) {
                    // caught and ignored
                }
            }

            // refreshing history
            foreach ( $this->_aBasketContents as $oBasketItem ) {
                $oBasket->addItemToBasket( $oBasketItem->getProductId(), $oBasketItem->getAmount(), $oBasketItem->getSelList(), true );
            }

            // marking basked as saved
            $this->_blBasketMerged = true;
        }
    }

    protected function _addItemToSavedBasket( $sProductId , $dAmount, $aSel, $blOverride = false )
    {
        // updating basket history
        if ( $oUser = $this->getBasketUser() ) {
            $oUser->getBasket( 'savedbasket' )->addItemToBasket( $sProductId, $dAmount, $aSel, $blOverride );
        }
    }

    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();

        $sDelivCountry = null;

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

            // ok, logged in
            if ( $sCountryId = $myConfig->getGlobalParameter( 'delcountryid' ) ) {
                $sDelivCountry = $sCountryId;
            } elseif ( $sAddressId = oxConfig::getParameter( 'deladrid' ) ) {

                $oDelAdress = oxNew( 'oxaddress' );
                if ( $oDelAdress->load( $sAddressId ) ) {
                    $sDelivCountry = $oDelAdress->oxaddress__oxcountryid->value;
                }
            }

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

        return $sDelivCountry;
    }

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

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

        // merging basket history
        if ( !$this->getConfig()->getConfigParam( 'blPerfNoBasketSaving' ) ) {
            $this->_deleteSavedBasket();
        }
    }

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

    public function getPaymentId()
    {
        if ( !$this->_sPaymentId ) {
             $this->_sPaymentId = oxConfig::getParameter( 'paymentid' );
        }
        return $this->_sPaymentId;
    }

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

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

    public function getShippingId()
    {
        if ( !$this->_sShippingSetId ) {
             $this->_sShippingSetId = oxConfig::getParameter( '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 ) = oxDeliverySetList::getInstance()->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();

                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]->selected = 1;
                        }
                        $oProduct->setSelectlist( $aSelectlist );
                    }
                }
            } catch ( oxNoArticleException $oEx ) {
                oxUtilsView::getInstance()->addErrorToDisplay( $oEx );
                $this->removeItem( $sItemKey );
                $this->calculateBasket( true );
                continue;
            } catch ( oxArticleInputException $oEx ) {
                oxUtilsView::getInstance()->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->_oPrice = oxNew( 'oxprice' );
        }

        return $this->_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();

        $oUtils = oxUtils::getInstance();
        foreach ( $this->_aDiscountedVats as $sKey => $dVat ) {
            // add prices of the same discounts
            $aVats[$sKey] += $oUtils->fRound( $dVat, $this->_oCurrency);
        }

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

        return $aVats;
    }

    public function getDiscountedNettoPrice()
    {
        if ( $this->_oNotDiscountedProductsPriceList ) {
            return $this->_dDiscountedProductNettoPrice + $this->_oNotDiscountedProductsPriceList->getNettoSum();
        }
        return false;
    }

    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 );
        }
        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 oxLang::getInstance()->formatCurrency( $this->getDiscountedNettoPrice(), $this->getBasketCurrency() );
    }

    public function getFProductsPrice()
    {
        if ( $this->_oProductsPriceList ) {
            return oxLang::getInstance()->formatCurrency( $this->_oProductsPriceList->getBruttoSum(), $this->getBasketCurrency() );
        }
        return null;
    }

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

    public function getDelCostVat()
    {
        $dDelVAT = $this->getCosts( 'oxdelivery' )->getVatValue();
        if ( $dDelVAT > 0 ) {
            return oxLang::getInstance()->formatCurrency( $dDelVAT, $this->getBasketCurrency() );
        }
        return false;
    }

    public function getDelCostNet()
    {
        if ( $this->getBasketUser() || $this->getConfig()->getConfigParam( 'blCalculateDelCostIfNotLoggedIn' ) ) {
            return oxLang::getInstance()->formatCurrency( $this->getCosts( 'oxdelivery' )->getNettoPrice(), $this->getBasketCurrency() );
        }
        return false;
    }

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

    public function getPayCostVat()
    {
        $dPayVAT = $this->getCosts( 'oxpayment' )->getVatValue();
        if ( $dPayVAT > 0 ) {
            return oxLang::getInstance()->formatCurrency( $dPayVAT, $this->getBasketCurrency() );
        }
        return false;
    }

    public function getPayCostNet()
    {
        return oxLang::getInstance()->formatCurrency( $this->getCosts( 'oxpayment' )->getNettoPrice(), $this->getBasketCurrency() );
    }

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

    public function getFPaymentCosts()
    {
        $oPaymentCost = $this->getCosts( 'oxpayment' );

        if ( $oPaymentCost && $oPaymentCost->getBruttoPrice() ) {
            return oxLang::getInstance()->formatCurrency( $oPaymentCost->getBruttoPrice(), $this->getBasketCurrency() );
        }
        return false;
    }

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

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

    public function getWrappCostVat()
    {
        $dWrappVAT = $this->getCosts( 'oxwrapping' )->getVatValue();
        if ( $dWrappVAT > 0 ) {
            return oxLang::getInstance()->formatCurrency( $dWrappVAT, $this->getBasketCurrency() );
        }
        return false;

    }

    public function getWrappCostNet()
    {
        $dWrappNet = $this->getCosts( 'oxwrapping' )->getNettoPrice();
        if ( $dWrappNet > 0 ) {
            return  oxLang::getInstance()->formatCurrency( $dWrappNet, $this->getBasketCurrency() );
        }
        return false;
    }

    public function getFWrappingCosts()
    {
        $oWrappingCost = $this->getCosts( 'oxwrapping' );
        if ( $oWrappingCost && $oWrappingCost->getBruttoPrice() ) {
            return oxLang::getInstance()->formatCurrency( $oWrappingCost->getBruttoPrice(), $this->getBasketCurrency() );
        }
        return false;
    }

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

    public function getFDeliveryCosts()
    {
        $oDeliveryCost = $this->getCosts( 'oxdelivery' );
        if ( $oDeliveryCost && $oDeliveryCost->getBruttoPrice()) {
            return oxLang::getInstance()->formatCurrency( $oDeliveryCost->getBruttoPrice(), $this->getBasketCurrency() );
        }
        return false;
    }

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

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

    public function getPriceForPayment()
    {
        $dPrice = $this->getDiscountedProductsBruttoPrice();

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

        return $dPrice;
    }

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

        // substracting 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( ( int ) $sConfValue );
            $blIsBelowMinOrderPrice = ($dMinOrderPrice > $this->getDiscountedProductsBruttoPrice());
        }

        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()->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->getActCategory() ) {
                    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 oxLang::getInstance()->formatCurrency( $oProtectionCost->getBruttoPrice(), $this->getBasketCurrency() );
        }
        return false;
    }

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

    public function getTsProtectionVat()
    {
        $dProtectionVAT = $this->getCosts( 'oxtsprotection' )->getVatValue();
        if ( $dProtectionVAT > 0 ) {
            return oxLang::getInstance()->formatCurrency( $dProtectionVAT, $this->getBasketCurrency() );
        }
        return false;
    }

    public function getTsProtectionNet()
    {
        return oxLang::getInstance()->formatCurrency( $this->getCosts( 'oxtsprotection' )->getNettoPrice(), $this->getBasketCurrency() );
    }

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

}