details.php

Go to the documentation of this file.

<?php

class Details extends oxUBase
{
    protected $_aVariantList = null;

    protected $_sThisTemplate = 'page/details/details.tpl';

    protected $_oParentProd = null;

    protected $_blCanRate = null;

    protected $_blShowSorting = true;

    protected $_blEditTags = null;

    protected $_blCanEditTags = null;

    protected $_aTags = null;

    protected $_aUserRecommList = 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 $_blMdView = null;

    protected $_dRatingValue = null;

    protected $_iRatingCnt = null;

    protected $_blTop5Action = false;

    protected $_sBidPrice = null;

    protected $_iPriceAlarmStatus = null;

    protected $_sSearchParamForHtml = null;

    protected $_aSimilarRecommListIds = null;


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

    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 selectlists too
                    $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;
    }

    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' ).'|';


        return $this->_sViewId = $sViewId;
    }


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

        $oProduct = $this->getProduct();

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

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

        parent::render();

        $sPartial = oxConfig::getParameter('renderPartial');
        $this->addTplParam('renderPartial', $sPartial);

        switch ($sPartial) {
            case "productInfo":
                return 'page/details/ajax/fullproductinfo.tpl';
                break;
            case "detailsMain":
                return 'page/details/ajax/productmain.tpl';
                break;
            default:
                // #785A loads and sets locator data
                $oLocator = oxNew( 'oxlocator', $this->getListType() );
                $oLocator->setLocatorData( $oProduct, $this );

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

                return $this->_sThisTemplate;
        }
    }

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

            $sMeta = $oProduct->getLongDescription()->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 )
    {
        if ( !$sKeywords ) {
            $oProduct = $this->getProduct();
            $sKeywords = trim( $this->getTitle() );

            if ( $oCatTree = $this->getCategoryTree() ) {
                foreach ( $oCatTree->getPath() as $oCat ) {
                    $sKeywords .= ", " . trim( $oCat->oxcategories__oxtitle->value );
                }
            }

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

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

        return $sKeywords;
    }

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

        return $myConfig->getConfigParam( 'bl_perfLoadReviews' );
    }

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

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

            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 saveReview()
    {
        if ( $this->canAcceptFormData() &&
             ( $oUser = $this->getUser() ) && ( $oProduct = $this->getProduct() ) ) {

            $dRating = oxConfig::getParameter( 'artrating' );
            if ( $dRating !== null ) {
                $dRating = (int) $dRating;
            }

            //save rating
            if ( $dRating !== null && $dRating >= 1 && $dRating <= 5 ) {
                $oRating = oxNew( 'oxrating' );
                if ( $oRating->allowRating( $oUser->getId(), 'oxarticle', $oProduct->getId() ) ) {
                    $oRating->oxratings__oxuserid   = new oxField( $oUser->getId() );
                    $oRating->oxratings__oxtype     = new oxField( 'oxarticle' );
                    $oRating->oxratings__oxobjectid = new oxField( $oProduct->getId() );
                    $oRating->oxratings__oxrating   = new oxField( $dRating );
                    $oRating->save();
                    $oProduct->addToRatingAverage( $dRating );
                }
            }

            if ( ( $sReviewText = trim( ( string ) oxConfig::getParameter( 'rvw_txt', true ) ) ) ) {
                $oReview = oxNew( 'oxreview' );
                $oReview->oxreviews__oxobjectid = new oxField( $oProduct->getId() );
                $oReview->oxreviews__oxtype     = new oxField( 'oxarticle' );
                $oReview->oxreviews__oxtext     = new oxField( $sReviewText, oxField::T_RAW );
                $oReview->oxreviews__oxlang     = new oxField( oxRegistry::getLang()->getBaseLanguage() );
                $oReview->oxreviews__oxuserid   = new oxField( $oUser->getId() );
                $oReview->oxreviews__oxrating   = new oxField( ( $dRating !== null ) ? $dRating : 0);
                $oReview->save();
            }
        }
    }

    public function addToRecomm()
    {
        if (!$this->getViewConfig()->getShowListmania()) {
            return;
        }

        $sRecommText = trim( ( string ) oxConfig::getParameter( 'recomm_txt' ) );
        $sRecommList = oxConfig::getParameter( 'recomm' );
        $sArtId      = $this->getProduct()->getId();

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

    public function addTags()
    {
        $sTag  = $this->getConfig()->getParameter('newTags', true );
        $sHighTag  = $this->getConfig()->getParameter( 'highTags', true );
        if ( !$sTag && !$sHighTag) {
            return;
        }
        if ( $sHighTag ) {
            $sTag = getStr()->html_entity_decode( $sHighTag );
        }

        //can tag only once per product and tags
        $aTags = array();
        $oProduct = $this->getProduct();
        $aTaggedProducts = oxSession::getVar("aTaggedProducts");
        if ( $aTaggedProducts ) {
            $aTags = $aTaggedProducts[$oProduct->getId()];
        }
        $blAddedTag = false;
        //Checks if user already tagged it
        if ( $aTags[$sTag] != 1 ) {
            $oProduct->addTag( $sTag );
            $aTags[$sTag] = 1;
            $aTaggedProducts[$oProduct->getId()] = $aTags;
            oxSession::setVar( 'aTaggedProducts', $aTaggedProducts);
            $blAddedTag = true;
        }
        // for ajax call
        if ( oxConfig::getParameter( 'blAjax', true ) ) {
            oxRegistry::getUtils()->showMessageAndExit( $blAddedTag );
        }
    }

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

        // for ajax call
        if ( oxConfig::getParameter( 'blAjax', true ) ) {
            oxRegistry::getUtils()->setHeader( "Content-Type: text/html; charset=".oxRegistry::getLang()->translateString( 'charset' ) );
            $oActView = oxNew( 'oxubase' );
            $oSmarty = oxRegistry::get("oxUtilsView")->getSmarty();
            $oSmarty->assign('oView', $this );
            $oSmarty->assign('oViewConf', $this->getViewConfig() );
            oxRegistry::getUtils()->showMessageAndExit( $oSmarty->fetch( 'page/details/inc/editTags.tpl', $this->getViewId() ) );
        }
    }

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

        // for ajax call
        if ( oxConfig::getParameter( 'blAjax', true ) ) {
            oxRegistry::getUtils()->setHeader( "Content-Type: text/html; charset=".oxRegistry::getLang()->translateString( 'charset' ) );
            $oActView = oxNew( 'oxubase' );
            $oSmarty = oxRegistry::get("oxUtilsView")->getSmarty();
            $oSmarty->assign('oView', $this );
            $oSmarty->assign('oViewConf', $this->getViewConfig() );
            oxRegistry::getUtils()->showMessageAndExit( $oSmarty->fetch( 'page/details/inc/tags.tpl', $this->getViewId() ) );
        }
    }

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

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

    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 getProduct()
    {
        $myConfig = $this->getConfig();
        $myUtils = oxRegistry::getUtils();

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

            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'];
            }
        }

        // additional checks
        if ( !$this->_blIsInitialized ) {

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

        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;
            } elseif ( 'recommlist' == $sListType ) {
                    $this->_iLinkType = OXARTICLE_LINKTYPE_RECOMM;
            } else {
                $this->_iLinkType = OXARTICLE_LINKTYPE_CATEGORY;

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

        return $this->_iLinkType;
    }

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

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

    public function getCanonicalUrl()
    {
        if ( ( $oProduct = $this->getProduct() ) ) {
            if ( $oProduct->oxarticles__oxparentid->value ) {
                $oProduct = $this->_getParentProduct( $oProduct->oxarticles__oxparentid->value );
            }

            $oUtils = oxRegistry::get("oxUtilsUrl");
            if ( oxRegistry::getUtils()->seoIsActive() ) {
                $sUrl = $oUtils->prepareCanonicalUrl( $oProduct->getBaseSeoLink( $oProduct->getLanguage(), true ) );
            } else {
                $sUrl = $oUtils->prepareCanonicalUrl( $oProduct->getBaseStdLink( $oProduct->getLanguage() ) );
            }
            return $sUrl;
        }
    }

    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 isPersParam()
    {
        $oProduct = $this->getProduct();
        return $oProduct->oxarticles__oxisconfigurable->value;
    }

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

    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 getBreadCrumb()
    {
        $aPaths = array();

        if ( 'search' == oxConfig::getParameter( 'listtype' ) ) {
            $sSearchParam = $this->getSearchParamForHtml();

            $aCatPath = array();
            $aCatPath['title'] = sprintf( oxRegistry::getLang()->translateString( 'searchResult', oxRegistry::getLang()->getBaseLanguage(), false ), $sSearchParam );
            $aCatPath['link']  = $this->getViewConfig()->getSelfLink() . 'stoken=' . oxSession::getVar('sess_stoken') . "&amp;cl=search&amp;searchparam=" . $sSearchParam;

            $aPaths[] = $aCatPath;

        } elseif ( 'tag' == oxConfig::getParameter( 'listtype' ) ) {

            $aCatPath = array();

            $aCatPath['title'] = oxRegistry::getLang()->translateString( 'TAGS', oxRegistry::getLang()->getBaseLanguage(), false );
            $aCatPath['link']  = oxRegistry::get("oxSeoEncoder")->getStaticUrl( $this->getViewConfig()->getSelfLink() . 'cl=tags' );
            $aPaths[] = $aCatPath;

            $oStr = getStr();
            $aCatPath['title'] = $oStr->ucfirst(oxConfig::getParameter( 'searchtag' ));
            $aCatPath['link']  = oxRegistry::get("oxSeoEncoderTag")->getTagUrl( oxConfig::getParameter( 'searchtag' ) );
            $aPaths[] = $aCatPath;

        } elseif ( 'recommlist' == oxConfig::getParameter( 'listtype' ) ) {

            $aCatPath = array();
            $aCatPath['title'] = oxRegistry::getLang()->translateString( 'PAGE_RECOMMENDATIONS_PRODUCTS_TITLE', oxRegistry::getLang()->getBaseLanguage(), false );
            $aPaths[] = $aCatPath;
        } else {

            $oCatTree = $this->getCatTreePath();

            if ( $oCatTree ) {

                foreach ( $oCatTree as $oCat ) {
                    $aCatPath = array();

                    $aCatPath['link'] = $oCat->getLink();
                    $aCatPath['title'] = $oCat->oxcategories__oxtitle->value;

                    $aPaths[] = $aCatPath;
                }
            }
        }

        return $aPaths;
    }

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

        //control captcha
        $sMac     = oxConfig::getParameter( 'c_mac' );
        $sMacHash = oxConfig::getParameter( 'c_mach' );
        $oCaptcha = $this->getCaptcha();
        if ( !$oCaptcha->pass( $sMac, $sMacHash ) ) {
            $this->_iPriceAlarmStatus = 2;
            return;
        }

        $aParams = oxConfig::getParameter( 'pa' );
        if ( !isset( $aParams['email'] ) || !$myUtils->isValidEmail( $aParams['email'] ) ) {
            $this->_iPriceAlarmStatus = 0;
            return;
        }
        $aParams['aid'] = $this->getProduct()->getId();
        $oCur = $myConfig->getActShopCurrencyObject();
        // convert currency to default
        $dPrice = $myUtils->currency2Float( $aParams['price'] );

        $oAlarm = oxNew( "oxpricealarm" );
        $oAlarm->oxpricealarm__oxuserid = new oxField( oxSession::getVar( 'usr' ));
        $oAlarm->oxpricealarm__oxemail  = new oxField( $aParams['email']);
        $oAlarm->oxpricealarm__oxartid  = new oxField( $aParams['aid']);
        $oAlarm->oxpricealarm__oxprice  = new oxField( $myUtils->fRound( $dPrice, $oCur ));
        $oAlarm->oxpricealarm__oxshopid = new oxField( $myConfig->getShopId());
        $oAlarm->oxpricealarm__oxcurrency = new oxField( $oCur->name);

        $oAlarm->oxpricealarm__oxlang = new oxField(oxRegistry::getLang()->getBaseLanguage());

        $oAlarm->save();

        // Send Email
        $oEmail = oxNew( 'oxemail' );
        $this->_iPriceAlarmStatus = (int) $oEmail->sendPricealarmNotification( $aParams, $oAlarm );
    }

    public function getPriceAlarmStatus()
    {
        return $this->_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 isMoreTagsVisible()
    {
        return true;
    }

    public function getSearchParamForHtml()
    {
        if ( $this->_sSearchParamForHtml === null ) {
            $this->_sSearchParamForHtml = oxConfig::getParameter( 'searchparam' );
        }
        return $this->_sSearchParamForHtml;
    }

    public function showRdfa()
    {
        return $this->getConfig()->getConfigParam( 'blRDFaEmbedding' );
    }

    public function getRDFaNormalizedRating()
    {
        $myConfig = $this->getConfig();
        $iMin = $myConfig->getConfigParam("iRDFaMinRating");
        $iMax = $myConfig->getConfigParam("iRDFaMaxRating");

        $oProduct = $this->getProduct();
        $iCount = $oProduct->oxarticles__oxratingcnt->value;
        if ( isset($iMin) && isset($iMax) && $iMax != '' && $iMin != '' && $iCount > 0 ) {
            $aNomalizedRating = array();
            $iValue = ((4*($oProduct->oxarticles__oxrating->value - $iMin)/($iMax - $iMin)))+1;
            $aNomalizedRating["count"] = $iCount;
            $aNomalizedRating["value"] = round($iValue, 2);
            return $aNomalizedRating;
        }
        return false;
    }

    public function getRDFaValidityPeriod($sShopConfVar)
    {
        if ( $sShopConfVar ) {
            $aValidity = array();
            $iDays = $this->getConfig()->getConfigParam($sShopConfVar);
            $iFrom = oxRegistry::get("oxUtilsDate")->getTime();

            $iThrough = $iFrom + ($iDays * 24 * 60 * 60);
            $aValidity["from"] = date('Y-m-d\TH:i:s', $iFrom)."Z";
            $aValidity["through"] = date('Y-m-d\TH:i:s', $iThrough)."Z";

            return $aValidity;
        }
        return false;
    }

    public function getRDFaBusinessFnc()
    {
        return $this->getConfig()->getConfigParam("sRDFaBusinessFnc");
    }

    public function getRDFaCustomers()
    {
        return $this->getConfig()->getConfigParam("aRDFaCustomers");
    }

    public function getRDFaVAT()
    {
        return $this->getConfig()->getConfigParam("iRDFaVAT");
    }

    public function getRDFaGenericCondition()
    {
        return $this->getConfig()->getConfigParam("iRDFaCondition");
    }

    public function getBundleArticle()
    {
        $oProduct = $this->getProduct();
        if ( $oProduct && $oProduct->oxarticles__oxbundleid->value ) {
            $oArticle = oxNew("oxarticle");
            $oArticle->load($oProduct->oxarticles__oxbundleid->value);
            return $oArticle;
        }
        return false;
    }

    public function getRDFaPaymentMethods()
    {
        $iPrice = $this->getProduct()->getPrice()->getBruttoPrice();
        $oPayments = oxNew("oxpaymentlist");
        $oPayments->loadRDFaPaymentList($iPrice);
        return $oPayments;
    }

    public function getRDFaDeliverySetMethods()
    {
        $oDelSets = oxNew("oxdeliverysetlist");
        $oDelSets->loadRDFaDeliverySetList();
        return $oDelSets;
    }

    public function getProductsDeliveryList()
    {
        $oProduct = $this->getProduct();
        $oDelList = oxNew( "oxDeliveryList" );
        $oDelList->loadDeliveryListForProduct( $oProduct );
        return $oDelList;
    }

    public function getRDFaDeliveryChargeSpecLoc()
    {
        return $this->getConfig()->getConfigParam("sRDFaDeliveryChargeSpecLoc");
    }

    public function getRDFaPaymentChargeSpecLoc()
    {
        return $this->getConfig()->getConfigParam("sRDFaPaymentChargeSpecLoc");
    }

    public function getRDFaBusinessEntityLoc()
    {
        return $this->getConfig()->getConfigParam("sRDFaBusinessEntityLoc");
    }

    public function showRDFaProductStock()
    {
        return $this->getConfig()->getConfigParam("blShowRDFaProductStock");
    }

}