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()
    {
        return $this->getParentId();
    }

    public function getParentId()
    {
        // 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");
            $oArticle->setLoadParentData(true);
            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;

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