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;


    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 excp 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 );
            $iOnStock = $oArticle->checkForStock( $this->_dAmount, $dArtStockAmount );
            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 excpetion 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( );
            $this->_sVarSelect = $oArticle->oxarticles__oxvarselect->value ? $oArticle->oxarticles__oxvarselect->value : '';
        }

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