oxorder.php

Go to the documentation of this file.

<?php

class oxOrder extends oxBase
{
    // defining order state constants
    const ORDER_STATE_MAILINGERROR = 0;

    const ORDER_STATE_OK = 1;

    const ORDER_STATE_PAYMENTERROR = 2;

    const ORDER_STATE_ORDEREXISTS = 3;

    const ORDER_STATE_INVALIDDELIVERY = 4;

    const ORDER_STATE_INVALIDPAYMENT = 5;

    protected $_aSkipSaveFields = array( 'oxorderdate' );

    protected $_oArticles = null;

    protected $_oDelSet   = null;

    protected $_oGiftCard = null;

    protected $_oPaymentType = null;

    protected $_oPayment = null;

    protected $_aVoucherList = null;

    protected $_oDelPrice = null;

    protected $_oUser = null;

    protected $_oBasket = null;

    protected $_oWrappingPrice = null;

    protected $_oPaymentPrice = null;

    protected $_sClassName = 'oxorder';

    protected $_blSeparateNumbering = null;

    protected $_iOrderLang = null;

    protected $_blReloadDelivery = true;

    protected $_blReloadDiscount = true;

    protected $_oOrderCurrency = null;

    public function __construct()
    {
        parent::__construct();
        $this->init( 'oxorder' );

        // set usage of seperate orders numbering for different shops
        $this->setSeparateNumbering( $this->getConfig()->getConfigParam( 'blSeparateNumbering') );

    }

    public function __get( $sName )
    {
        if ( $sName == 'oDelSet' ) {
            return $this->getDelSet();
        }

        if ( $sName == 'oxorder__oxbillcountry' ) {
            return $this->getBillCountry();
        }

        if ( $sName == 'oxorder__oxdelcountry' ) {
            return $this->getDelCountry();
        }
    }

    public function assign( $dbRecord )
    {

        parent::assign( $dbRecord );

        $oUtilsDate = oxUtilsDate::getInstance();

        // convert date's to international format
        $this->oxorder__oxorderdate = new oxField( $oUtilsDate->formatDBDate( $this->oxorder__oxorderdate->value));
        $this->oxorder__oxsenddate  = new oxField( $oUtilsDate->formatDBDate( $this->oxorder__oxsenddate->value));

        //settting deprecated template variables
        $this->_setDeprecatedValues();
    }

    protected function _getCountryTitle( $sCountryId )
    {
        $sTitle = null;
        if ( $sCountryId && $sCountryId != '-1' ) {
            $oCountry = oxNew( 'oxcountry' );
            $oCountry->load( $sCountryId );
            $sTitle = $oCountry->oxcountry__oxtitle->value;
        }

        return $sTitle;
    }

    public function getOrderArticles( $blExcludeCanceled = false )
    {
        // checking set value
        if ( $this->_oArticles === null  ) {
            $blExcludeState = $blExcludeCanceled;
            $sTable = getViewName( "oxorderarticles" );
            $sSelect = "select {$sTable}.* from {$sTable}
                        where {$sTable}.oxorderid = '".$this->getId() . "'" .
                        ( $blExcludeCanceled ? " and {$sTable}.oxstorno != 1 ": " " ) ."
                        order by {$sTable}.oxartid";

            // order articles
            $oArticles = oxNew( 'oxlist' );
            $oArticles->init( 'oxorderarticle' );
            $oArticles->selectString( $sSelect );

            // is value was not set, just returning it
            return $oArticles;
        }
        return $this->_oArticles;
    }

    public function setOrderArticleList( $aOrderArticleList )
    {
        $this->_oArticles = $aOrderArticleList;
    }

    public function getOrderDeliveryPrice()
    {
        if ( $this->_oDelPrice != null ) {
            return $this->_oDelPrice;
        }

        $this->_oDelPrice = oxNew( 'oxprice' );
        $this->_oDelPrice->setBruttoPriceMode();
        $this->_oDelPrice->setPrice( $this->oxorder__oxdelcost->value, $this->oxorder__oxdelvat->value );
        return $this->_oDelPrice;
    }

    public function getOrderWrappingPrice()
    {
        if ( $this->_oWrappingPrice != null ) {
            return $this->_oWrappingPrice;
        }

        $this->_oWrappingPrice = oxNew( 'oxprice' );
        $this->_oWrappingPrice->setBruttoPriceMode();
        $this->_oWrappingPrice->setPrice( $this->oxorder__oxwrapcost->value, $this->oxorder__oxwrapvat->value );
        return $this->_oWrappingPrice;
    }

    public function getOrderPaymentPrice()
    {
        if ( $this->_oPaymentPrice != null ) {
            return $this->_oPaymentPrice;
        }

        $this->_oPaymentPrice = oxNew( 'oxprice' );
        $this->_oPaymentPrice->setBruttoPriceMode();
        $this->_oPaymentPrice->setPrice( $this->oxorder__oxpaycost->value, $this->oxorder__oxpayvat->value );
        return $this->_oPaymentPrice;
    }

    public function getOrderNetSum()
    {
        $dTotalNetSum = 0;

        $dTotalNetSum += $this->oxorder__oxtotalnetsum->value;
        $dTotalNetSum += $this->getOrderDeliveryPrice()->getNettoPrice();
        $dTotalNetSum += $this->getOrderWrappingPrice()->getNettoPrice();
        $dTotalNetSum += $this->getOrderPaymentPrice()->getNettoPrice();

        return $dTotalNetSum;
    }

