details.php

Go to the documentation of this file.

<?php

class Details extends oxUBase
{
    protected $_aVariantList = null;

    protected $_sThisTemplate = 'details.tpl';

    protected $_oParent = null;

    protected $_blCanRate = null;

    protected $_blShowSorting = true;

    protected $_blEditTags = null;

    protected $_aTags = null;

    protected $_sTagCloud = null;

    protected $_aUserRecommList = null;

    protected $_sLoginFormAnchor = null;

    protected $_oCaptcha = null;

    protected $_aMediaFiles = null;

    protected $_aLastProducts = null;

    protected $_oVendor = null;

    protected $_oManufacturer = null;

    protected $_oCategory = null;

    protected $_aAttributes = null;

    protected $_sParentName = null;

    protected $_sParentUrl = null;

    protected $_aPicGallery = null;

    protected $_aSelectLists = null;

    protected $_aReviews = null;

    protected $_oCrossSelling = null;

    protected $_oSimilarProducts = null;

    protected $_oRecommList = null;

    protected $_oAccessoires = null;

    protected $_aAlsoBoughtArts = null;

    protected $_sSearchTitle = null;

    protected $_blIsInitialized = false;

    protected $_iLinkType = null;

    protected function _getParentProduct( $sParentId )
    {
        if ( $sParentId && $this->_oParent === null ) {
            $this->_oParent = false;
            if ( ( $oParent = oxNewArticle( $sParentId ) ) ) {
                $this->_processProduct( $oParent );
                $this->_oParent = $oParent;
            }
        }
        return $this->_oParent;
    }

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

            //loading full list of variants
            $this->_aVariantList = $oProduct->getVariants( false );

