oxbasketitem.php

Go to the documentation of this file.

<?php

class oxBasketItem extends oxSuperCfg
{

    protected $_sProductId = null;

    protected $_sTitle = null;

    protected $_sVarSelect = null;

    protected $_sIcon = null;

    protected $_sLink = null;

    protected $_oPrice = null;

    protected $_oUnitPrice = null;

    protected $_dAmount = 0.0;

    protected $_dWeight = 0;

    protected $_aSelList = array();

    protected $_sShopId = null;

    protected $_sNativeShopId = null;

    protected $_blSkipDiscounts = false;

    protected $_aPersistentParameters = array();

    protected $_blBundle = false;

    protected $_blIsDiscountArticle = false;

    protected $_oArticle = null;

    protected $_sDimageDirNoSsl = null;

    protected $_sDimageDirSsl = null;

    protected $_aChosenSelectlist = array();

    protected $_sWrappingId = null;

    protected $_sWishId = null;

    protected $_sWishArticleId = null;

    protected $_blCheckArticleStock = true;


    protected $_iLanguageId = null;

    protected $_blSsl = null;

    protected $_sIconUrl = null;


    protected $_oRegularUnitPrice = null;

    protected $basketItemKey = null;

    public function getBasketItemKey()
    {
        return $this->basketItemKey;
    }

    public function setBasketItemKey($itemKey)
    {
        $this->basketItemKey = $itemKey;
    }

    public function getRegularUnitPrice()
    {
        return $this->_oRegularUnitPrice;
    }

    public function setRegularUnitPrice($oRegularUnitPrice)
    {
        $this->_oRegularUnitPrice = $oRegularUnitPrice;
    }


    public function init($sProductID, $dAmount, $aSel = null, $aPersParam = null, $blBundle = null)
    {
        $this->_setArticle($sProductID);
        $this->setAmount($dAmount);
        $this->_setSelectList($aSel);
        $this->setPersParams($aPersParam);
        $this->setBundle($blBundle);
        $this->setLanguageId(oxRegistry::getLang()->getBaseLanguage());
    }

    public function initFromOrderArticle($oOrderArticle)
    {
        $this->_setFromOrderArticle($oOrderArticle);
        $this->setAmount($oOrderArticle->oxorderarticles__oxamount->value);
        $this->_setSelectList($oOrderArticle->getOrderArticleSelectList());
        $this->setPersParams($oOrderArticle->getPersParams());
        $this->setBundle($oOrderArticle->isBundle());
    }

    public function setAsDiscountArticle($blIsDiscountArticle)
    {
        $this->_blIsDiscountArticle = $blIsDiscountArticle;
    }

    public function setStockCheckStatus($blStatus)
    {
        $this->_blCheckArticleStock = $blStatus;
    }

    public function getStockCheckStatus()
    {
        return $this->_blCheckArticleStock;
    }

    public function setAmount($dAmount, $blOverride = true, $sItemKey = null)
    {
        try {
            //validating amount
            $dAmount = oxRegistry::get("oxInputValidator")->validateBasketAmount($dAmount);
        } catch (oxArticleInputException $oEx) {
            $oEx->setArticleNr($this->getProductId());
            $oEx->setProductId($this->getProductId());
            // setting additional information for exception and then rethrowing
            throw $oEx;
        }

        $oArticle = $this->getArticle(true);


        // setting default
        $iOnStock = true;

        if ($blOverride) {
            $this->_dAmount = $dAmount;
        } else {
            $this->_dAmount += $dAmount;
        }

        // checking for stock
        if ($this->getStockCheckStatus() == true) {
            $dArtStockAmount = $this->getSession()->getBasket()->getArtStockInBasket($oArticle->getId(), $sItemKey);
            $selectForUpdate = false;
            if ($this->getConfig()->getConfigParam('blPsBasketReservationEnabled')) {
                $selectForUpdate = true;
            }
            $iOnStock = $oArticle->checkForStock($this->_dAmount, $dArtStockAmount, $selectForUpdate);
            if ($iOnStock !== true) {
                if ($iOnStock === false) {
                    // no stock !
                    $this->_dAmount = 0;
                } else {
                    // limited stock
                    $this->_dAmount = $iOnStock;
                    $blOverride = true;
                }
            }
        }

        // calculating general weight
        $this->_dWeight = $oArticle->oxarticles__oxweight->value * $this->_dAmount;

        if ($iOnStock !== true) {
            $oEx = oxNew('oxOutOfStockException');
            $oEx->setMessage('ERROR_MESSAGE_OUTOFSTOCK_OUTOFSTOCK');
            $oEx->setArticleNr($oArticle->oxarticles__oxartnum->value);
            $oEx->setProductId($oArticle->getProductId());
            $oEx->setRemainingAmount($this->_dAmount);
            $oEx->setBasketIndex($sItemKey);
            throw $oEx;
        }
    }

    public function setPrice($oPrice)
    {
        $this->_oUnitPrice = clone $oPrice;

        $this->_oPrice = clone $oPrice;
        $this->_oPrice->multiply($this->getAmount());
    }