    public function finalizeOrder( oxBasket $oBasket, $oUser, $blRecalculatingOrder = false )
    {
        // check if this order is already stored
        $sGetChallenge = oxSession::getVar( 'sess_challenge' );
        if ( $this->_checkOrderExist( $sGetChallenge ) ) {
            oxUtils::getInstance()->logger( 'BLOCKER' );
            // we might use this later, this means that somebody klicked like mad on order button
            return self::ORDER_STATE_ORDEREXISTS;
        }

        // if not recalculating order, use sess_challenge id, else leave old order id
        if ( !$blRecalculatingOrder ) {
            // use this ID
            $this->setId( $sGetChallenge );

            // validating various order/basket parameters before finalizing
            if ( $iOrderState = $this->validateOrder( $oBasket, $oUser ) ) {
                return $iOrderState;
            }
        }

        // copies user info
        $this->_setUser( $oUser );

        // copies basket info
        $this->_loadFromBasket( $oBasket );

        // payment information
        $oUserPayment = $this->_setPayment( $oBasket->getPaymentId() );

        // set folder information, if order is new
        // #M575 in recalcualting order case folder must be the same as it was
        if ( !$blRecalculatingOrder ) {
            $this->_setFolder();
        }

        //saving all order data to DB
        $this->save();

        // executing payment (on failure deletes order and returns error code)
        // in case when recalcualting order, payment execution is skipped
        if ( !$blRecalculatingOrder ) {
            $blRet = $this->_executePayment( $oBasket, $oUserPayment );
            if ( $blRet !== true ) {
                return $blRet;
            }
        }

        // deleting remark info only when order is finished
        oxSession::deleteVar( 'ordrem' );

        // updating order trans status (success status)
        $this->_setOrderStatus( 'OK' );

        // store orderid
        $oBasket->setOrderId( $this->getId() );

        // updating wish lists
        $this->_updateWishlist( $oBasket->getContents(), $oUser );

        // updating users notice list
        $this->_updateNoticeList( $oBasket->getContents(), $oUser );

        // marking vouchers as used and sets them to $this->_aVoucherList (will be used in order email)
        // skipping this action in case of order recalculation
        if ( !$blRecalculatingOrder ) {
            $this->_markVouchers( $oBasket, $oUser );
        }

        // send order by email to shop owner and current user
        // skipping this action in case of order recalculation
        if ( !$blRecalculatingOrder ) {
            $iRet = $this->_sendOrderByEmail( $oUser, $oBasket, $oUserPayment );
        } else {
            $iRet = self::ORDER_STATE_OK;
        }

        return $iRet;
    }

    protected function _setOrderStatus( $sStatus )
    {
        $oDb = oxDb::getDb();
        $sQ = 'update oxorder set oxtransstatus='.$oDb->quote( $sStatus ).' where oxid="'.$this->getId().'" ';
        $oDb->execute( $sQ );

        //updating order object
        $this->oxorder__oxtransstatus = new oxField( $sStatus, oxField::T_RAW );
    }

    protected function _loadFromBasket( oxBasket $oBasket )
    {
        $myConfig = $this->getConfig();

        // store IP Adress - default must be FALSE as it is illegal to store
        if ( $myConfig->getConfigParam( 'blStoreIPs' ) &&  $this->oxorder__oxip->value === null ) {
            $this->oxorder__oxip = new oxField(oxUtilsServer::getInstance()->getRemoteAddress(), oxField::T_RAW);
        }

        // copying main price info
        $this->oxorder__oxtotalnetsum   = new oxField(oxUtils::getInstance()->fRound($oBasket->getProductsPrice()->getNettoSum()), oxField::T_RAW);
        $this->oxorder__oxtotalbrutsum  = new oxField($oBasket->getProductsPrice()->getBruttoSum(), oxField::T_RAW);
        $this->oxorder__oxtotalordersum = new oxField($oBasket->getPrice()->getBruttoPrice(), oxField::T_RAW);

        // payment costs if available
        if ( ( $oPaymentCost = $oBasket->getCosts( 'oxpayment' ) ) ) {
            $this->oxorder__oxpaycost = new oxField($oPaymentCost->getBruttoPrice(), oxField::T_RAW);
            $this->oxorder__oxpayvat  = new oxField($oPaymentCost->getVAT(), oxField::T_RAW);
        }

        // delivery info
        if ( ( $oDeliveryCost = $oBasket->getCosts( 'oxdelivery' ) ) ) {
            $this->oxorder__oxdelcost = new oxField($oDeliveryCost->getBruttoPrice(), oxField::T_RAW);
            //V #M382: Save VAT, not VAT value for delivery costs
            $this->oxorder__oxdelvat  = new oxField($oDeliveryCost->getVAT(), oxField::T_RAW); //V #M382
            $this->oxorder__oxdeltype = new oxField($oBasket->getShippingId(), oxField::T_RAW);
        }

        // user remark
        if ( $this->oxorder__oxremark->value === null ) {
            $this->oxorder__oxremark = new oxField(oxSession::getVar( 'ordrem' ), oxField::T_RAW);
        }

        // currency
        $oCur = $myConfig->getActShopCurrencyObject();
        $this->oxorder__oxcurrency = new oxField($oCur->name);
        $this->oxorder__oxcurrate  = new oxField($oCur->rate, oxField::T_RAW);

        // store voucherdiscount
        if ( ( $oVoucherDiscount = $oBasket->getVoucherDiscount() ) ) {
            $this->oxorder__oxvoucherdiscount = new oxField($oVoucherDiscount->getBruttoPrice(), oxField::T_RAW);
        }

        // general discount
        if ( $this->_blReloadDiscount ) {
            $dDiscount = 0;
            $aDiscounts = $oBasket->getDiscounts();
            if ( count($aDiscounts) > 0 ) {
                foreach ($aDiscounts as $oDiscount) {
                    $dDiscount += $oDiscount->dDiscount;
                }
            }
            $this->oxorder__oxdiscount = new oxField($dDiscount, oxField::T_RAW);
        }

        //order language
        $this->oxorder__oxlang = new oxField( $this->getOrderLanguage() );


        // initial status - 'ERROR'
        $this->oxorder__oxtransstatus = new oxField('ERROR', oxField::T_RAW);

        // copies basket product info ...
        $this->_setOrderArticles( $oBasket->getContents() );

        // copies wrapping info
        $this->_setWrapping( $oBasket );
    }