            //if we are child and do not have any variants then please load all parent variants as ours
            if ( ( $oParent = $this->_getParentProduct( $oProduct->oxarticles__oxparentid->value ) ) && count( $this->_aVariantList ) == 0 ) {
                $myConfig = $this->getConfig();

                $this->_aVariantList = $oParent->getVariants( false );

                //in variant list parent may be NOT buyable
                if ( $oParent->blNotBuyableParent ) {
                    $oParent->blNotBuyable = true;
                }

                //lets additionally add parent article if it is sellable
                if ( $myConfig->getConfigParam( 'blVariantParentBuyable' ) ) {
                    //#1104S if parent is buyable load selectlists too
                    $oParent->aSelectlist = $oParent->getSelectLists();
                    $this->_aVariantList = array_merge( array( $oParent ), $this->_aVariantList->getArray() );
                }

                //..and skip myself from the list
                if ( isset( $this->_aVariantList[$oProduct->getId()] ) ) {
                    unset( $this->_aVariantList[$oProduct->getId()] );
                }
            }

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

        }
        return $this->_aVariantList;
    }

    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 getViewId()
    {
        if ( isset( $this->_sViewId )) {
            return $this->_sViewId;
        }

            $sViewId = parent::getViewId().'|'.oxConfig::getParameter( 'anid' ).'|'.count( $this->getVariantList() ).'|';


        return $this->_sViewId = $sViewId;
    }


    public function init()
    {
        parent::init();

        $oProduct = $this->getProduct();

        // assign template name
        if ( $oProduct->oxarticles__oxtemplate->value ) {
            $this->_sThisTemplate = $oProduct->oxarticles__oxtemplate->value;
        }

        if ( ( $sTplName = oxConfig::getParameter( 'tpl' ) ) ) {
            $this->_sThisTemplate = basename ( $sTplName );
        }
    }

    public function render()
    {
        $myConfig = $this->getConfig();

        $oProduct = $this->getProduct();

        //loading amount price list
        $oProduct->loadAmountPriceInfo();

        // Passing to view. Left for compatibility reasons for a while. Will be removed in future
        $this->_aViewData['product'] = $oProduct;

        $this->_aViewData["aTags"]      = $this->getTags();
        $this->_aViewData["blEditTags"] = $this->getEditTags();
        startProfile("tagCloud");
        $this->_aViewData['tagCloud']   = $this->getTagCloud();
        stopProfile("tagCloud");

        $this->_aViewData['loginformanchor'] = $this->getLoginFormAnchor();

        $this->_aViewData['ispricealarm'] = $this->isPriceAlarm();

        $this->_aViewData['customerwho']    = $this->getAlsoBoughtThiesProducts();
        $this->_aViewData['accessoirelist'] = $this->getAccessoires();
        $this->_aViewData['similarlist']    = $this->getSimilarProducts();
        $this->_aViewData['crossselllist']  = $this->getCrossSelling();

        $this->_aViewData['variants'] = $this->getVariantList();

        $this->_aViewData['reviews'] = $this->getReviews();

        $this->_aViewData['selectlist'] = $this->getSelectLists();

        $this->_aViewData["actpicid"]  = $this->getActPictureId();
        $this->_aViewData["actpic"]    = $this->getActPicture();
        $this->_aViewData['blMorePic'] = $this->morePics();
        $this->_aViewData['ArtPics']   = $this->getPictures();
        $this->_aViewData['ArtIcons']  = $this->getIcons();
        $this->_aViewData['blZoomPic'] = $this->showZoomPics();
        $this->_aViewData['aZoomPics'] = $this->getZoomPics();
        $this->_aViewData['iZoomPic']  = $this->getActZoomPic();

        $this->_aViewData['parentname']      = $this->getParentName();
        $this->_aViewData['parent_url']      = $this->getParentUrl();
        $this->_aViewData['draw_parent_url'] = $this->drawParentUrl();

        $this->_aViewData['pgNr'] = $this->getActPage();

        parent::render();

        $this->_aViewData['allartattr'] = $this->getAttributes();

        // #1102C
        $this->_aViewData['oCategory'] = $this->getCategory();

        $this->_aViewData['oVendor'] = $this->getVendor();

        $this->_aViewData['oManufacturer'] = $this->getManufacturer();

        $this->_aViewData['aLastProducts'] = $this->getLastProducts();

        // #785A loads and sets locator data
        $oLocator = oxNew( 'oxlocator', $this->getListType() );
        $oLocator->setLocatorData( $oProduct, $this );

        //media files
        $this->_aViewData['aMediaUrls'] = $this->getMediaFiles();

        if (in_array('oxrss_recommlists', $myConfig->getConfigParam( 'aRssSelected' )) && $this->getSimilarRecommLists()) {
            $oRss = oxNew('oxrssfeed');
            $this->addRssFeed($oRss->getRecommListsTitle( $oProduct ), $oRss->getRecommListsUrl( $oProduct ), 'recommlists');
        }


        //antispam
        $this->_aViewData['oCaptcha']     = $this->getCaptcha();
        $this->_aViewData['sSearchTitle'] = $this->getSearchTitle();
        $this->_aViewData['actCatpath']   = $this->getCatTreePath();

        return $this->_sThisTemplate;
    }

    protected function _prepareMetaDescription( $sMeta, $iLength = 200, $blDescTag = false )
    {
        if ( !$sMeta ) {
            $oProduct = $this->getProduct();

            $sMeta = $oProduct->getArticleLongDesc()->value;
            $sMeta = str_replace( array( '<br>', '<br />', '<br/>' ), "\n", $sMeta );
            $sMeta = $oProduct->oxarticles__oxtitle->value.' - '.$sMeta;
            $sMeta = strip_tags( $sMeta );
        }
        return parent::_prepareMetaDescription( $sMeta, $iLength, $blDescTag );
    }

    protected function _prepareMetaKeyword( $sKeywords, $blRemoveDuplicatedWords = true )
    {
        $myConfig = $this->getConfig();

        if ( !$sKeywords ) {
            $oProduct = $this->getProduct();
            $aKeywords[] = trim( $this->getTitle() );

            if ( $oCatTree = $this->getCategoryTree() ) {
                foreach ( $oCatTree->getPath() as $oCat ) {
                    $aKeywords[] = trim( $oCat->oxcategories__oxtitle->value );
                }
            }

            $sKeywords = implode( ", ", $aKeywords );

            $sKeywords = parent::_prepareMetaKeyword( $sKeywords, $blRemoveDuplicatedWords );

            //adding searchkeys info
            if ( $sSearchKeys = trim( $oProduct->oxarticles__oxsearchkeys->value ) ) {
                $sKeywords .= ", " . parent::_prepareMetaKeyword( $sSearchKeys, false );
            }
        }

        return $sKeywords;
    }

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

            $this->_blCanRate = false;
            $myConfig = $this->getConfig();

            if ( $myConfig->getConfigParam( 'bl_perfLoadReviews' ) &&
                 $oUser = $this->getUser() ) {

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

    public function saveReview()
    {
        $sReviewText = trim( ( string ) oxConfig::getParameter( 'rvw_txt', true ) );
        $dRating     = oxConfig::getParameter( 'artrating' );
        if ($dRating < 0 || $dRating > 5) {
            $dRating = null;
        }

        $sArtId  = oxConfig::getParameter( 'anid' );
        $sUserId = oxSession::getVar( 'usr' );

        //save rating
        if ( $dRating && $sUserId ) {
            $oProduct = $this->getProduct();

            $oRating = oxNew( 'oxrating' );
            $blRate = $oRating->allowRating( $sUserId, 'oxarticle', $oProduct->getId());
            if ( $blRate) {
                $oRating->oxratings__oxuserid = new oxField($sUserId);
                $oRating->oxratings__oxtype   = new oxField('oxarticle', oxField::T_RAW);
                $oRating->oxratings__oxobjectid = new oxField($sArtId);
                $oRating->oxratings__oxrating = new oxField($dRating);
                $oRating->save();
                $oProduct->addToRatingAverage( $dRating);
            } else {
                $dRating = null;
            }
        }

        if ( $sReviewText && $sUserId ) {
            $oReview = oxNew( 'oxreview' );
            $oReview->oxreviews__oxobjectid = new oxField($sArtId);
            $oReview->oxreviews__oxtype = new oxField('oxarticle', oxField::T_RAW);
            $oReview->oxreviews__oxtext = new oxField($sReviewText, oxField::T_RAW);
            $oReview->oxreviews__oxlang = new oxField(oxLang::getInstance()->getBaseLanguage());
            $oReview->oxreviews__oxuserid = new oxField($sUserId);
            $oReview->oxreviews__oxrating = new oxField(( $dRating) ? $dRating : null);
            $oReview->save();
        }
    }

    public function showLogin()
    {
        $this->_sThisTemplate = 'account_login.tpl';
        if ( $sAnchor = $this->getConfig()->getParameter("anchor") ) {
            $this->_sLoginFormAnchor = $sAnchor;
        }
    }

    public function addToRecomm()
    {
        $sRecommText = trim( ( string ) oxConfig::getParameter( 'recomm_txt' ) );
        $sRecommList = oxConfig::getParameter( 'recomm' );
        $sArtId      = oxConfig::getParameter( 'anid' );

        if ( $sArtId ) {
            $oRecomm = oxNew( 'oxrecommlist' );
            $oRecomm->load( $sRecommList);
            $oRecomm->addArticle( $sArtId, $sRecommText );
        }
    }

    public function addTags()
    {
        $sTag  = $this->getConfig()->getParameter('newTags', true );
        $sTag .= " ".getStr()->html_entity_decode( $this->getConfig()->getParameter( 'highTags', true ) );

        $oProduct = $this->getProduct();
        $oProduct->addTag( $sTag );

        //refresh
        $oTagHandler = oxNew( 'oxTagCloud' );
        $this->_sTagCloud = $oTagHandler->getTagCloud( $oProduct->getId() );
    }

    public function editTags()
    {
        $oTagCloud = oxNew("oxTagCloud");
        $this->_aTags = $oTagCloud->getTags( $this->getProduct()->getId() );
        $this->_blEditTags = true;
    }

    protected function _getSeoObjectId()
    {
        if ( $oProduct = $this->getProduct() ) {
            return $oProduct->getId();
        }
    }

    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 = array();
            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 getEditTags()
    {
        return $this->_blEditTags;
    }

    public function getTags()
    {
        return $this->_aTags;
    }

    public function getTagCloud()
    {
        if ( $this->_sTagCloud === null ) {
            $this->_sTagCloud = false;
            $oTagHandler = oxNew('oxTagCloud');
            $this->_sTagCloud = $oTagHandler->getTagCloud($this->getProduct()->getId());
        }
        return $this->_sTagCloud;
    }


    public function getLoginFormAnchor()
    {
        return $this->_sLoginFormAnchor;
    }

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

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

            //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' );
            //$this->_oProduct->setSkipAbPrice( true );

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

        // additional checks
        if ( !$this->_blIsInitialized ) {
            if ( !$this->_oProduct->isVisible() ) {
                $myUtils->redirect( $myConfig->getShopHomeURL() );
                $myUtils->showMessageAndExit( '' );
            }

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

        return $this->_oProduct;
    }

    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;
            } else {
                $this->_iLinkType = OXARTICLE_LINKTYPE_CATEGORY;

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

        return $this->_iLinkType;
    }

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

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

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

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

    public function drawParentUrl()
    {
        return $this->getProduct()->isVariant();
    }

    public function getParentName()
    {
        if ( $this->_sParentName === null ) {
            $this->_sParentName = false;
            if ( ( $oParent = $this->_getParentProduct( $this->getProduct()->oxarticles__oxparentid->value ) ) ) {
                $this->_sParentName = $oParent->oxarticles__oxtitle->value;
            }
        }
        return $this->_sParentName;
    }

    public function getParentUrl()
    {
        if ( $this->_sParentUrl === null ) {
            $this->_sParentUrl = false;
            if ( ( $oParent = $this->_getParentProduct( $this->getProduct()->oxarticles__oxparentid->value ) ) ) {
                $this->_sParentUrl = $oParent->getLink();
            }
        }
        return $this->_sParentUrl;
    }

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

    public function getActPictureId()
    {
        $aPicGallery = $this->getPictureGallery();
        return $aPicGallery['ActPicID'];
    }

    public function getActPicture()
    {
        $aPicGallery = $this->getPictureGallery();
        return $aPicGallery['ActPic'];
    }

    public function morePics()
    {
        $aPicGallery = $this->getPictureGallery();
        return $aPicGallery['MorePics'];
    }

    public function getPictures()
    {
        $aPicGallery = $this->getPictureGallery();
        return $aPicGallery['Pics'];
    }

    public function getArtPic( $sPicNr )
    {
        $aPicGallery = $this->getPictureGallery();
        return $aPicGallery['Pics'][$sPicNr];
    }

    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 getActZoomPic()
    {
        return 1;
    }

    public function getSelectLists()
    {
        if ( $this->_aSelectLists === null ) {
            $this->_aSelectLists = false;
            if ( $this->getConfig()->getConfigParam( 'bl_perfLoadSelectLists' ) ) {
                $this->_aSelectLists = $this->getProduct()->getSelectLists();
            }
        }
        return $this->_aSelectLists;
    }

    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 getSimilarRecommLists()
    {
        if ( $this->_oRecommList === null ) {
            $this->_oRecommList = false;
            if ( $oProduct = $this->getProduct() ) {
                $oRecommList = oxNew('oxrecommlist');
                $this->_oRecommList = $oRecommList->getRecommListsByIds( array( $oProduct->getId() ) );
            }
        }
        return $this->_oRecommList;
    }

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

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

    public function isPriceAlarm()
    {
        // #419 disabling pricealarm 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 noIndex()
    {
        $sListType = oxConfig::getParameter( 'listtype' );
        if ( $sListType && ( 'vendor' == $sListType || 'manufacturer' == $sListType ) ) {
            return $this->_iViewIndexState = VIEW_INDEXSTATE_NOINDEXFOLLOW;
        }
        return parent::noIndex();
    }

    public function getTitle()
    {
        if ( $oProduct = $this->getProduct() ) {
            return $oProduct->oxarticles__oxtitle->value . ( $oProduct->oxarticles__oxvarselect->value ? ' ' . $oProduct->oxarticles__oxvarselect->value : '' );
        }
    }


    public function getTag()
    {
        return oxConfig::getParameter("searchtag", 1);
    }
}

---