    public function getIconUrl()
    {
        // icon url must be (re)loaded in case icon is not set or shop was switched between ssl/nonssl
        if ($this->_sIconUrl === null || $this->_blSsl != $this->getConfig()->isSsl()) {
            $this->_sIconUrl = $this->getArticle()->getIconUrl();
        }

        return $this->_sIconUrl;
    }

    public function getArticle($blCheckProduct = false, $sProductId = null, $blDisableLazyLoading = false)
    {
        if ($this->_oArticle === null || (!$this->_oArticle->isOrderArticle() && $blDisableLazyLoading)) {
            $sProductId = $sProductId ? $sProductId : $this->_sProductId;
            if (!$sProductId) {
                //this exception may not be caught, anyhow this is a critical exception
                $oEx = oxNew('oxArticleException');
                $oEx->setMessage('EXCEPTION_ARTICLE_NOPRODUCTID');
                throw $oEx;
            }

            $this->_oArticle = oxNew('oxarticle');
            // #M773 Do not use article lazy loading on order save
            if ($blDisableLazyLoading) {
                $this->_oArticle->modifyCacheKey('_allviews');
                $this->_oArticle->disableLazyLoading();
            }

            // performance:
            // - skipping variants loading
            // - skipping 'ab' price info
            // - load parent field
            $this->_oArticle->setNoVariantLoading(true);
            $this->_oArticle->setLoadParentData(true);
            if (!$this->_oArticle->load($sProductId)) {
                $oEx = oxNew('oxNoArticleException');
                $oLang = oxRegistry::getLang();
                $oEx->setMessage(sprintf($oLang->translateString('ERROR_MESSAGE_ARTICLE_ARTICLE_DOES_NOT_EXIST', $oLang->getBaseLanguage()), $sProductId));
                $oEx->setArticleNr($sProductId);
                $oEx->setProductId($sProductId);
                throw $oEx;
            }

            // cant put not visible product to basket (M:1286)
            if ($blCheckProduct && !$this->_oArticle->isVisible()) {
                $oEx = oxNew('oxNoArticleException');
                $oLang = oxRegistry::getLang();
                $oEx->setMessage(sprintf($oLang->translateString('ERROR_MESSAGE_ARTICLE_ARTICLE_DOES_NOT_EXIST', $oLang->getBaseLanguage()), $this->_oArticle->oxarticles__oxartnum->value));
                $oEx->setArticleNr($sProductId);
                $oEx->setProductId($sProductId);
                throw $oEx;
            }

            // cant put not buyable product to basket
            if ($blCheckProduct && !$this->_oArticle->isBuyable()) {
                $oEx = oxNew('oxArticleInputException');
                $oEx->setMessage('ERROR_MESSAGE_ARTICLE_ARTICLE_NOT_BUYABLE');
                $oEx->setArticleNr($sProductId);
                $oEx->setProductId($sProductId);
                throw $oEx;
            }
        }

        return $this->_oArticle;
    }

    public function getdBundledAmount()
    {
        return $this->isBundle() ? $this->_dAmount : 0;
    }

    public function getPrice()
    {
        return $this->_oPrice;
    }

    public function getUnitPrice()
    {
        return $this->_oUnitPrice;
    }

    public function getAmount()
    {
        return $this->_dAmount;
    }

    public function getWeight()
    {
        return $this->_dWeight;
    }

    public function getTitle()
    {
        if ($this->_sTitle === null || $this->getLanguageId() != oxRegistry::getLang()->getBaseLanguage()) {

            $oArticle = $this->getArticle();
            $this->_sTitle = $oArticle->oxarticles__oxtitle->value;

            if ($oArticle->oxarticles__oxvarselect->value) {
                $this->_sTitle = $this->_sTitle . ', ' . $this->getVarSelect();
            }
        }

        return $this->_sTitle;
    }

    public function getLink()
    {
        if ($this->_sLink === null || $this->getLanguageId() != oxRegistry::getLang()->getBaseLanguage()) {
            $this->_sLink = oxRegistry::get("oxUtilsUrl")->cleanUrl($this->getArticle()->getLink(), array('force_sid'));
        }

        return $this->getSession()->processUrl($this->_sLink);
    }

    public function getShopId()
    {
        return $this->_sShopId;
    }

    public function getSelList()
    {
        return $this->_aSelList;
    }

    public function getChosenSelList()
    {
        return $this->_aChosenSelectlist;
    }

    public function isBundle()
    {
        return $this->_blBundle;
    }

    public function isDiscountArticle()
    {
        return $this->_blIsDiscountArticle;
    }

    public function isSkipDiscount()
    {
        return $this->_blSkipDiscounts;
    }

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

    public function __sleep()
    {
        $aRet = array();
        foreach (get_object_vars($this) as $sKey => $sVar) {
            if ($sKey != '_oArticle') {
                $aRet[] = $sKey;
            }
        }

        return $aRet;
    }