    public function getOrderLanguage()
    {
        if ( $this->_iOrderLang === null ) {
            if ( isset( $this->oxorder__oxlang->value ) ) {
                $this->_iOrderLang = oxLang::getInstance()->validateLanguage( $this->oxorder__oxlang->value );
            } else {
                $this->_iOrderLang = oxLang::getInstance()->getBaseLanguage();
            }
        }
        return $this->_iOrderLang;
    }

    protected function _setUser( $oUser )
    {

        $this->oxorder__oxuserid        = new oxField($oUser->getId());

        // bill address
        $this->oxorder__oxbillcompany     = clone $oUser->oxuser__oxcompany;
        $this->oxorder__oxbillemail       = clone $oUser->oxuser__oxusername;
        $this->oxorder__oxbillfname       = clone $oUser->oxuser__oxfname;
        $this->oxorder__oxbilllname       = clone $oUser->oxuser__oxlname;
        $this->oxorder__oxbillstreet      = clone $oUser->oxuser__oxstreet;
        $this->oxorder__oxbillstreetnr    = clone $oUser->oxuser__oxstreetnr;
        $this->oxorder__oxbilladdinfo     = clone $oUser->oxuser__oxaddinfo;
        $this->oxorder__oxbillustid       = clone $oUser->oxuser__oxustid;
        $this->oxorder__oxbillcity        = clone $oUser->oxuser__oxcity;
        $this->oxorder__oxbillcountryid   = clone $oUser->oxuser__oxcountryid;
        $this->oxorder__oxbillzip         = clone $oUser->oxuser__oxzip;
        $this->oxorder__oxbillfon         = clone $oUser->oxuser__oxfon;
        $this->oxorder__oxbillfax         = clone $oUser->oxuser__oxfax;
        $this->oxorder__oxbillsal         = clone $oUser->oxuser__oxsal;


        // delivery address
        if ( ( $oDelAdress = $this->getDelAddressInfo() ) ) {
            // set delivery address
            $this->oxorder__oxdelcompany   = clone $oDelAdress->oxaddress__oxcompany;
            $this->oxorder__oxdelfname     = clone $oDelAdress->oxaddress__oxfname;
            $this->oxorder__oxdellname     = clone $oDelAdress->oxaddress__oxlname;
            $this->oxorder__oxdelstreet    = clone $oDelAdress->oxaddress__oxstreet;
            $this->oxorder__oxdelstreetnr  = clone $oDelAdress->oxaddress__oxstreetnr;
            $this->oxorder__oxdeladdinfo   = clone $oDelAdress->oxaddress__oxaddinfo;
            $this->oxorder__oxdelcity      = clone $oDelAdress->oxaddress__oxcity;
            $this->oxorder__oxdelcountryid = clone $oDelAdress->oxaddress__oxcountryid;
            $this->oxorder__oxdelzip       = clone $oDelAdress->oxaddress__oxzip;
            $this->oxorder__oxdelfon       = clone $oDelAdress->oxaddress__oxfon;
            $this->oxorder__oxdelfax       = clone $oDelAdress->oxaddress__oxfax;
            $this->oxorder__oxdelsal       = clone $oDelAdress->oxaddress__oxsal;
        }
    }

    protected function _setWrapping( oxBasket $oBasket )
    {
        $myConfig = $this->getConfig();

        // wrapping price
        if ( ( $oWrappingCost = $oBasket->getCosts( 'oxwrapping' ) ) ) {
            $this->oxorder__oxwrapcost = new oxField($oWrappingCost->getBruttoPrice(), oxField::T_RAW);

            // wrapping VAT
            if ( $myConfig->getConfigParam( 'blCalcVatForWrapping' ) ) {
                $this->oxorder__oxwrapvat = new oxField($oWrappingCost->getVAT(), oxField::T_RAW);
            }
        }

        // greetings card
        $this->oxorder__oxcardid = new oxField($oBasket->getCardId(), oxField::T_RAW);

        // card text will be stored in database
        $this->oxorder__oxcardtext = new oxField($oBasket->getCardMessage(), oxField::T_RAW);
    }

