oxwarticledetails.php

Go to the documentation of this file.

<?php

class oxwArticleDetails extends oxWidget
{

    protected $_aVariantList = null;
    protected $_aComponentNames = array('oxcmp_cur' => 1, 'oxcmp_shop' => 1, 'oxcmp_basket' => 1, 'oxcmp_user' => 1);

    protected $_sThisTemplate = 'widget/product/details.tpl';

    protected $_oParentProd = null;

    protected $_blCanRate = null;

    protected $_blCanEditTags = null;

    protected $_oCaptcha = null;

    protected $_aMediaFiles = null;

    protected $_aLastProducts = null;

    protected $_oVendor = null;

    protected $_oManufacturer = null;

    protected $_oCategory = null;

    protected $_aAttributes = null;

    protected $_aPicGallery = null;

    protected $_aReviews = null;

    protected $_oCrossSelling = null;

    protected $_oSimilarProducts = null;

    protected $_oAccessoires = null;

    protected $_aAlsoBoughtArts = null;

    protected $_sSearchTitle = null;

    protected $_blIsInitialized = false;

    protected $_iLinkType = null;

    protected $_blMdView = null;

    protected $_dRatingValue = null;

    protected $_iRatingCnt = null;

    protected $_sBidPrice = null;

    protected $_blShowSorting = true;

    protected $_aSimilarRecommListIds = null;


    public function getActZoomPic()
    {
        return 1;
    }

    protected function _getParentProduct($sParentId)
    {
        if ($sParentId && $this->_oParentProd === null) {
            $this->_oParentProd = false;
            $oProduct = oxNew('oxArticle');
            if (($oProduct->load($sParentId))) {
                $this->_processProduct($oProduct);
                $this->_oParentProd = $oProduct;
            }
        }

        return $this->_oParentProd;
    }

    protected function _getAddUrlParams()
    {
        if ($this->getListType() == "search") {
            return $this->getDynUrlParams();
        }
    }

    protected function _processProduct($oProduct)
    {
        $oProduct->setLinkType($this->getLinkType());
        if ($sAddParams = $this->_getAddUrlParams()) {
            $oProduct->appendLink($sAddParams);
        }
    }

    public function ratingIsActive()
    {
        return $this->getConfig()->getConfigParam('bl_perfLoadReviews');
    }

    public function canRate()
    {
        if ($this->_blCanRate === null) {

            $this->_blCanRate = false;

            if ($this->ratingIsActive() && $oUser = $this->getUser()) {

                $oRating = oxNew('oxrating');
                $this->_blCanRate = $oRating->allowRating($oUser->getId(), 'oxarticle', $this->getProduct()->getId());
            }
        }

        return $this->_blCanRate;
    }

    public function canChangeTags()
    {
        if ($oUser = $this->getUser()) {

            return true;
        }

        return false;
    }

    public function getAttributes()
    {
        if ($this->_aAttributes === null) {
            // all attributes this article has
            $aArtAttributes = $this->getProduct()->getAttributes();

            //making a new array for backward compatibility
            $this->_aAttributes = false;

            if (count($aArtAttributes)) {
                foreach ($aArtAttributes as $sKey => $oAttribute) {
                    $this->_aAttributes[$sKey] = new stdClass();
                    $this->_aAttributes[$sKey]->title = $oAttribute->oxattribute__oxtitle->value;
                    $this->_aAttributes[$sKey]->value = $oAttribute->oxattribute__oxvalue->value;
                }
            }
        }

        return $this->_aAttributes;
    }

    public function getTagCloudManager()
    {
        $oTagList = oxNew("oxArticleTagList");
        //$oTagList->load($this->getProduct()->getId());
        $oTagList->setArticleId($this->getProduct()->getId());
        $oTagCloud = oxNew("oxTagCloud");
        $oTagCloud->setTagList($oTagList);
        $oTagCloud->setExtendedMode(true);

        return $oTagCloud;
    }

    public function isEditableTags()
    {
        if ($this->_blCanEditTags === null) {
            $this->_blCanEditTags = false;
            if ($this->getProduct() && $this->getUser()) {
                $this->_blCanEditTags = true;
            }
        }

        return $this->_blCanEditTags;
    }

    public function getLinkType()
    {
        if ($this->_iLinkType === null) {
            $sListType = oxRegistry::getConfig()->getRequestParameter('listtype');
            if ('vendor' == $sListType) {
                $this->_iLinkType = OXARTICLE_LINKTYPE_VENDOR;
            } elseif ('manufacturer' == $sListType) {
                $this->_iLinkType = OXARTICLE_LINKTYPE_MANUFACTURER;
            } elseif ('tag' == $sListType) {
                $this->_iLinkType = OXARTICLE_LINKTYPE_TAG;
            } elseif ('recommlist' == $sListType) {
                $this->_iLinkType = OXARTICLE_LINKTYPE_RECOMM;
            } else {
                $this->_iLinkType = OXARTICLE_LINKTYPE_CATEGORY;

                // price category has own type..
                if (($oCat = $this->getActiveCategory()) && $oCat->isPriceCategory()) {
                    $this->_iLinkType = OXARTICLE_LINKTYPE_PRICECATEGORY;
                }
            }
        }

        return $this->_iLinkType;
    }

