oxorderarticle.php

Go to the documentation of this file.

<?php

class oxOrderArticle extends oxBase implements oxIArticle
{

    protected static $_aOrderCache = array();

    protected $_sClassName = 'oxorderarticle';

    protected $_aPersParam = null;

    protected $_aStatuses = null;

    protected $_aOrderArticleSelList = null;

    protected $_oOrderArticle = null;

    protected $_oArticle = null;

    protected $_blIsNewOrderItem = false;

    protected $_aSkipSaveFields = array( 'oxtimestamp' );

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

    public function copyThis( $oProduct )
    {
        $aObjectVars = get_object_vars( $oProduct );

        foreach ( $aObjectVars as $sName => $sValue ) {
            if ( isset( $oProduct->$sName->value ) ) {
                $sFieldName = preg_replace('/oxarticles__/', 'oxorderarticles__', $sName);
                if ( $sFieldName != "oxorderarticles__oxtimestamp" ) {
                    $this->$sFieldName = $oProduct->$sName;
                }
                // formatting view
                if ( !$this->getConfig()->getConfigParam( 'blSkipFormatConversion' ) ) {
                    if ( $sFieldName == "oxorderarticles__oxinsert" ) {
                        oxRegistry::get("oxUtilsDate")->convertDBDate( $this->$sFieldName, true );
                    }
                }
            }
        }

    }

    public function assign( $dbRecord )
    {
        parent::assign( $dbRecord );
        $this->_setArticleParams();
    }

    public function updateArticleStock( $dAddAmount, $blAllowNegativeStock = false )
    {
        // TODO: use oxarticle reduceStock
        // decrement stock if there is any
        $oArticle = oxNew( 'oxarticle' );
        $oArticle->load( $this->oxorderarticles__oxartid->value );
        $oArticle->beforeUpdate();

        if ( $this->getConfig()->getConfigParam( 'blUseStock' ) ) {
            // get real article stock count
            $iStockCount = $this->_getArtStock( $dAddAmount, $blAllowNegativeStock );
            $oDb = oxDb::getDb();

            $oArticle->oxarticles__oxstock = new oxField($iStockCount);
            $oDb->execute( 'update oxarticles set oxarticles.oxstock = '.$oDb->quote( $iStockCount ).' where oxarticles.oxid = '.$oDb->quote( $this->oxorderarticles__oxartid->value ) );
            $oArticle->onChange( ACTION_UPDATE_STOCK );
        }

        //update article sold amount
        $oArticle->updateSoldAmount( $dAddAmount * ( -1 ) );
    }

    protected function _getArtStock( $dAddAmount = 0, $blAllowNegativeStock = false )
    {
        $oDb = oxDb::getDb();

        // #1592A. must take real value
        $sQ = 'select oxstock from oxarticles where oxid = '.$oDb->quote( $this->oxorderarticles__oxartid->value );
        $iStockCount  = ( float ) $oDb->getOne( $sQ, false, false );

        $iStockCount += $dAddAmount;

        // #1592A. calculating according new stock option
        if ( !$blAllowNegativeStock && $iStockCount < 0 ) {
            $iStockCount = 0;
        }

        return $iStockCount;
    }


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

        if ( $this->oxorderarticles__oxpersparam->value ) {
            $this->_aPersParam = unserialize( $this->oxorderarticles__oxpersparam->value );
        }