    protected function _setOrderArticles( $aArticleList )
    {
        // reset articles list
        $this->_oArticles = oxNew( 'oxlist' );
        $iCurrLang = $this->getOrderLanguage();

        // add all the products we have on basket to the order
        foreach ( $aArticleList as $oContent ) {

            //$oContent->oProduct = $oContent->getArticle();
            // #M773 Do not use article lazy loading on order save
            $oProduct = $oContent->getArticle( true, null, true);

            // copy only if object is oxarticle type
            if ( $oProduct->isOrderArticle() ) {
                $oOrderArticle = $oProduct;
            } else {

                // if order language doe not match product language - article must be reloaded in order language
                if ( $iCurrLang != $oProduct->getLanguage() ) {
                    $oProduct->loadInLang( $iCurrLang, $oProduct->getProductId() );
                }

                // set chosen selectlist
                $sSelList = '';
                if ( count( $aChosenSelList = $oContent->getChosenSelList() ) ) {
                    foreach ( $aChosenSelList as $oItem ) {
                        if ( $sSelList ) {
                            $sSelList .= ", ";
                        }
                        $sSelList .= "{$oItem->name} : {$oItem->value}";
                    }
                }

                $oOrderArticle = oxNew( 'oxorderarticle' );
                $oOrderArticle->setIsNewOrderItem( true );
                $oOrderArticle->copyThis( $oProduct );
                $oOrderArticle->setId();

                $oOrderArticle->oxorderarticles__oxartnum     = clone $oProduct->oxarticles__oxartnum;
                $oOrderArticle->oxorderarticles__oxselvariant = new oxField( trim( $sSelList.' '.$oProduct->oxarticles__oxvarselect->value ), oxField::T_RAW );
                $oOrderArticle->oxorderarticles__oxshortdesc  = new oxField( $oProduct->oxarticles__oxshortdesc->value, oxField::T_RAW );
                // #M974: duplicated entries for the name of variants in orders
                $oOrderArticle->oxorderarticles__oxtitle      = new oxField( trim( $oProduct->oxarticles__oxtitle->value ), oxField::T_RAW );

                // copying persistent parameters ...
                if ( !is_array( $aPersParams = $oProduct->getPersParams() ) ) {
                    $aPersParams = $oContent->getPersParams();
                }
                if ( is_array( $aPersParams ) && count( $aPersParams )) {
                    $oOrderArticle->oxorderarticles__oxpersparam = new oxField( serialize( $aPersParams ), oxField::T_RAW );
                }
            }

            // ids, titles, numbers ...
            $oOrderArticle->oxorderarticles__oxorderid = new oxField( $this->getId() );
            $oOrderArticle->oxorderarticles__oxartid   = new oxField( $oContent->getProductId() );
            $oOrderArticle->oxorderarticles__oxamount  = new oxField( $oContent->getAmount() );

            // prices
            $oPrice = $oContent->getPrice();
            $oOrderArticle->oxorderarticles__oxnetprice  = new oxField( $oPrice->getNettoPrice(), oxField::T_RAW );
            $oOrderArticle->oxorderarticles__oxvatprice  = new oxField( $oPrice->getVatValue(), oxField::T_RAW );
            $oOrderArticle->oxorderarticles__oxbrutprice = new oxField( $oPrice->getBruttoPrice(), oxField::T_RAW );
            $oOrderArticle->oxorderarticles__oxvat       = new oxField( $oPrice->getVat(), oxField::T_RAW );

            $oUnitPtice = $oContent->getUnitPrice();
            $oOrderArticle->oxorderarticles__oxnprice = new oxField( $oUnitPtice->getNettoPrice(), oxField::T_RAW );
            $oOrderArticle->oxorderarticles__oxbprice = new oxField( $oUnitPtice->getBruttoPrice(), oxField::T_RAW );

            // wrap id
            $oOrderArticle->oxorderarticles__oxwrapid = new oxField( $oContent->getWrappingId(), oxField::T_RAW );

            // items shop id
            $oOrderArticle->oxorderarticles__oxordershopid = new oxField( $oContent->getShopId(), oxField::T_RAW );

            // add information for eMail
            //P
            //TODO: check if this assign is needed at all
            $oOrderArticle->oProduct = $oProduct;

            // simulatin order article list
            $this->_oArticles->offsetSet( $oOrderArticle->getId(), $oOrderArticle );
        }
    }

    protected function _executePayment( oxBasket $oBasket, $oUserpayment )
    {
        $oPayTransaction = $this->_getGateway();
        $oPayTransaction->setPaymentParams( $oUserpayment );

        if ( !$oPayTransaction->executePayment( $oBasket->getPrice()->getBruttoPrice(), $this ) ) {
            $this->delete();

            // checking for error messages
            if ( method_exists( $oPayTransaction, 'getLastError' ) ) {
                if ( ( $sLastError = $oPayTransaction->getLastError() ) ) {
                    return $sLastError;
                }
            }

            // checking for error codes
            if ( method_exists( $oPayTransaction, 'getLastErrorNo' ) ) {
                if ( ( $iLastErrorNo = $oPayTransaction->getLastErrorNo() ) ) {
                    return $iLastErrorNo;
                }
            }

            return self::ORDER_STATE_PAYMENTERROR; // means no authentication
        }
        return true; // everything fine
    }

    protected function _getGateway()
    {
        return oxNew( 'oxPaymentGateway' );
    }

    protected function _setPayment( $sPaymentid )
    {
        // copying payment info fields
        $aDynvalue = oxSession::getVar( 'dynvalue' );
        $aDynvalue = $aDynvalue ? $aDynvalue : oxConfig::getParameter( 'dynvalue' );

        // loading payment object
        $oPayment = oxNew( 'oxpayment' );

        if (!$oPayment->load( $sPaymentid )) {
            return null;
        }

        // #756M Preserve already stored payment information
        if ( !$aDynvalue && ( $oUserpayment = $this->getPaymentType() ) ) {
            if ( is_array( $aStoredDynvalue = $oUserpayment->getDynValues() ) ) {
            foreach ( $aStoredDynvalue as $oVal ) {
                    $aDynvalue[$oVal->name] = $oVal->value;
                }
            }
        }

        $oPayment->setDynValues( oxUtils::getInstance()->assignValuesFromText( $oPayment->oxpayments__oxvaldesc->value ) );

        // collecting dynamic values
        $aDynVal = array();

        if ( is_array( $aPaymentDynValues = $oPayment->getDynValues() ) ) {
            foreach ( $aPaymentDynValues  as $key => $oVal ) {
                if ( isset( $aDynvalue[$oVal->name] ) ) {
                    $oVal->value = $aDynvalue[$oVal->name];
                }

                //$oPayment->setDynValue($key, $oVal);
                $aPaymentDynValues[$key] = $oVal;
                $aDynVal[$oVal->name] = $oVal->value;
            }
        }

        // Store this payment information, we might allow users later to
        // reactivate already give payment informations

        $oUserpayment = oxNew( 'oxuserpayment' );
        $oUserpayment->oxuserpayments__oxuserid     = clone $this->oxorder__oxuserid;
        $oUserpayment->oxuserpayments__oxpaymentsid = new oxField($sPaymentid, oxField::T_RAW);
        $oUserpayment->oxuserpayments__oxvalue      = new oxField(oxUtils::getInstance()->assignValuesToText( $aDynVal ), oxField::T_RAW);
        $oUserpayment->oxpayments__oxdesc           = clone $oPayment->oxpayments__oxdesc;
        $oUserpayment->setDynValues( $aPaymentDynValues );
        $oUserpayment->save();

        // storing payment information to order
        $this->oxorder__oxpaymentid   = new oxField($oUserpayment->getId(), oxField::T_RAW);
        $this->oxorder__oxpaymenttype = clone $oUserpayment->oxuserpayments__oxpaymentsid;

        // returning user payment object which will be used later in code ...
        return $oUserpayment;
    }

    protected function _setFolder()
    {
        $myConfig = $this->getConfig();
        $this->oxorder__oxfolder    = new oxField(key( $myConfig->getShopConfVar(  'aOrderfolder', $myConfig->getShopId() ) ), oxField::T_RAW);
    }