    public function getVariantListExceptCurrent()
    {
        $oList = $this->getVariantList();
        if (is_object($oList)) {
            $oList = clone $oList;
        }

        $sOxId = $this->getProduct()->getId();
        if (isset($oList[$sOxId])) {
            unset($oList[$sOxId]);
        }

        return $oList;
    }

    public function loadVariantInformation()
    {
        if ($this->_aVariantList === null) {
            $oProduct = $this->getProduct();

            //if we are child and do not have any variants then let's load all parent variants as ours
            if ($oParent = $oProduct->getParentArticle()) {
                $myConfig = $this->getConfig();

                $oParent->setNoVariantLoading(false);
                $this->_aVariantList = $oParent->getFullVariants(false);

                //lets additionally add parent article if it is sellable
                if (count($this->_aVariantList) && $myConfig->getConfigParam('blVariantParentBuyable')) {
                    //#1104S if parent is buyable load select lists too
                    $oParent->enablePriceLoad();
                    $oParent->aSelectlist = $oParent->getSelectLists();
                    $this->_aVariantList = array_merge(array($oParent), $this->_aVariantList->getArray());
                }
            } else {
                //loading full list of variants
                $this->_aVariantList = $oProduct->getFullVariants(false);
            }

            // setting link type for variants ..
            foreach ($this->_aVariantList as $oVariant) {
                $this->_processProduct($oVariant);
            }

        }

        return $this->_aVariantList;
    }


    public function getVariantList()
    {
        return $this->loadVariantInformation();
    }

    public function getCaptcha()
    {
        if ($this->_oCaptcha === null) {
            $this->_oCaptcha = oxNew('oxCaptcha');
        }

        return $this->_oCaptcha;
    }

    public function getMediaFiles()
    {
        if ($this->_aMediaFiles === null) {
            $aMediaFiles = $this->getProduct()->getMediaUrls();
            $this->_aMediaFiles = count($aMediaFiles) ? $aMediaFiles : false;
        }

        return $this->_aMediaFiles;
    }

    public function getLastProducts($iCnt = 4)
    {
        if ($this->_aLastProducts === null) {
            //last seen products for #768CA
            $oProduct = $this->getProduct();
            $sParentIdField = 'oxarticles__oxparentid';
            $sArtId = $oProduct->$sParentIdField->value ? $oProduct->$sParentIdField->value : $oProduct->getId();

            $oHistoryArtList = oxNew('oxArticleList');
            $oHistoryArtList->loadHistoryArticles($sArtId, $iCnt);
            $this->_aLastProducts = $oHistoryArtList;
        }

        return $this->_aLastProducts;
    }

    public function getManufacturer()
    {
        if ($this->_oManufacturer === null) {
            $this->_oManufacturer = $this->getProduct()->getManufacturer(false);
        }

        return $this->_oManufacturer;
    }

    public function getVendor()
    {
        if ($this->_oVendor === null) {
            $this->_oVendor = $this->getProduct()->getVendor(false);
        }

        return $this->_oVendor;
    }

    public function getCategory()
    {
        if ($this->_oCategory === null) {
            $this->_oCategory = $this->getProduct()->getCategory();
        }

        return $this->_oCategory;
    }

    public function getPictureGallery()
    {
        if ($this->_aPicGallery === null) {
            //get picture gallery
            $this->_aPicGallery = $this->getPicturesProduct()->getPictureGallery();
        }

        return $this->_aPicGallery;
    }

    public function getActPicture()
    {
        $aPicGallery = $this->getPictureGallery();

        return $aPicGallery['ActPic'];
    }

    public function morePics()
    {
        $aPicGallery = $this->getPictureGallery();

        return $aPicGallery['MorePics'];
    }

    public function getIcons()
    {
        $aPicGallery = $this->getPictureGallery();

        return $aPicGallery['Icons'];
    }

    public function showZoomPics()
    {
        $aPicGallery = $this->getPictureGallery();

        return $aPicGallery['ZoomPic'];
    }

    public function getZoomPics()
    {
        $aPicGallery = $this->getPictureGallery();

        return $aPicGallery['ZoomPics'];
    }

