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()
    {
        $oManager = oxNew( "oxTagCloud" );
        $oManager->setExtendedMode( true );
        $oManager->setProductId( $this->getProduct()->getId() );
        return $oManager;
    }

    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 = oxConfig::getParameter( '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();
            $sArtId = $oProduct->oxarticles__oxparentid->value?$oProduct->oxarticles__oxparentid->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();
        if ( isset( $oProduct->oxarticles__oxblfixedprice->value ) && $oProduct->oxarticles__oxblfixedprice->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() ) ) {
                $this->_dRatingValue = round( $oDetailsProduct->getArticleRatingAverage( $this->getConfig()->getConfigParam( 'blShowVariantReviews' ) ), 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() ) ) {
                $this->_iRatingCnt = $oDetailsProduct->getArticleRatingCount( $this->getConfig()->getConfigParam( 'blShowVariantReviews' ) );
            }
        }
        return $this->_iRatingCnt;
    }

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

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

            $aParams = oxConfig::getParameter( '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();
        if ( ( $oParent = $this->_getParentProduct( $oProduct->oxarticles__oxparentid->value ) ) ) {
            return $oParent->getVariantSelections( oxConfig::getParameter( "varselid" ), $oProduct->getId() );
        }

        return $oProduct->getVariantSelections( oxConfig::getParameter( "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 = oxConfig::getParameter( 'anid' );

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

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

                $aVariantSelections = $this->_oProduct->getVariantSelections( oxConfig::getParameter( "varselid" ) );
                if ($aVariantSelections && $aVariantSelections['oActiveVariant'] && $aVariantSelections['blPerfectFit']) {
                    $this->_oProduct = $aVariantSelections['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( 'alist', $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;
    }

}