    protected function _updateWishlist( $aArticleList, $oUser )
    {

        foreach ( $aArticleList as $oContent) {
            if ( ( $sWishId = $oContent->getWishId() ) ) {

                // checking which wishlist user uses ..
                if ( $sWishId == $oUser->getId() ) {
                    $oUserBasket = $oUser->getBasket( 'wishlist' );
                } else {
                    $aWhere = array( 'oxuserbaskets.oxuserid' => $sWishId, 'oxuserbaskets.oxtitle' => 'wishlist' );
                    $oUserBasket = oxNew( 'oxuserbasket' );
                    $oUserBasket->assignRecord( $oUserBasket->buildSelectString( $aWhere ) );
                }

                // updating users wish list
                if ( $oUserBasket ) {
                    if ( !($sProdId = $oContent->getWishArticleId() )) {
                        $sProdId = $oContent->getProductId();
                    }
                    $oUserBasketItem = $oUserBasket->getItem( $sProdId, $oContent->getSelList() );
                    $dNewAmount = $oUserBasketItem->oxuserbasketitems__oxamount->value - $oContent->getAmount();
                    if ( $dNewAmount < 0) {
                        $dNewAmount = 0;
                    }
                    $oUserBasket->addItemToBasket( $sProdId, $dNewAmount, $oContent->getSelList(), true );
                }
            }
        }
    }

    protected function _updateNoticeList( $aArticleList, $oUser )
    {
        // loading users notice list ..
        if ( $oUserBasket = $oUser->getBasket( 'noticelist' ) ) {
            // only if wishlist is enabled
            foreach ( $aArticleList as $oContent) {
                $sProdId = $oContent->getProductId();

                // updating users notice list
                $oUserBasketItem = $oUserBasket->getItem( $sProdId, $oContent->getSelList() );
                $dNewAmount = $oUserBasketItem->oxuserbasketitems__oxamount->value - $oContent->getAmount();
                if ( $dNewAmount < 0) {
                    $dNewAmount = 0;
                }
                $oUserBasket->addItemToBasket( $sProdId, $dNewAmount, $oContent->getSelList(), true );
            }
        }
    }

    protected function _updateStock()
    {
        $myConfig = $this->getConfig();

        // ordered articles
        if ( $myConfig->getConfigParam( 'blUseStock' ) ) {
            $oOrderArticles = $this->getOrderArticles();
            foreach ( $oOrderArticles as $oOrderArticle ) {
                if ( $oOrderArticle->isNewOrderItem() ) {
                    $oOrderArticle->updateArticleStock( $oOrderArticle->oxorderarticles__oxamount->value * (-1), $myConfig->getConfigParam( 'blAllowNegativeStock' ) );
                }
            }
        }
    }

    protected function _markVouchers( $oBasket, $oUser )
    {
        $this->_aVoucherList = $oBasket->getVouchers();

        if ( is_array( $this->_aVoucherList ) ) {
            foreach ( $this->_aVoucherList as $sVoucherId => $oSimpleVoucher) {
                $oVoucher = oxNew( 'oxvoucher' );
                $oVoucher->load( $sVoucherId );
                $oVoucher->markAsUsed( $this->oxorder__oxid->value, $oUser->oxuser__oxid->value, $oSimpleVoucher->fVoucherdiscount );

                $this->_aVoucherList[$sVoucherId] = $oVoucher;
            }
        }
    }

    public function save()
    {
        if ( ( $blSave = parent::save() ) ) {

            // saving order articles
            $oOrderArticles = $this->getOrderArticles();
            if ( $oOrderArticles && count( $oOrderArticles ) > 0 ) {
                foreach ( $oOrderArticles as $oOrderArticle ) {
                    $oOrderArticle->save();
                }
            }
        }

        return $blSave;
    }

    public function getDelAddressInfo()
    {
        $oDelAdress = null;
        if ( ( $soxAddressId = oxConfig::getParameter( 'deladrid' ) ) ) {
            $oDelAdress = oxNew( 'oxaddress' );
            $oDelAdress->load( $soxAddressId );

            //get delivery country name from delivery country id
            if ( $oDelAdress->oxaddress__oxcountryid->value && $oDelAdress->oxaddress__oxcountryid->value != -1 ) {
                 $oCountry = oxNew( 'oxcountry' );
                 $oCountry->load( $oDelAdress->oxaddress__oxcountryid->value );
                 $oDelAdress->oxaddress__oxcountry = clone $oCountry->oxcountry__oxtitle;
            }
        }
        return $oDelAdress;
    }

    public function validateStock( $oBasket )
    {
        foreach ( $oBasket->getContents() as $key => $oContent ) {
            try {
                $oProd = $oContent->getArticle();
            } catch ( oxNoArticleException $oEx ) {
                $oBasket->removeItem( $key );
                throw $oEx;
            } catch ( oxArticleInputException $oEx ) {
                $oBasket->removeItem( $key );
                throw $oEx;
            }

            // check if its still available
            $iOnStock = $oProd->checkForStock( $oContent->getAmount() );
            if ( $iOnStock !== true ) {
                $oEx = oxNew( 'oxOutOfStockException' );
                $oEx->setMessage( 'EXCEPTION_OUTOFSTOCK_OUTOFSTOCK' );
                $oEx->setArticleNr( $oProd->oxarticles__oxartnum->value );
                $oEx->setProductId( $oProd->getId() );
                $oEx->setRemainingAmount( $oProd->oxarticles__oxstock->value );
                throw $oEx;
            }
        }
    }