    public function getReviews()
    {
        if ($this->_aReviews === null) {
            $this->_aReviews = false;
            if ($this->getConfig()->getConfigParam('bl_perfLoadReviews')) {
                $this->_aReviews = $this->getProduct()->getReviews();
            }
        }

        return $this->_aReviews;
    }

    public function getCrossSelling()
    {
        if ($this->_oCrossSelling === null) {
            $this->_oCrossSelling = false;
            if ($oProduct = $this->getProduct()) {
                $this->_oCrossSelling = $oProduct->getCrossSelling();
            }
        }

        return $this->_oCrossSelling;
    }

    public function getSimilarProducts()
    {
        if ($this->_oSimilarProducts === null) {
            $this->_oSimilarProducts = false;
            if ($oProduct = $this->getProduct()) {
                $this->_oSimilarProducts = $oProduct->getSimilarProducts();
            }
        }

        return $this->_oSimilarProducts;
    }

    public function getSimilarRecommListIds()
    {
        if ($this->_aSimilarRecommListIds === null) {
            $this->_aSimilarRecommListIds = false;

            if ($oProduct = $this->getProduct()) {
                $this->_aSimilarRecommListIds = array($oProduct->getId());
            }
        }

        return $this->_aSimilarRecommListIds;
    }

    public function getAccessoires()
    {
        if ($this->_oAccessoires === null) {
            $this->_oAccessoires = false;
            if ($oProduct = $this->getProduct()) {
                $this->_oAccessoires = $oProduct->getAccessoires();
            }
        }

        return $this->_oAccessoires;
    }

    public function getAlsoBoughtTheseProducts()
    {
        if ($this->_aAlsoBoughtArts === null) {
            $this->_aAlsoBoughtArts = false;
            if ($oProduct = $this->getProduct()) {
                $this->_aAlsoBoughtArts = $oProduct->getCustomerAlsoBoughtThisProducts();
            }
        }

        return $this->_aAlsoBoughtArts;
    }

    public function isPriceAlarm()
    {
        // #419 disabling price alarm if article has fixed price
        $oProduct = $this->getProduct();
        $sFixedPriceField = 'oxarticles__oxblfixedprice';
        if (isset($oProduct->$sFixedPriceField->value) && $oProduct->$sFixedPriceField->value) {
            return 0;
        }

        return 1;
    }

    protected function _getSubject($iLang)
    {
        return $this->getProduct();
    }

    public function getSearchTitle()
    {
        return $this->_sSearchTitle;
    }

    public function setSearchTitle($sTitle)
    {
        $this->_sSearchTitle = $sTitle;
    }

    public function setCatTreePath($sActCatPath)
    {
        $this->_sCatTreePath = $sActCatPath;
    }

    public function isPersParam()
    {
        $oProduct = $this->getProduct();

        return $oProduct->oxarticles__oxisconfigurable->value;
    }

    public function getRatingValue()
    {

        if ($this->_dRatingValue === null) {
            $this->_dRatingValue = (double) 0;
            if ($this->isReviewActive() && ($oDetailsProduct = $this->getProduct())) {
                $blShowVariantsReviews = $this->getConfig()->getConfigParam('blShowVariantReviews');
                $this->_dRatingValue = round($oDetailsProduct->getArticleRatingAverage($blShowVariantsReviews), 1);
            }
        }

        return (double) $this->_dRatingValue;
    }

    public function isReviewActive()
    {
        return $this->getConfig()->getConfigParam('bl_perfLoadReviews');
    }

    public function getRatingCount()
    {
        if ($this->_iRatingCnt === null) {
            $this->_iRatingCnt = false;
            if ($this->isReviewActive() && ($oDetailsProduct = $this->getProduct())) {
                $blShowVariantsReviews = $this->getConfig()->getConfigParam('blShowVariantReviews');
                $this->_iRatingCnt = $oDetailsProduct->getArticleRatingCount($blShowVariantsReviews);
            }
        }

        return $this->_iRatingCnt;
    }

    public function getPriceAlarmStatus()
    {
        return $this->getViewParameter('iPriceAlarmStatus');
    }

    public function getBidPrice()
    {
        if ($this->_sBidPrice === null) {
            $this->_sBidPrice = false;

            $aParams = oxRegistry::getConfig()->getRequestParameter('pa');
            $oCur = $this->getConfig()->getActShopCurrencyObject();
            $iPrice = oxRegistry::getUtils()->currency2Float($aParams['price']);
            $this->_sBidPrice = oxRegistry::getLang()->formatCurrency($iPrice, $oCur);
        }

        return $this->_sBidPrice;
    }