    protected function _setArticle($sProductId)
    {
        $oConfig = $this->getConfig();
        $oArticle = $this->getArticle(true, $sProductId);

        // product ID
        $this->_sProductId = $sProductId;

        $this->_sTitle = null;
        $this->_sVarSelect = null;
        $this->getTitle();

        // icon and details URL's
        $this->_sIcon = $oArticle->oxarticles__oxicon->value;
        $this->_sIconUrl = $oArticle->getIconUrl();
        $this->_blSsl = $oConfig->isSsl();

        // removing force_sid from the link (in case it'll change)
        $this->_sLink = oxRegistry::get("oxUtilsUrl")->cleanUrl($oArticle->getLink(), array('force_sid'));

        // shop Ids
        $this->_sShopId = $oConfig->getShopId();
        $this->_sNativeShopId = $oArticle->oxarticles__oxshopid->value;

        // SSL/NON SSL image paths
        $this->_sDimageDirNoSsl = $oArticle->nossl_dimagedir;
        $this->_sDimageDirSsl = $oArticle->ssl_dimagedir;
    }

    protected function _setFromOrderArticle($oOrderArticle)
    {
        // overriding whole article
        $this->_oArticle = $oOrderArticle;

        // product ID
        $this->_sProductId = $oOrderArticle->getProductId();

        // products title
        $this->_sTitle = $oOrderArticle->oxarticles__oxtitle->value;

        // shop Ids
        $this->_sShopId = $this->getConfig()->getShopId();
        $this->_sNativeShopId = $oOrderArticle->oxarticles__oxshopid->value;
    }

    protected function _setSelectList($aSelList)
    {
        // checking for default select list
        $aSelectLists = $this->getArticle()->getSelectLists();
        if (!$aSelList || is_array($aSelList) && count($aSelList) == 0) {
            if ($iSelCnt = count($aSelectLists)) {
                $aSelList = array_fill(0, $iSelCnt, '0');
            }
        }

        $this->_aSelList = $aSelList;

        //
        if (count($this->_aSelList) && is_array($this->_aSelList)) {
            foreach ($this->_aSelList as $conkey => $iSel) {
                $this->_aChosenSelectlist[$conkey] = new stdClass();
                $this->_aChosenSelectlist[$conkey]->name = $aSelectLists[$conkey]['name'];
                $this->_aChosenSelectlist[$conkey]->value = $aSelectLists[$conkey][$iSel]->name;
            }
        }
    }

    public function getPersParams()
    {
        return $this->_aPersistentParameters;
    }

    public function setPersParams($aPersParam)
    {
        $this->_aPersistentParameters = $aPersParam;
    }

    public function setBundle($blBundle)
    {
        $this->_blBundle = $blBundle;
    }

    public function setSkipDiscounts($blSkip)
    {
        $this->_blSkipDiscounts = $blSkip;
    }

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

    public function setWrapping($sWrapId)
    {
        $this->_sWrappingId = $sWrapId;
    }

    public function getWrappingId()
    {
        return $this->_sWrappingId;
    }

    public function getWrapping()
    {
        $oWrap = null;
        if ($sWrapId = $this->getWrappingId()) {
            $oWrap = oxNew('oxwrapping');
            $oWrap->load($sWrapId);
        }

        return $oWrap;
    }

    public function getWishId()
    {
        return $this->_sWishId;
    }

    public function setWishId($sWishId)
    {
        $this->_sWishId = $sWishId;
    }

    public function setWishArticleId($sArticleId)
    {
        $this->_sWishArticleId = $sArticleId;
    }

    public function getWishArticleId()
    {
        return $this->_sWishArticleId;
    }

    public function getFRegularUnitPrice()
    {
        return oxRegistry::getLang()->formatCurrency($this->getRegularUnitPrice()->getPrice());
    }

    public function getFUnitPrice()
    {
        return oxRegistry::getLang()->formatCurrency($this->getUnitPrice()->getPrice());
    }

    public function getFTotalPrice()
    {
        return oxRegistry::getLang()->formatCurrency($this->getPrice()->getPrice());
    }

    public function getVatPercent()
    {
        return oxRegistry::getLang()->formatVat($this->getPrice()->getVat());
    }

    public function getVarSelect()
    {
        if ($this->_sVarSelect === null || $this->getLanguageId() != oxRegistry::getLang()->getBaseLanguage()) {
            $oArticle = $this->getArticle();
            $sVarSelectValue = $oArticle->oxarticles__oxvarselect->value;
            $this->_sVarSelect = (!empty($sVarSelectValue) || $sVarSelectValue === '0') ? $sVarSelectValue : '';
        }

        return $this->_sVarSelect;
    }

    public function getLanguageId()
    {
        return $this->_iLanguageId;
    }

    public function setLanguageId($iLanguageId)
    {
        $iOldLang = $this->_iLanguageId;
        $this->_iLanguageId = $iLanguageId;

        // #0003777: reload content on language change
        if ($iOldLang !== null && $iOldLang != $iLanguageId) {
            try {
                $this->_setArticle($this->getProductId());
            } catch (oxNoArticleException $oEx) {
                oxRegistry::get("oxUtilsView")->addErrorToDisplay($oEx);
            } catch (oxArticleInputException $oEx) {
                oxRegistry::get("oxUtilsView")->addErrorToDisplay($oEx);
            }
        }
    }
}