    protected function _insert()
    {
        $myConfig = $this->getConfig();
        $oUtilsDate = oxUtilsDate::getInstance();

        //V #M525 orderdate must be the same as it was
        if ( !$this->oxorder__oxorderdate->value ) {
            $this->oxorder__oxorderdate = new oxField(date( 'Y-m-d H:i:s', $oUtilsDate->getTime() ), oxField::T_RAW);
        } else {
            $this->oxorder__oxorderdate = new oxField( $oUtilsDate->formatDBDate( $this->oxorder__oxorderdate->value, true ));
        }
        $this->oxorder__oxshopid    = new oxField($myConfig->getShopId(), oxField::T_RAW);

        $this->oxorder__oxsenddate  = new oxField( $oUtilsDate->formatDBDate( $this->oxorder__oxsenddate->value, true ));

        if ( ( $blInsert = parent::_insert() ) ) {
            // setting order number
            if ( !$this->oxorder__oxordernr->value ) {
                $aWhere = '';
                // separate order numbers for shops ...
                if ( $this->_blSeparateNumbering ) {
                    $aWhere = array( 'oxshopid = "'.$myConfig->getShopId().'"' );
                }
                $this->_setRecordNumber( 'oxordernr', $aWhere );
            }
        }
        return $blInsert;
    }

    protected function _update()
    {
        $this->oxorder__oxsenddate = new oxField(oxUtilsDate::getInstance()->formatDBDate( $this->oxorder__oxsenddate->value, true ));
        return parent::_update();
    }

    public function delete( $sOxId = null )
    {
        if ( $sOxId ) {
            if ( !$this->load( $sOxId ) ) {
                // such order does not exist
                return false;
            }
        } elseif ( !$sOxId ) {
            $sOxId = $this->getId();
        }

        // no order id is passed
        if ( !$sOxId ) {
            return false;
        }


        // delete order articles
        $oOrderArticles = $this->getOrderArticles( false );
        foreach ( $oOrderArticles as $oOrderArticle ) {
            $oOrderArticle->delete();
        }

        // #440 - deleting user payment info
        if ( $oPaymentType = $this->getPaymentType() ) {
            $oPaymentType->delete();
        }

        return parent::delete( $sOxId );
    }

    public function recalculateOrder( $aNewArticles = array() )
    {
        oxDb::startTransaction();

        try {
            $oBasket = $this->_getOrderBasket();

            // add this order articles to virtual basket and recalculates basket
            $this->_addOrderArticlesToBasket( $oBasket, $this->getOrderArticles( true ) );

            // adding new articles to existing order
            $this->_addArticlesToBasket( $oBasket, $aNewArticles );

            // recalculating basket
            $oBasket->calculateBasket( true );

            //finalizing order (skipping payment execution, vouchers marking and mail sending)
            $iRet = $this->finalizeOrder( $oBasket, $this->getOrderUser(), true );

            //if finalizing order failed, rollback transaction
            if ( $iRet !== 1 ) {
                oxDb::rollbackTransaction();
            } else {
                oxDb::commitTransaction();
            }

        } catch( Exception $oE ) {
            // if exception, rollBack everything
            oxDb::rollbackTransaction();
        }
    }

    protected $_oOrderBasket = null;
    protected function _getOrderBasket( $blStockCheck = true )
    {
        $this->_oOrderBasket = oxNew( "oxbasket" );

        // setting stock check mode
        $this->_oOrderBasket->setStockCheckMode( $blStockCheck );

        // setting virtual basket user
        $this->_oOrderBasket->setBasketUser( $this->getOrderUser() );

        // transferring order id
        $this->_oOrderBasket->setOrderId( $this->getId() );

        // setting basket currency order uses
        $aCurrencies = $this->getConfig()->getCurrencyArray();
        foreach ( $aCurrencies as $oCur ) {
            if ($oCur->name == $this->oxorder__oxcurrency->value) {
                $oBasketCur = $oCur;
                break;
            }
        }

        // setting currency
        $this->_oOrderBasket->setBasketCurrency( $oBasketCur );

        // set basket card id and message
        $this->_oOrderBasket->setCardId( $this->oxorder__oxcardid->value );
        $this->_oOrderBasket->setCardMessage( $this->oxorder__oxcardtext->value );

        if ( $this->_blReloadDiscount ) {
            // disabling availability check
            $this->_oOrderBasket->setSkipVouchersChecking( true );

            // add previously used vouchers
            $sQ = 'select oxid from oxvouchers where oxorderid = "'.$this->getId().'"';
            $aVouchers = oxDb::getDb( true )->getAll( $sQ );
            foreach ( $aVouchers as $aVoucher ) {
                $this->_oOrderBasket->addVoucher( $aVoucher['oxid'] );
            }
        } else {
            $this->_oOrderBasket->setDiscountCalcMode( false );
            $this->_oOrderBasket->setVoucherDiscount( $this->oxorder__oxvoucherdiscount->value );
            $this->_oOrderBasket->setTotalDiscount( $this->oxorder__oxdiscount->value );
        }

        // must be kept old delivery?
        if ( !$this->_blReloadDelivery ) {
            $this->_oOrderBasket->setDeliveryPrice( $this->getOrderDeliveryPrice() );
        } else {
            //  set shipping
            $this->_oOrderBasket->setShipping( $this->oxorder__oxdeltype->value );
            $this->_oOrderBasket->setDeliveryPrice( null );
        }

        //set basket payment
        $this->_oOrderBasket->setPayment( $this->oxorder__oxpaymenttype->value );

        return $this->_oOrderBasket;
    }

    public function setDelivery( $sDeliveryId )
    {
        $this->reloadDelivery( true );
        $this->oxorder__oxdeltype = new oxField( $sDeliveryId );
    }

    public function getOrderUser()
    {
        if ($this->_oUser) {
            return $this->_oUser;
        }
        $this->_oUser = oxNew( "oxuser" );
        $this->_oUser->load( $this->oxorder__oxuserid->value );

        return $this->_oUser;
    }

    public function pdfFooter( $oPdf )
    {
    }

    public function pdfHeaderplus( $oPdf )
    {
    }

    public function pdfHeader( $oPdf )
    {
    }

    public function genPdf( $sFilename, $iSelLang = 0 )
    {
    }

    public function getInvoiceNum()
    {
        $sQ = 'select max(oxorder.oxinvoicenr) from oxorder where oxorder.oxshopid = "'.$this->getConfig()->getShopId().'" ';
        return ( ( int ) oxDb::getDb()->getOne( $sQ ) + 1 );
    }

