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;

    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;

        //validate amount
        //possibly throws exception
        $sItemId = $this->getItemKey( $sProductID, $aSel, $aPersParam, $blBundle );
        if ($sOldBasketItemId && strcmp($sOldBasketItemId, $sItemId)) {
            if (isset( $this->_aBasketContents[$sItemId] )) {
                // we are merging, so params will just go to the new key
                unset( $this->_aBasketContents[$sOldBasketItemId] );
            } 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 {
                $this->_aBasketContents[$sItemId]->setAmount( $dAmount, $blOverride );
            } catch( oxOutOfStockException $oEx ) {
                // rethrow later
            }

        } else {
            //inserting new
            $oBasketItem = oxNew( 'oxbasketitem' );
            try {
                $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
            }

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

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

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

            // updating basket history
            if ( !$blBundle && !$blRemoveItem ) {
                $this->_addItemToSavedBasket( $this->_aBasketContents[$sItemId]->getProductId(), $dAmount, $aSel, $blOverride );
            }

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



    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 )
    {
        unset( $this->_aBasketContents[$sItemKey] );
    }

    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 ) {

            // 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 );
        }

        // 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' );

        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() ) {
                    // apply basket type discounts
                    $aItemDiscounts = $oArticle->applyBasketDiscounts( $oBasketPrice, oxDiscountList::getInstance()->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 );
            }
        }
    }

    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(),
                                        oxConfig::getParameter( 'sShipSet' )
                                    );

            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
            $this->_oPrice->subtract( $this->_oVoucherDiscount->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() );
        }

    }

    protected function _calcVoucherDiscount()
    {
        $this->_oVoucherDiscount = oxNew( 'oxPrice' );
        $this->_oVoucherDiscount->setBruttoPriceMode();


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

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

        //apply discounts for brutto price
        $dDiscountedBruttoPrice = $dBruttoPrice - $this->_oTotalDiscount->getBruttoPrice() - $this->_oVoucherDiscount->getBruttoPrice();

        //apply discount for VATs
        if ( $dBruttoPrice && ( $this->_oTotalDiscount->getBruttoPrice() || $this->_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 );

            $this->_aDiscounts[$oDiscount->getId()] = $oStdDiscount;

            // substracting product price after discount
            $dOldprice = $dOldprice - $oStdDiscount->dDiscount;
        }
    }

    protected function _calcBasketTotalDiscount()
    {
        $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;
    }

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

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

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

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

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

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

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

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

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

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

        //  7.2: adding wrapping costs
        $this->setCost( 'oxwrapping', $this->_calcBasketWrapping() );

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

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

        //  9. setting deprecated values
        $this->_setDeprecatedValues();

        //  10.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;
        }

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

        $myConfig = $this->getConfig();
        foreach ( $this->_aBasketContents as $oBasketItem ) {
            if ( !$oBasketItem->isBundle() ) {
                if ( ( $oArticle = $oBasketItem->getArticle() ) ) {

                    $aCatIds = $oArticle->getCategoryIds();
                    $dPrice  = $oArticle->getPrice()->getBruttoPrice();

                    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]->dAmount += $oBasketItem->getAmount();
                        $this->_aBasketSummary->aCategories[$sCatId]->iCount++;
                    }

                    // variant handling
                    if ( $oArticle->oxarticles__oxparentid->value && $myConfig->getConfigParam( 'blVariantParentBuyable' ) ) {
                        if ( !isset( $this->_aBasketSummary->aArticles[$oArticle->oxarticles__oxparentid->value] ) ) {
                            $this->_aBasketSummary->aArticles[$oArticle->oxarticles__oxparentid->value] = 0;
                        }
                        $this->_aBasketSummary->aArticles[$oArticle->oxarticles__oxparentid->value] += $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();
                }
            }
        }
        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()
    {
        // remove this
        $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() );

        // formatting final values
        $this->fproductsprice    = $this->getFProductsPrice();
        $this->fproductsnetprice = $this->getProductsNetPrice();
        $this->fVAT = oxLang::getInstance()->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    = oxLang::getInstance()->formatCurrency( $this->ddeliverycost, $this->getBasketCurrency() );
            $this->fdeliverynetcost = oxLang::getInstance()->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      = oxLang::getInstance()->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    = oxLang::getInstance()->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 = oxLang::getInstance()->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 = oxLang::getInstance()->formatCurrency( $oDiscount->dDiscount, $this->getBasketCurrency() );
            }
        }
        $this->dDiscount  = $this->getTotalDiscount()->getBruttoPrice();

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

    }


    protected function _mergeSavedBasket()
    {
        if ( $this->_blBasketMerged ) {
            return;
        }

        $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->getId(), $oItem->dAmount, $oItem->aSelList, 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();
        }
    }

    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( 'oxbase' );
                $oDelAdress->init( '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->getSession()->delBasket();

            // 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' );
        }

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

        return $this->_sShippingSetId;
    }

    public function getBasketArticles()
    {
        $aBasketArticles = array();
        foreach ( $this->_aBasketContents as $sItemKey => $oBasketItem ) {

            $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 );
                }
            }

            $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()
    {
        if ( !$this->_oNotDiscountedProductsPriceList ) {
            return array();
        }

        $aVats = array();

        $aAllVats = $this->_oNotDiscountedProductsPriceList->getVatInfo();

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

        foreach ( $aAllVats as $sKey => $dVat ) {
            $aVats[$sKey] = oxLang::getInstance()->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()
    {
        return $this->_oVoucherDiscount;
    }

    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()
    {
        return oxLang::getInstance()->formatCurrency( $this->getCosts( 'oxdelivery' )->getNettoPrice(), $this->getBasketCurrency() );
    }

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

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

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

}

---