    public function getVariantSelections()
    {
        // finding parent
        $oProduct = $this->getProduct();
        $sParentIdField = 'oxarticles__oxparentid';
        if (($oParent = $this->_getParentProduct($oProduct->$sParentIdField->value))) {
            $sVarSelId = oxRegistry::getConfig()->getRequestParameter("varselid");
            return $oParent->getVariantSelections($sVarSelId, $oProduct->getId());
        }

        return $oProduct->getVariantSelections(oxRegistry::getConfig()->getRequestParameter("varselid"));
    }

    public function getPicturesProduct()
    {
        $aVariantSelections = $this->getVariantSelections();
        if ($aVariantSelections && $aVariantSelections['oActiveVariant'] && !$aVariantSelections['blPerfectFit']) {
            return $aVariantSelections['oActiveVariant'];
        }

        return $this->getProduct();
    }

    public function getProduct()
    {
        $myConfig = $this->getConfig();
        $myUtils = oxRegistry::getUtils();

        if ($this->_oProduct === null) {

            if ($this->getViewParameter('_object')) {
                $this->_oProduct = $this->getViewParameter('_object');
            } else {
                //this option is only for lists and we must reset value
                //as blLoadVariants = false affect "ab price" functionality
                $myConfig->setConfigParam('blLoadVariants', true);

                $sOxid = oxRegistry::getConfig()->getRequestParameter('anid');

                // object is not yet loaded
                $this->_oProduct = oxNew('oxarticle');

                if (!$this->_oProduct->load($sOxid)) {
                    $myUtils->redirect($myConfig->getShopHomeURL());
                    $myUtils->showMessageAndExit('');
                }

                $sVarSelId = oxRegistry::getConfig()->getRequestParameter("varselid");
                $aVarSelections = $this->_oProduct->getVariantSelections($sVarSelId);
                if ($aVarSelections && $aVarSelections['oActiveVariant'] && $aVarSelections['blPerfectFit']) {
                    $this->_oProduct = $aVarSelections['oActiveVariant'];
                }
            }
        }
        if (!$this->_blIsInitialized) {
            $this->_additionalChecksForArticle($myUtils, $myConfig);
        }

        return $this->_oProduct;
    }

    protected function _setSortingParameters()
    {
        $sSortingParameters = $this->getViewParameter('sorting');
        if ($sSortingParameters) {
            list($sSortBy, $sSortDir) = explode('|', $sSortingParameters);
            $this->setItemSorting($this->getSortIdent(), $sSortBy, $sSortDir);
        }
    }

    public function render()
    {
        $oProduct = $this->getProduct();

        parent::render();

        $oCategory = oxNew('oxCategory');

        // if category parameter is not found, use category from product
        $sCatId = $this->getViewParameter("cnid");

        if (!$sCatId && $oProduct->getCategory()) {
            $oCategory = $oProduct->getCategory();
        } else {
            $oCategory->load($sCatId);
        }
        $this->_setSortingParameters();

        $this->setActiveCategory($oCategory);

        $oLocator = oxNew('oxLocator', $this->getListType());
        $oLocator->setLocatorData($oProduct, $this);

        return $this->_sThisTemplate;

    }

    public function isMdVariantView()
    {
        if ($this->_blMdView === null) {
            $this->_blMdView = false;
            if ($this->getConfig()->getConfigParam('blUseMultidimensionVariants')) {
                $iMaxMdDepth = $this->getProduct()->getMdVariants()->getMaxDepth();
                $this->_blMdView = ($iMaxMdDepth > 1);
            }
        }

        return $this->_blMdView;
    }

    public function getTagSeparator()
    {
        $sSeparator = $this->getConfig()->getConfigParam("sTagSeparator");

        return $sSeparator;
    }

    protected function _additionalChecksForArticle($myUtils, $myConfig)
    {
        $blContinue = true;
        if (!$this->_oProduct->isVisible()) {
            $blContinue = false;
        } elseif ($this->_oProduct->oxarticles__oxparentid->value) {
            $oParent = $this->_getParentProduct($this->_oProduct->oxarticles__oxparentid->value);
            if (!$oParent || !$oParent->isVisible()) {
                $blContinue = false;
            }
        }

        if (!$blContinue) {
            $myUtils->redirect($myConfig->getShopHomeURL());
            $myUtils->showMessageAndExit('');
        }

        $this->_processProduct($this->_oProduct);
        $this->_blIsInitialized = true;
    }

    public function getDefaultSorting()
    {
        $aSorting = parent::getDefaultSorting();

        $oCategory = $this->getActiveCategory();

        if ($this->getListType() != 'search' && $oCategory && $oCategory instanceof oxCategory) {
            if ($sSortBy = $oCategory->getDefaultSorting()) {
                $sSortDir = ($oCategory->getDefaultSortingMode()) ? "desc" : "asc";
                $aSorting = array('sortby' => $sSortBy, 'sortdir' => $sSortDir);
            }
        }

        return $aSorting;
    }
}