    public function getNextBillNum()
    {
        $sQ = 'select max(cast(oxorder.oxbillnr as unsigned)) from oxorder where oxorder.oxshopid = "'.$this->getConfig()->getShopId().'" ';
        return ( ( int ) oxDb::getDb()->getOne( $sQ ) + 1 );
    }

    public function getShippingSetList()
    {
        // in which country we deliver
        if ( !( $sShipId = $this->oxorder__oxdelcountryid->value ) ) {
            $sShipId = $this->oxorder__oxbillcountryid->value;
        }

        $oBasket = $this->_getOrderBasket( false );

        // add this order articles to basket and recalculate basket
        $this->_addOrderArticlesToBasket( $oBasket, $this->getOrderArticles() );

        // recalculating basket
        $oBasket->calculateBasket( true );

        // load fitting deliveries list
        $oDeliveryList = oxNew( "oxDeliveryList", "core" );
        $oDeliveryList->setCollectFittingDeliveriesSets( true );

        return $oDeliveryList->getDeliveryList( $oBasket, $this->getOrderUser(), $sShipId );
    }

    public function getVoucherNrList()
    {
        $oDB = oxDb::getDb( true );
        $aVouchers = array();
        $sSelect = "select oxvouchernr from oxvouchers where oxorderid = ".$oDB->quote( $this->oxorder__oxid->value );
        $rs = $oDB->execute( $sSelect);
        if ($rs != false && $rs->recordCount() > 0) {
            while (!$rs->EOF) {
                $aVouchers[] = $rs->fields['oxvouchernr'];
                $rs->moveNext();
            }
        }
        return $aVouchers;
    }

    public function getOrderSum( $blToday = false )
    {
        $sSelect  = 'select sum(oxtotalordersum / oxcurrate) from oxorder where ';
        $sSelect .= 'oxshopid = "'.$this->getConfig()->getShopId().'" and oxorder.oxstorno != "1" ';

        if ( $blToday ) {
            $sSelect .= 'and oxorderdate like "'.date( 'Y-m-d').'%" ';
        }

        return ( double ) oxDb::getDb()->getOne( $sSelect );
    }

    public function getOrderCnt( $blToday = false )
    {
        $sSelect  = 'select count(*) from oxorder where ';
        $sSelect .= 'oxshopid = "'.$this->getConfig()->getShopId().'"  and oxorder.oxstorno != "1" ';

        if ( $blToday ) {
            $sSelect .= 'and oxorderdate like "'.date( 'Y-m-d').'%" ';
        }

        return ( int ) oxDb::getDb()->getOne( $sSelect );
    }


    protected function _checkOrderExist( $sOxId = null )
    {
        if ( !$sOxId) {
            return false;
        }

        $oDb = oxDb::getDb();
        if ( $oDb->getOne( 'select oxid from oxorder where oxid = '.$oDb->quote( $sOxId ) ) ) {
            return true;
        }

        return false;
    }

    protected function _sendOrderByEmail( $oUser = null, $oBasket = null, $oPayment = null )
    {
        $iRet = self::ORDER_STATE_MAILINGERROR;

        // add user, basket and payment to order
        $this->_oUser    = $oUser;
        $this->_oBasket  = $oBasket;
        $this->_oPayment = $oPayment;

        $oxEmail = oxNew( 'oxemail' );

        // send order email to user
        if ( $oxEmail->sendOrderEMailToUser( $this ) ) {
            // mail to user was successfully sent
            $iRet = self::ORDER_STATE_OK;
        }

        // send order email to shop owner
        $oxEmail->sendOrderEMailToOwner( $this );

        return $iRet;
    }

    public function getBasket()
    {
        return $this->_oBasket;
    }

    public function getPayment()
    {
        return $this->_oPayment;
    }

    public function getVoucherList()
    {
        return $this->_aVoucherList;
    }

    public function getDelSet()
    {
        if ( $this->_oDelSet == null ) {
            // load deliveryset info
            $this->_oDelSet = oxNew( 'oxdeliveryset' );
            $this->_oDelSet->load( $this->oxorder__oxdeltype->value );
        }

        return $this->_oDelSet;
    }

    public function getPaymentType()
    {
        if ( $this->oxorder__oxpaymentid->value && $this->_oPaymentType === null ) {
            $this->_oPaymentType = false;
            $oPaymentType = oxNew( 'oxuserpayment' );
            if ( $oPaymentType->load( $this->oxorder__oxpaymentid->value ) ) {
                $this->_oPaymentType = $oPaymentType;
            }
        }

        return $this->_oPaymentType;
    }

    public function getGiftCard()
    {
        if ( $this->oxorder__oxcardid->value && $this->_oGiftCard == null ) {
            $this->_oGiftCard = oxNew( 'oxwrapping' );
            $this->_oGiftCard->load( $this->oxorder__oxcardid->value );
        }

        return $this->_oGiftCard;
    }

    public function setSeparateNumbering( $blSeparateNumbering = null )
    {
        $this->_blSeparateNumbering = $blSeparateNumbering;
    }

    public function getLastUserPaymentType( $sUserId)
    {
        $oDb = oxDb::getDb();
        $sQ = 'select oxorder.oxpaymenttype from oxorder where oxorder.oxshopid="'.$this->getConfig()->getShopId().'" and oxorder.oxuserid='.$oDb->quote( $sUserId ).' order by oxorder.oxorderdate desc ';
        $sLastPaymentId = $oDb->getOne( $sQ );
        return $sLastPaymentId;
    }

    protected function _makeSelListArray( $sArtId = null, $sOrderArtSelList = null )
    {
        $oOrder = oxNew( 'oxorderArticle' );
        return $oOrder->getOrderArticleSelectList( $sArtId, $sOrderArtSelList );
    }

    protected function _addOrderArticlesToBasket( $oBasket, $aOrderArticles )
    {
        // if no order articles, return empty basket
        if ( count( $aOrderArticles ) > 0 ) {

            //adding order articles to basket
            foreach ( $aOrderArticles as $oOrderArticle ) {
                $oBasket->addOrderArticleToBasket( $oOrderArticle );
            }
        }
    }