        return $this->_aPersParam;
    }

    public function setPersParams( $aParams )
    {
        $this->_aPersParam = $aParams;

        // serializing persisten info stored while ordering
        $this->oxorderarticles__oxpersparam = new oxField(serialize( $aParams ), oxField::T_RAW);
    }

    protected function _setFieldData( $sFieldName, $sValue, $iDataType = oxField::T_TEXT)
    {
        $sFieldName = strtolower($sFieldName);
        switch ( $sFieldName ) {
            case 'oxpersparam':
            case 'oxorderarticles__oxpersparam':
            case 'oxerpstatus':
            case 'oxorderarticles__oxerpstatus':
            case 'oxtitle':
            case 'oxorderarticles__oxtitle':
                $iDataType = oxField::T_RAW;
                break;
        }
        return parent::_setFieldData($sFieldName, $sValue, $iDataType);
    }

    public function loadInLang( $iLanguage, $sOxid )
    {
        return $this->load( $sOxid );
    }

    public function getProductId()
    {
        return $this->oxorderarticles__oxartid->value;
    }

    public function getProductParentId()
    {
        // when this field will be introduced there will be no need to load from real article
        if ( isset( $this->oxorderarticles__oxartparentid ) && $this->oxorderarticles__oxartparentid->value !== false ) {
            return $this->oxorderarticles__oxartparentid->value;
        }

        $oDb = oxDb::getDb();
        $oArticle = oxNew( "oxarticle" );
        $sQ = "select oxparentid from " . $oArticle->getViewName() . " where oxid=" . $oDb->quote( $this->getProductId() );
        $this->oxarticles__oxparentid = new oxField( $oDb->getOne( $sQ ) );
        return $this->oxarticles__oxparentid->value;
    }

    protected function _setArticleParams()
    {
        // creating needed fields
        $this->oxarticles__oxstock  = $this->oxorderarticles__oxamount;
        $this->oxarticles__oxtitle  = $this->oxorderarticles__oxtitle;
        $this->oxarticles__oxwidth  = $this->oxorderarticles__oxwidth;
        $this->oxarticles__oxlength = $this->oxorderarticles__oxlength;
        $this->oxarticles__oxheight = $this->oxorderarticles__oxheight;
        $this->oxarticles__oxweight = $this->oxorderarticles__oxweight;
        $this->oxarticles__oxsubclass  = $this->oxorderarticles__oxsubclass;
        $this->oxarticles__oxartnum    = $this->oxorderarticles__oxartnum;
        $this->oxarticles__oxshortdesc = $this->oxorderarticles__oxshortdesc;

        $this->oxarticles__oxvat    = $this->oxorderarticles__oxvat;
        $this->oxarticles__oxprice  = $this->oxorderarticles__oxprice;
        $this->oxarticles__oxbprice = $this->oxorderarticles__oxbprice;

        $this->oxarticles__oxthumb = $this->oxorderarticles__oxthumb;
        $this->oxarticles__oxpic1  = $this->oxorderarticles__oxpic1;
        $this->oxarticles__oxpic2  = $this->oxorderarticles__oxpic2;
        $this->oxarticles__oxpic3  = $this->oxorderarticles__oxpic3;
        $this->oxarticles__oxpic4  = $this->oxorderarticles__oxpic4;
        $this->oxarticles__oxpic5  = $this->oxorderarticles__oxpic5;

        $this->oxarticles__oxfile     = $this->oxorderarticles__oxfile;
        $this->oxarticles__oxdelivery = $this->oxorderarticles__oxdelivery;
        $this->oxarticles__oxissearch = $this->oxorderarticles__oxissearch;
        $this->oxarticles__oxfolder   = $this->oxorderarticles__oxfolder;
        $this->oxarticles__oxtemplate = $this->oxorderarticles__oxtemplate;
        $this->oxarticles__oxexturl   = $this->oxorderarticles__oxexturl;
        $this->oxarticles__oxurlimg   = $this->oxorderarticles__oxurlimg;
        $this->oxarticles__oxurldesc  = $this->oxorderarticles__oxurldesc;
        $this->oxarticles__oxshopid   = $this->oxorderarticles__oxordershopid;
        $this->oxarticles__oxquestionemail = $this->oxorderarticles__oxquestionemail;
        $this->oxarticles__oxsearchkeys    = $this->oxorderarticles__oxsearchkeys;
    }

    public function checkForStock( $dAmount, $dArtStockAmount = 0 )
    {
        return true;
    }

    protected function _getOrderArticle( $sArticleId = null )
    {
        if ( $this->_oOrderArticle === null ) {
            $this->_oOrderArticle = false;

            $sArticleId = $sArticleId ? $sArticleId : $this->getProductId();
            $oArticle = oxNew( "oxArticle" );
            if ( $oArticle->load( $sArticleId ) ) {
                $this->_oOrderArticle = $oArticle;
            }
        }
        return $this->_oOrderArticle;
    }

    public function getSelectLists( $sKeyPrefix = null )
    {
        $aSelLists = array();
        if ( $oArticle = $this->_getOrderArticle() ) {
            $aSelLists = $oArticle->getSelectLists();
        }
        return $aSelLists;
    }

    public function getOrderArticleSelectList( $sArtId = null, $sOrderArtSelList = null )
    {
        if ( $this->_aOrderArticleSelList === null ) {

            $sOrderArtSelList = $sOrderArtSelList ? $sOrderArtSelList : $this->oxorderarticles__oxselvariant->value;

            $aList = array();
            $aRet  = array();

            if ( $oArticle = $this->_getOrderArticle( $sArtId ) ) {
                $aList = explode( ", ", $sOrderArtSelList );
                $oStr = getStr();

                $aArticleSelList = $oArticle->getSelectLists();

                //formatting temporary list array from string
                foreach ( $aList as $sList ) {
                    if ( $sList ) {

                        $aVal = explode( ":", $sList );
                        if ( isset($aVal[0]) && isset($aVal[1])) {
                            $sOrderArtListTitle = $oStr->strtolower( trim($aVal[0]) );
                            $sOrderArtSelValue  = $oStr->strtolower( trim($aVal[1]) );

                            //checking article list for matches with article list stored in oxOrderItem
                            $iSelListNum = 0;
                            if ( count($aArticleSelList) > 0 ) {
                                foreach ( $aArticleSelList as $aSelect ) {
                                    //check if selects titles are equal

                                    if ( $oStr->strtolower($aSelect['name']) == $sOrderArtListTitle ) {
                                        //try to find matching select items value
                                        $iSelValueNum = 0;
                                        foreach ( $aSelect as $oSel ) {
                                            if ( $oStr->strtolower($oSel->name) == $sOrderArtSelValue ) {
                                                // found, adding to return array
                                                $aRet[$iSelListNum] = $iSelValueNum;
                                            }
                                            //next article list item
                                            $iSelValueNum++;
                                        }
                                    }
                                    //next article list
                                    $iSelListNum++;
                                }
                            }
                        }
                    }
                }
            }

            $this->_aOrderArticleSelList = $aRet;
        }

        return $this->_aOrderArticleSelList;
    }

    public function getBasketPrice( $dAmount, $aSelList, $oBasket )
    {
        $oArticle = $this->_getOrderArticle();
        if ( $oArticle ) {
            return $oArticle->getBasketPrice( $dAmount, $aSelList, $oBasket );
        } else {
            return $this->getPrice();
        }
    }

    public function skipDiscounts()
    {
        return false;
    }

    public function getCategoryIds( $blActCats = false, $blSkipCache = false )
    {
        $aCatIds = array();
        if ( $oOrderArticle = $this->_getOrderArticle() ) {
            $aCatIds = $oOrderArticle->getCategoryIds( $blActCats, $blSkipCache );
        }
        return $aCatIds;
    }

    public function getLanguage()
    {
        return oxRegistry::getLang()->getBaseLanguage();
    }

    public function getBasePrice( $dAmount = 1 )
    {

        return $this->getPrice();
    }

    public function getPrice()
    {
        $oBasePrice = oxNew( 'oxPrice' );
        // prices in db are ONLY brutto
        $oBasePrice->setBruttoPriceMode();
        $oBasePrice->setVat( $this->oxorderarticles__oxvat->value );
        $oBasePrice->setPrice( $this->oxorderarticles__oxbprice->value );

        return $oBasePrice;
    }

    public function setIsNewOrderItem( $blIsNew )
    {
        $this->_blIsNewOrderItem = $blIsNew;
    }

    public function isNewOrderItem()
    {
        return $this->_blIsNewOrderItem;
    }

    public function setNewAmount( $iNewAmount )
    {
        if ( $iNewAmount >= 0 ) {
            // to update stock we must first check if it is possible - article exists?
            $oArticle = oxNew( "oxarticle" );
            if ( $oArticle->load( $this->oxorderarticles__oxartid->value ) ) {

                // updating stock info
                $iStockChange = $iNewAmount - $this->oxorderarticles__oxamount->value;
                if ( $iStockChange > 0 && ( $iOnStock = $oArticle->checkForStock( $iStockChange ) ) !== false ) {
                    if ( $iOnStock !== true ) {
                        $iStockChange = $iOnStock;
                        $iNewAmount   = $this->oxorderarticles__oxamount->value + $iStockChange;
                    }
                }

                $this->updateArticleStock( $iStockChange * -1, $this->getConfig()->getConfigParam( 'blAllowNegativeStock' ) );

                // updating self
                $this->oxorderarticles__oxamount = new oxField ( $iNewAmount, oxField::T_RAW );
                $this->save();
            }
        }
    }

    public function isOrderArticle()
    {
        return true;
    }


    public function cancelOrderArticle()
    {
        if ( $this->oxorderarticles__oxstorno->value == 0 ) {
            $myConfig = $this->getConfig();
            $this->oxorderarticles__oxstorno = new oxField( 1 );
            if ( $this->save() ) {
                $this->updateArticleStock( $this->oxorderarticles__oxamount->value, $myConfig->getConfigParam('blAllowNegativeStock') );
            }
        }
    }

    public function delete( $sOXID = null)
    {
        if ( $blDelete = parent::delete( $sOXID ) ) {
            $myConfig = $this->getConfig();
            if ( $this->oxorderarticles__oxstorno->value != 1 ) {
                $this->updateArticleStock( $this->oxorderarticles__oxamount->value, $myConfig->getConfigParam('blAllowNegativeStock') );
            }
        }
        return $blDelete;
    }

    public function save()
    {
        // ordered articles
        if ( ( $blSave = parent::save() ) && $this->isNewOrderItem() ) {
            $myConfig = $this->getConfig();
            if ( $myConfig->getConfigParam( 'blUseStock' ) &&
                 $myConfig->getConfigParam( 'blPsBasketReservationEnabled' ) ) {
                    $this->getSession()
                            ->getBasketReservations()
                            ->commitArticleReservation(
                                   $this->oxorderarticles__oxartid->value,
                                   $this->oxorderarticles__oxamount->value
                           );
            } else {
                $this->updateArticleStock( $this->oxorderarticles__oxamount->value * (-1), $myConfig->getConfigParam( 'blAllowNegativeStock' ) );
            }

            // seting downloadable products article files
            $this->_setOrderFiles();

            // marking object as "non new" disable further stock changes
            $this->setIsNewOrderItem( false );
        }

        return $blSave;
    }

    public function getWrapping()
    {
        if ($this->oxorderarticles__oxwrapid->value) {
            $oWrapping = oxNew('oxwrapping');
            if ($oWrapping->load($this->oxorderarticles__oxwrapid->value)) {
                return $oWrapping;
            }
        }
        return null;
    }

    public function isBundle()
    {
        return ( bool ) $this->oxorderarticles__oxisbundle->value;
    }

    public function getTotalBrutPriceFormated()
    {
        $oLang = oxRegistry::getLang();
        $oOrder = $this->getOrder();
        $oCurrency = $this->getConfig()->getCurrencyObject( $oOrder->oxorder__oxcurrency->value );
        return $oLang->formatCurrency( $this->oxorderarticles__oxbrutprice->value, $oCurrency );
    }

    public function getBrutPriceFormated()
    {
        $oLang = oxRegistry::getLang();
        $oOrder = $this->getOrder();
        $oCurrency = $this->getConfig()->getCurrencyObject( $oOrder->oxorder__oxcurrency->value );
        return $oLang->formatCurrency(  $this->oxorderarticles__oxbprice->value, $oCurrency );
    }

    public function getNetPriceFormated()
    {
        $oLang = oxRegistry::getLang();
        $oOrder = $this->getOrder();
        $oCurrency = $this->getConfig()->getCurrencyObject( $oOrder->oxorder__oxcurrency->value );
        return $oLang->formatCurrency(  $this->oxorderarticles__oxnprice->value, $oCurrency );
    }

    public function getOrder()
    {
        if ( $this->oxorderarticles__oxorderid->value ) {
            // checking if the object already exists in the cache
            if ( isset( $this->_aOrderCache[ $this->oxorderarticles__oxorderid->value ] )) {
                // returning the cached object
                return $this->_aOrderCache[ $this->oxorderarticles__oxorderid->value ];
            }
            // creatina new order object and trying to load it
            $oOrder = oxNew( 'oxOrder' );
            if ( $oOrder->load( $this->oxorderarticles__oxorderid->value )) {
                return $this->_aOrderCache[$this->oxorderarticles__oxorderid->value] = $oOrder;
            }
        }

        return null;
    }

    protected function _insert()
    {
        $iInsertTime = time();
        $now = date('Y-m-d H:i:s', $iInsertTime);
        $this->oxorderarticles__oxtimestamp = new oxField( $now );

        return parent::_insert();
    }


    public function setArticle( $oArticle )
    {
        $this->_oArticle = $oArticle;
    }

    public function getArticle()
    {
        if ( $this->_oArticle === null ) {
            $oArticle = oxNew( 'oxArticle' );
            $oArticle->load($this->oxorderarticles__oxartid->value);
            $this->_oArticle = $oArticle;
        }

        return $this->_oArticle;
    }



    public function _setOrderFiles()
    {
        $oArticle = $this->getArticle();

        if ( $oArticle->oxarticles__oxisdownloadable->value ) {

            $oConfig          = $this->getConfig();
            $sOrderId          = $this->oxorderarticles__oxorderid->value;
            $sOrderArticleId = $this->getId();
            $sShopId          = $oConfig->getShopId();

            $oUser             = $oConfig->getUser();

            $oFiles = $oArticle->getArticleFiles( true );

            if ( $oFiles ) {
                foreach ($oFiles as $oFile) {
                    $oOrderFile = oxNew( 'oxOrderFile' );
                    $oOrderFile->setOrderId( $sOrderId );
                    $oOrderFile->setOrderArticleId( $sOrderArticleId );
                    $oOrderFile->setShopId( $sShopId );
                    $iMaxDownloadCount = (!empty($oUser) && !$oUser->hasAccount()) ? $oFile->getMaxUnregisteredDownloadsCount() :  $oFile->getMaxDownloadsCount();
                    $oOrderFile->setFile(
                        $oFile->oxfiles__oxfilename->value,
                        $oFile->getId(),
                        $iMaxDownloadCount * $this->oxorderarticles__oxamount->value,
                        $oFile->getLinkExpirationTime(),
                        $oFile->getDownloadExpirationTime()
                    );

                    $oOrderFile->save();
                }
            }
        }
    }

    public function getTotalNetPriceFormated()
    {
        $oLang = oxRegistry::getLang();
        $oOrder = $this->getOrder();
        $oCurrency = $this->getConfig()->getCurrencyObject( $oOrder->oxorder__oxcurrency->value );
        return $oLang->formatCurrency( $this->oxorderarticles__oxnetprice->value, $oCurrency );
    }
}