    protected function _addArticlesToBasket( $oBasket, $aArticles )
    {
        // if no order articles
        if ( count($aArticles ) > 0 ) {

            //adding order articles to basket
            foreach ( $aArticles as $oArticle ) {
                $aSel = isset( $oArticle->oxorderarticles__oxselvariant ) ? $oArticle->oxorderarticles__oxselvariant->value : null;
                $aPersParam = isset( $oArticle->oxorderarticles__oxpersparam ) ? $oArticle->getPersParams() : null;
                $oBasket->addToBasket( $oArticle->oxorderarticles__oxartid->value,
                                       $oArticle->oxorderarticles__oxamount->value,
                                       $aSel, $aPersParam );
            }
        }
    }

    protected function _setDeprecatedValues()
    {
        if ( $this->oxorder__oxstorno->value != 1 ) {
            $oCur = $this->getConfig()->getActShopCurrencyObject();
            $oLang = oxLang::getInstance();

            $this->totalnetsum   = $this->oxorder__oxtotalnetsum->value;
            $this->totalbrutsum  = $this->oxorder__oxtotalbrutsum->value;
            $this->totalorder    = $this->oxorder__oxtotalordersum->value;
            $this->ftotalnetsum  = $oLang->formatCurrency( $this->oxorder__oxtotalnetsum->value, $oCur );
            $this->ftotalbrutsum = $oLang->formatCurrency( $this->oxorder__oxtotalbrutsum->value, $oCur );
            $this->fdelcost      = $oLang->formatCurrency( $this->oxorder__oxdelcost->value, $oCur );
            $this->fpaycost      = $oLang->formatCurrency( $this->oxorder__oxpaycost->value, $oCur );
            $this->fwrapcost     = $oLang->formatCurrency( $this->oxorder__oxwrapcost->value, $oCur );
            $this->ftotalorder   = $this->getTotalOrderSum();
            $this->totalvouchers = 0;

            if ( $this->oxorder__oxvoucherdiscount->value ) {
                $this->totalvouchers  = $oLang->formatCurrency( $this->oxorder__oxvoucherdiscount->value, $oCur );
            }

            if ( $this->oxorder__oxdiscount->value ) {
                $this->discount  = $this->oxorder__oxdiscount->value;
                $this->fdiscount = $oLang->formatCurrency( $this->oxorder__oxdiscount->value, $oCur );
            }
        }
    }

    public function getTotalOrderSum()
    {
        $oCur = $this->getConfig()->getActShopCurrencyObject();
        return number_format( $this->oxorder__oxtotalordersum->value, $oCur->decimal, '.', '');
    }

    public function getBillCountry()
    {
        if ( !$this->oxorder__oxbillcountry->value ) {
            $this->oxorder__oxbillcountry = new oxField($this->_getCountryTitle( $this->oxorder__oxbillcountryid->value ));
        }
        return $this->oxorder__oxbillcountry;
    }

    public function getDelCountry()
    {
        if ( !$this->oxorder__oxdelcountry->value ) {
            $this->oxorder__oxdelcountry = new oxField($this->_getCountryTitle( $this->oxorder__oxdelcountryid->value ));
        }
        return $this->oxorder__oxdelcountry;
    }
    public function reloadDelivery( $blReload )
    {
        $this->_blReloadDelivery = $blReload;
    }

    public function reloadDiscount( $blReload )
    {
        $this->_blReloadDiscount = $blReload;
    }

    public function cancelOrder()
    {
        $this->oxorder__oxstorno = new oxField( 1 );
        if ( $this->save() ) {
            // canceling ordered products
            foreach ( $this->getOrderArticles() as $oOrderArticle ) {
                $oOrderArticle->cancelOrderArticle();
            }
        }
    }

    public function getOrderCurrency()
    {
        if ( $this->_oOrderCurrency === null ) {

            // setting default in case unrecognized currency was set during order
            $aCurrencies = $this->getConfig()->getCurrencyArray();
            $this->_oOrderCurrency = current( $aCurrencies );

            foreach ( $aCurrencies as $oCurr ) {
                if( $oCurr->name == $this->oxorder__oxcurrency->value ) {
                    $this->_oOrderCurrency = $oCurr;
                    break;
                }
            }
        }
        return $this->_oOrderCurrency;
    }

    public function validateOrder( $oBasket, $oUser )
    {
        // validating stock
        $iValidState = $this->validateStock( $oBasket );

        if ( !$iValidState ) {
            // validating delivery
            $iValidState = $this->validateDelivery( $oBasket );
        }

        if ( !$iValidState ) {
            // validating payment
            $iValidState = $this->validatePayment( $oBasket );
        }

        return $iValidState;
    }

    public function validateDelivery( $oBasket )
    {
        // proceed with no delivery
        // used for other countries
        if ( $oBasket->getPaymentId() == 'oxempty') {
            return;
        }
        $oDb = oxDb::getDb();

        $oDelSet = oxNew( "oxdeliveryset" );
        $sTable = $oDelSet->getViewName();

        $sQ = "select 1 from {$sTable} where {$sTable}.oxid=".
              $oDb->quote( $oBasket->getShippingId() )." and ".$oDelSet->getSqlActiveSnippet();

        if ( !$oDb->getOne( $sQ ) ) {
            // throwing exception
            return self::ORDER_STATE_INVALIDDELIVERY;
        }
    }

    public function validatePayment( $oBasket )
    {
        $oDb = oxDb::getDb();

        $oPayment = oxNew( "oxpayment" );
        $sTable = $oPayment->getViewName();

        $sQ = "select 1 from {$sTable} where {$sTable}.oxid=".
              $oDb->quote( $oBasket->getPaymentId() )." and ".$oPayment->getSqlActiveSnippet();

        if ( !$oDb->getOne( $sQ ) ) {
            return self::ORDER_STATE_INVALIDPAYMENT;
        }
    }
}

---