oxubase.php

Go to the documentation of this file.

<?php

// view indexing state for search engines:
define( 'VIEW_INDEXSTATE_INDEX', 0 );           //  index without limitations
define( 'VIEW_INDEXSTATE_NOINDEXNOFOLLOW', 1 ); //  no index / no follow
define( 'VIEW_INDEXSTATE_NOINDEXFOLLOW', 2 );   //  no index / follow

class oxUBase extends oxView
{
    protected $_blFbWidgetsOn = null;

    protected $_sRemoveMetaChars = '.\+*?[^]$(){}=!<>|:&';

    protected $_oaComponents = array();

    protected $_blIsOrderStep = false;

    protected $_sListType = null;

    protected $_aListDisplayTypes = array( 'grid', 'line', 'infogrid' );

    protected $_sListDisplayType = null;

    protected $_sCustomListDisplayType = null;

    protected $_oActCategory = null;

    protected $_oActManufacturer = null;

    protected $_oActVendor = null;

    protected $_oActiveRecommList = null;

    protected $_oActSearch = null;

    protected $_blShowSorting = false;

    protected $_blLoadCurrency = null;

    protected $_blLoadManufacturerTree = null;

    protected $_blDontShowEmptyCats = null;

    protected $_blLoadLanguage = null;

    protected $_iTopCatNavItmCnt = null;

    protected $_aRssLinks = null;

    protected $_sListOrderBy = null;

    protected $_sListOrderDir = null;

    protected $_sMetaDescription = null;

    protected $_sMetaKeywords = null;

    protected $_sMetaDescriptionIdent = null;

    protected $_sMetaKeywordsIdent = null;

    protected $_sAdditionalParams = null;

    protected $_oActCurrency = null;

    protected $_blEnabledPrivateSales = null;

    protected $_blCommonAdded = false;

    protected $_iViewIndexState = VIEW_INDEXSTATE_INDEX;

    protected $_blForceNoIndex = false;

    protected $_iCompItemsCnt = null;

    protected $_sContentId = null;

    protected $_oContent = null;

    protected $_sViewResetID = null;

    protected $_blActiveSorting = null;

    protected $_aMenueList = null;

    protected $_aComponentNames = array(
                                    'oxcmp_user'       => 1, // 0 means dont init if cached
                                    'oxcmp_lang'       => 0,
                                    'oxcmp_cur'        => 1,
                                    'oxcmp_shop'       => 1,
                                    'oxcmp_categories' => 0,
                                    'oxcmp_utils'      => 1,
                                    'oxcmp_news'       => 0,
                                    'oxcmp_basket'     => 1
                                  );

    protected $_aUserComponentNames = array();

    protected $_oProduct = null;

    protected $_iActPage = null;

    protected $_aArticleList = null;

    protected $_oManufacturerTree  = null;

    protected $_oCategoryTree  = null;

    protected $_aTop5ArticleList  = null;

    protected $_aBargainArticleList  = null;

    protected $_blLowOrderPrice = null;

    protected $_sMinOrderPrice  = null;

    protected $_iNewsRealStatus  = null;

    protected $_aBlockRedirectParams = array( 'fnc', 'stoken', 'force_sid', 'force_admin_sid' );

    protected $_oRootVendor = null;

    protected $_sVendorId = null;

    protected $_aManufacturerlist = null;

    protected $_oRootManufacturer = null;

    protected $_sManufacturerId = null;

    protected $_aSearchCatTree = null;

    protected $_blNewsSubscribed = null;

    protected $_oDelAddress = null;

    protected $_sCatTreePath = null;

    protected $_aContents = array();

    protected $_blTop5Action = false;

    protected $_blBargainAction = false;

    protected $_aMustFillFields = null;

    protected $_blShowTagCloud = true;

    protected $_blRootCatChanged = false;

    protected $_aInvoiceAddress = null;

    protected $_aDeliveryAddress = null;

    protected $_sActiveUsername = null;

    protected static $_aCollectedComponentNames = null;

    protected $_blLoadComponents = true;


    protected $_aSortColumns = null;

    protected function _getComponentNames()
    {
        if ( self::$_aCollectedComponentNames === null ) {
            self::$_aCollectedComponentNames = array_merge( $this->_aComponentNames, $this->_aUserComponentNames );

            // #1721: custom component handling. At the moment it is not possible to override this variable in oxubase,
            // so we added this array to config.inc.php file
            if ( ( $aUserCmps = $this->getConfig()->getConfigParam( 'aUserComponentNames' ) ) ) {
                self::$_aCollectedComponentNames = array_merge( self::$_aCollectedComponentNames, $aUserCmps );
            }

            if ( oxConfig::getParameter( '_force_no_basket_cmp' ) ) {
                unset( self::$_aCollectedComponentNames['oxcmp_basket'] );
            }
        }

        // resetting array pointer
        reset( self::$_aCollectedComponentNames );
        return self::$_aCollectedComponentNames;
    }

    protected function _processRequest()
    {
        $myUtils = oxRegistry::getUtils();

        // non admin, request is not empty and was not processed by seo engine
        if ( !isSearchEngineUrl() && $myUtils->seoIsActive() && ( $sStdUrl = getRequestUrl( '', true ) ) ) {

            // fetching standard url and looking for it in seo table
            if ( $this->_canRedirect() && ( $sRedirectUrl = oxRegistry::get("oxSeoEncoder")->fetchSeoUrl( $sStdUrl ) ) ) {
                $myUtils->redirect( $this->getConfig()->getCurrentShopUrl() . $sRedirectUrl, false );
            } elseif (VIEW_INDEXSTATE_INDEX == $this->noIndex()) {
                // forcing to set noindex/follow meta
                $this->_forceNoIndex();

                if ( $this->getConfig()->getConfigParam('blSeoLogging') ) {
                    $sShopId = $this->getConfig()->getShopId();
                    $sLangId = oxRegistry::getLang()->getBaseLanguage();
                    $sIdent  = md5( strtolower( $sStdUrl ) . $sShopId . $sLangId );

                    // logging "not found" url
                    $oDb = oxDb::getDb();
                    $oDb->execute( "replace oxseologs ( oxstdurl, oxident, oxshopid, oxlang )
                                    values ( " . $oDb->quote( $sStdUrl ) . ", '{$sIdent}', '{$sShopId}', '{$sLangId}' ) " );
                }
            }
        }
    }

    public function init()
    {
        $this->_processRequest();

        // storing current view
        $blInit = true;


        // init all components if there are any
        if ( $this->_blLoadComponents ) {
            foreach ( $this->_getComponentNames() as $sComponentName => $blNotCacheable ) {
                // do not override initiated components
                if ( !isset( $this->_oaComponents[$sComponentName] ) ) {
                    // component objects MUST be created to support user called functions
                    $oComponent = oxNew( $sComponentName );
                    $oComponent->setParent( $this );
                    $oComponent->setThisAction( $sComponentName );
                    $this->_oaComponents[$sComponentName] = $oComponent;
                }

                // do we really need to initiate them ?
                if ( $blInit ) {
                    $this->_oaComponents[$sComponentName]->init();

                    // executing only is view does not have action method
                    if ( !method_exists( $this, $this->getFncName() ) ) {
                        $this->_oaComponents[$sComponentName]->executeFunction( $this->getFncName() );
                    }
                }
            }
        }

        parent::init();
    }

    public function getViewId()
    {
        if ( $this->_sViewId ) {
            return $this->_sViewId;
        }

        $myConfig = $this->getConfig();
        $iLang = oxRegistry::getLang()->getBaseLanguage();
        $iCur  = (int) $myConfig->getShopCurrency();


            $this->_sViewId =  "ox|$iLang|$iCur";

        $this->_sViewId .= "|".( (int) $this->_blForceNoIndex ).'|'.((int)$this->isRootCatChanged());

        // #0004798: SSL should be included in viewId
        if ($myConfig->isSsl()) {
            $this->_sViewId .= "|ssl";
        }

        // #0002866: external global viewID addition
        if (function_exists('customGetViewId')) {
            $oExtViewId = customGetViewId();

            if ($oExtViewId !== null) {
                $this->_sViewId .= '|'.md5(serialize($oExtViewId));
            }
        }
        return $this->_sViewId;
    }


    public function showSorting()
    {
        return $this->_blShowSorting && $this->getConfig()->getConfigParam( 'blShowSorting' );
    }

    public function setComponents( $aComponents = null )
    {
        $this->_oaComponents = $aComponents;
    }

    public function getComponents()
    {
        return $this->_oaComponents;
    }

    public function getComponent( $sName )
    {
        if ( isset( $sName ) && isset( $this->_oaComponents[$sName] ) ) {
            return $this->_oaComponents[$sName];
        }
    }
    public function setIsOrderStep( $blIsOrderStep = null )
    {
        $this->_blIsOrderStep = $blIsOrderStep;
    }

    public function getIsOrderStep()
    {
        return $this->_blIsOrderStep;
    }


    public function setActiveCategory( $oCategory )
    {
        $this->_oActCategory = $oCategory;
    }

    public function getActiveCategory()
    {
        return $this->_oActCategory;
    }

    public function getListType()
    {
        if ( $this->_sListType == null ) {
            if ( $sListType = oxConfig::getParameter( 'listtype' ) ) {
                $this->_sListType = $sListType;
            } elseif ( $sListType = $this->getConfig()->getGlobalParameter( 'listtype' ) ) {
                $this->_sListType = $sListType;
            }
        }
        return $this->_sListType;
    }

    public function getListDisplayType()
    {
        if ( $this->_sListDisplayType == null ) {
            $this->_sListDisplayType = $this->getCustomListDisplayType();

            if ( !$this->_sListDisplayType ) {
                $this->_sListDisplayType = $this->getConfig()->getConfigParam( 'sDefaultListDisplayType' );
            }

            $this->_sListDisplayType = in_array( ( string ) $this->_sListDisplayType, $this->_aListDisplayTypes ) ? $this->_sListDisplayType : 'infogrid';

            // writing to session
            if ( oxConfig::getParameter( 'ldtype' ) ) {
                oxSession::setVar( 'ldtype', $this->_sListDisplayType );
            }
        }
        return $this->_sListDisplayType;
    }

    public function getCustomListDisplayType()
    {
        if ( $this->_sCustomListDisplayType == null ) {
            $this->_sCustomListDisplayType = oxConfig::getParameter( 'ldtype' );

            if ( !$this->_sCustomListDisplayType ) {
                $this->_sCustomListDisplayType = oxRegistry::getSession()->getVariable( 'ldtype' );
            }
        }
        return $this->_sCustomListDisplayType;
    }

    public function setListType( $sType )
    {
        $this->_sListType = $sType;
        $this->getConfig()->setGlobalParameter( 'listtype', $sType );
    }

    public function loadCurrency()
    {
        if ( $this->_blLoadCurrency == null ) {
            $this->_blLoadCurrency = false;
            if ( $blLoadCurrency = $this->getConfig()->getConfigParam( 'bl_perfLoadCurrency' ) ) {
                $this->_blLoadCurrency = $blLoadCurrency;
            }
        }
        return $this->_blLoadCurrency;
    }

    public function dontShowEmptyCategories()
    {
        if ( $this->_blDontShowEmptyCats == null ) {
            $this->_blDontShowEmptyCats = false;
            if ( $blDontShowEmptyCats = $this->getConfig()->getConfigParam( 'blDontShowEmptyCategories' ) ) {
                $this->_blDontShowEmptyCats = $blDontShowEmptyCats;
            }
        }
        return $this->_blDontShowEmptyCats;
    }

    public function showCategoryArticlesCount()
    {
        return $this->getConfig()->getConfigParam( 'bl_perfShowActionCatArticleCnt' );
    }

    public function isLanguageLoaded()
    {
        if ( $this->_blLoadLanguage == null ) {
            $this->_blLoadLanguage = false;
            if ( $blLoadLanguage = $this->getConfig()->getConfigParam( 'bl_perfLoadLanguages' ) ) {
                $this->_blLoadLanguage = $blLoadLanguage;
            }
        }
        return $this->_blLoadLanguage;
    }

    public function getTopNavigationCatCnt()
    {
        if ( $this->_iTopCatNavItmCnt == null ) {
            $iTopCatNavItmCnt = $this->getConfig()->getConfigParam( 'iTopNaviCatCount' );
            $this->_iTopCatNavItmCnt = $iTopCatNavItmCnt ? $iTopCatNavItmCnt : 5;
        }
        return $this->_iTopCatNavItmCnt;
    }

    public function addRssFeed($sTitle, $sUrl, $key = null)
    {
        if (!is_array($this->_aRssLinks)) {
            $this->_aRssLinks = array();
        }

        $sUrl = oxRegistry::get("oxUtilsUrl")->prepareUrlForNoSession($sUrl);

        if ($key === null) {
            $this->_aRssLinks[] = array('title'=>$sTitle, 'link' => $sUrl);
        } else {
            $this->_aRssLinks[$key] = array('title'=>$sTitle, 'link' => $sUrl);
        }
    }

    public function getSortOrderByParameterName()
    {
        return 'listorderby';
    }

    public function getSortOrderParameterName()
    {
        return 'listorder';
    }


    public function getSortIdent()
    {
        return 'alist';
    }

    public function getDefaultSorting()
    {
        return null;
    }

    public function getUserSelectedSorting()
    {
        $aSorting = null;
        $oStr = getStr();
        $oConfig = oxRegistry::getConfig();
        $aSortDirections = array( 'desc', 'asc' );
        $aSortColumns = $this->getSortColumns();

        $sSortBy  = $oConfig->getParameter( $this->getSortOrderByParameterName() );
        $sSortDir = $oConfig->getParameter( $this->getSortOrderParameterName() );

        if ( $sSortBy && oxDb::getInstance()->isValidFieldName( $sSortBy ) && /*in_array( $oStr->strtolower($sSortBy), $aSortColumns ) &&*/
            $sSortDir && oxRegistry::getUtils()->isValidAlpha( $sSortDir ) && in_array( $oStr->strtolower($sSortDir), $aSortDirections ) ) {
            $aSorting = array ( 'sortby' => $sSortBy, 'sortdir' => $sSortDir );
        }

        return $aSorting;
    }


    public function getSavedSorting( $sSortIdent )
    {
        $aSorting = oxRegistry::getSession()->getVariable( 'aSorting' );
        if ( isset( $aSorting[$sSortIdent] ) ) {
            return $aSorting[$sSortIdent];
        }
    }

    public function setListOrderBy( $sColumn )
    {
        $this->_sListOrderBy = $sColumn;
    }

    public function setListOrderDirection( $sDirection )
    {
        $this->_sListOrderDir = $sDirection;
    }



    public function prepareSortColumns()
    {
        $aSortColumns = $this->getConfig()->getConfigParam( 'aSortCols' );
        $aSortDir = array( 'desc', 'asc' );
        if ( count( $aSortColumns ) > 0 ) {

            $this->_aSortColumns = $aSortColumns;

            $sCnid = oxRegistry::getConfig()->getRequestParameter( 'cnid' );


            $sSortBy  = oxRegistry::getConfig()->getRequestParameter( $this->getSortOrderByParameterName() );
            $sSortDir = oxRegistry::getConfig()->getRequestParameter( $this->getSortOrderParameterName() );

            $oStr = getStr();
            if ( (!$sSortBy || !in_array( $oStr->strtolower($sSortBy), $aSortColumns) || !in_array( $oStr->strtolower($sSortDir), $aSortDir) ) && $aSorting = $this->getSorting( $sCnid ) ) {
                $sSortBy  = $aSorting['sortby'];
                $sSortDir = $aSorting['sortdir'];
            }

            if ( $sSortBy && oxDb::getInstance()->isValidFieldName( $sSortBy ) &&
                 $sSortDir && oxRegistry::getUtils()->isValidAlpha( $sSortDir ) ) {

                $this->_sListOrderBy  = $sSortBy;
                $this->_sListOrderDir = $sSortDir;

                // caching sorting config
                $this->setItemSorting( $sCnid, $sSortBy, $sSortDir );
            }
        }
    }

    public function getListOrderBy()
    {
        //if column is with table name split it
        $aColumns = explode('.', $this->_sListOrderBy);

        if ( is_array($aColumns) && count($aColumns) > 1 ) {
           return $aColumns[1];
        }

        return $this->_sListOrderBy;
    }

    public function getListOrderDirection()
    {
        return $this->_sListOrderDir;
    }

    public function setMetaDescription ( $sDescription )
    {
        return $this->_sMetaDescription = $sDescription;
    }

    public function setMetaKeywords( $sKeywords )
    {
        return $this->_sMetaKeywords = $sKeywords;
    }

    protected function _getMetaFromSeo( $sDataType )
    {
        $sOxid  = $this->_getSeoObjectId();
        $iLang  = oxRegistry::getLang()->getBaseLanguage();
        $sShop  = $this->getConfig()->getShopId();

        if ( $sOxid && oxRegistry::getUtils()->seoIsActive() &&
             ( $sKeywords = oxRegistry::get("oxSeoEncoder")->getMetaData( $sOxid, $sDataType, $sShop, $iLang) ) ) {
            return $sKeywords;
        }
    }

    protected function _getMetaFromContent( $sMetaIdent )
    {
        if ( $sMetaIdent ) {
            $oContent = oxNew( 'oxcontent' );
            if ( $oContent->loadByIdent( $sMetaIdent ) &&
                 $oContent->oxcontents__oxactive->value ) {
                return getStr()->strip_tags( $oContent->oxcontents__oxcontent->value );
            }
        }
    }

    public function getMetaKeywords()
    {
        if ( $this->_sMetaKeywords === null ) {
            $this->_sMetaKeywords = false;

            // set special meta keywords ?
            if ( ( $sKeywords = $this->_getMetaFromSeo( 'oxkeywords' ) ) ) {
                $this->_sMetaKeywords = $sKeywords;
            } elseif ( ( $sKeywords = $this->_getMetaFromContent( $this->_sMetaKeywordsIdent ) ) ) {
                $this->_sMetaKeywords = $this->_prepareMetaKeyword( $sKeywords, false );
            } else {
                $this->_sMetaKeywords = $this->_prepareMetaKeyword( false, true );
            }
        }

        return $this->_sMetaKeywords;
    }

    public function getMetaDescription()
    {
        if ( $this->_sMetaDescription === null ) {
            $this->_sMetaDescription = false;

            // set special meta description ?
            if ( ( $sDescription = $this->_getMetaFromSeo( 'oxdescription' ) ) ) {
                $this->_sMetaDescription = $sDescription;
            } elseif ( ( $sDescription = $this->_getMetaFromContent( $this->_sMetaDescriptionIdent ) ) ) {
                $this->_sMetaDescription = $this->_prepareMetaDescription( $sDescription );
            } else {
                $this->_sMetaDescription = $this->_prepareMetaDescription( false );
            }
        }

        return $this->_sMetaDescription;
    }

    public function getActCurrency()
    {
        return $this->_oActCurrency;
    }

    public function setActCurrency( $oCur )
    {
        $this->_oActCurrency = $oCur;
    }

    public function getCompareItemCount()
    {
        if ( $this->_iCompItemsCnt === null ) {
            $aItems = oxRegistry::getSession()->getVariable('aFiltcompproducts');
            $this->_iCompItemsCnt = is_array($aItems)?count($aItems):0;
        }
        return $this->_iCompItemsCnt;
    }

    protected function _forceNoIndex()
    {
        $this->_blForceNoIndex = true;
    }

    public function noIndex()
    {
        if ( $this->_blForceNoIndex ) {
            $this->_iViewIndexState = VIEW_INDEXSTATE_NOINDEXFOLLOW;
        } elseif ( oxConfig::getParameter( 'cur' ) ) {
            $this->_iViewIndexState = VIEW_INDEXSTATE_NOINDEXNOFOLLOW;
        } else {
            switch ( oxConfig::getParameter( 'fnc' ) ) {
                case 'tocomparelist':
                case 'tobasket':
                    $this->_iViewIndexState = VIEW_INDEXSTATE_NOINDEXNOFOLLOW;
                    break;
            }
        }
        return $this->_iViewIndexState;
    }

    public function isSortingActive()
    {
        return $this->_blActiveSorting;
    }

    public function getMenueList()
    {
        return $this->_aMenueList;
    }

    public function setMenueList( $aMenue )
    {
        $this->_aMenueList = $aMenue;
    }


    protected function _setNrOfArtPerPage()
    {
        $myConfig  = $this->getConfig();

        //setting default values to avoid possible errors showing article list
        $iNrofCatArticles = $myConfig->getConfigParam( 'iNrofCatArticles' );

        $iNrofCatArticles = ( $iNrofCatArticles ) ? $iNrofCatArticles : 10;

        // checking if all needed data is set
        switch ( $this->getListDisplayType() ) {
            case 'grid':
                $aNrofCatArticles = $myConfig->getConfigParam( 'aNrofCatArticlesInGrid' );
                break;
            case 'line':
            case 'infogrid':
            default:
                $aNrofCatArticles = $myConfig->getConfigParam( 'aNrofCatArticles' );
        }

        if ( !is_array( $aNrofCatArticles ) || !isset( $aNrofCatArticles[0] ) ) {
            $aNrofCatArticles = array( $iNrofCatArticles );
            $myConfig->setConfigParam( 'aNrofCatArticles', $aNrofCatArticles );
        } else {
            $iNrofCatArticles = $aNrofCatArticles[0];
        }

        $oViewConf = $this->getViewConfig();
        //value from user input
        if ( ( $iNrofArticles = (int) oxConfig::getParameter( '_artperpage' ) ) ) {
            // M45 Possibility to push any "Show articles per page" number parameter
            $iNrofCatArticles = ( in_array( $iNrofArticles, $aNrofCatArticles ) ) ? $iNrofArticles : $iNrofCatArticles;
            $oViewConf->setViewConfigParam( 'iartPerPage', $iNrofCatArticles );
            oxSession::setVar( '_artperpage', $iNrofCatArticles );
        } elseif ( ( $iSessArtPerPage = oxRegistry::getSession()->getVariable( '_artperpage' ) )&& is_numeric( $iSessArtPerPage ) ) {
            // M45 Possibility to push any "Show articles per page" number parameter
            $iNrofCatArticles = ( in_array( $iSessArtPerPage, $aNrofCatArticles ) ) ? $iSessArtPerPage : $iNrofCatArticles;
            $oViewConf->setViewConfigParam( 'iartPerPage', $iSessArtPerPage );
            $iNrofCatArticles = $iSessArtPerPage;
        } else {
            $oViewConf->setViewConfigParam( 'iartPerPage', $iNrofCatArticles );
        }

        //setting number of articles per page to config value
        $myConfig->setConfigParam( 'iNrofCatArticles', $iNrofCatArticles );
    }

    protected function _getSeoObjectId()
    {
    }

    protected function _prepareMetaDescription( $sMeta, $iLength = 1024, $blRemoveDuplicatedWords = false )
    {
        if ( $sMeta ) {

            $oStr = getStr();
            if ( $iLength != -1 ) {
                /* *
                 * performance - we do not need a huge amount of initial text.
                 * assume that effective text may be double longer than $iLength
                 * and simple truncate it
                 */
                $iELength = ( $iLength * 2 );
                $sMeta = $oStr->substr( $sMeta, 0, $iELength );
            }

            // decoding html entities
            $sMeta = $oStr->html_entity_decode( $sMeta );
            // stripping HTML tags
            $sMeta = $oStr->strip_tags( $sMeta );

            // removing some special chars
            $sMeta = $oStr->cleanStr( $sMeta );

            // removing duplicate words
            if ( $blRemoveDuplicatedWords ) {
                $sMeta = $this->_removeDuplicatedWords( $sMeta, $this->getConfig()->getConfigParam( 'aSkipTags' ) );
            }

            // some special cases
            $sMeta = str_replace( ' ,', ',', $sMeta );
            $aPattern = array( "/,[\s\+\-\*]*,/", "/\s+,/" );
            $sMeta = $oStr->preg_replace( $aPattern, ',', $sMeta );
            $sMeta = oxRegistry::get("oxUtilsString")->minimizeTruncateString( $sMeta, $iLength );
            $sMeta = $oStr->htmlspecialchars( $sMeta );

            return trim( $sMeta );
        }
    }

    protected function _prepareMetaKeyword( $sKeywords, $blRemoveDuplicatedWords = true )
    {

        $sString = $this->_prepareMetaDescription( $sKeywords, -1, false );

        if ( $blRemoveDuplicatedWords ) {
            $sString = $this->_removeDuplicatedWords( $sString, $this->getConfig()->getConfigParam( 'aSkipTags' ) );
        }

       return trim( $sString );
    }

    protected function _removeDuplicatedWords( $aInput, $aSkipTags = array() )
    {
        $oStr = getStr();
        if ( is_array( $aInput ) ) {
            $aInput = implode( " ", $aInput );
        }

        // removing some usually met characters..
        $aInput = $oStr->preg_replace( "/[".preg_quote( $this->_sRemoveMetaChars, "/" )."]/", " ", $aInput );

        // splitting by word
        $aStrings = $oStr->preg_split( "/[\s,]+/", $aInput );

        if ( $sCount = count( $aSkipTags ) ) {
            for ( $iNum = 0; $iNum < $sCount; $iNum++ ) {
                $aSkipTags[$iNum] = $oStr->strtolower( $aSkipTags[$iNum] );
            }
        }
        $sCount = count($aStrings);
        for ( $iNum = 0; $iNum < $sCount; $iNum++ ) {
            $aStrings[$iNum] = $oStr->strtolower( $aStrings[$iNum] );
            // removing in admin defined strings
            if ( !$aStrings[$iNum] || in_array( $aStrings[$iNum], $aSkipTags ) ) {
                unset( $aStrings[$iNum] );
            }
        }

        // duplicates
        return implode( ', ', array_unique( $aStrings ) );
    }

    public function getNavigationParams()
    {
        $aParams['cnid'] = $this->getCategoryId();
        $aParams['mnid'] = oxConfig::getParameter( 'mnid' );

        $aParams['listtype'] = $this->getListType();
        $aParams['ldtype'] = $this->getCustomListDisplayType();
        $aParams['actcontrol'] = $this->getClassName();

        $aParams['recommid'] = oxConfig::getParameter( 'recommid' );

        $aParams['searchrecomm'] = oxConfig::getParameter( 'searchrecomm', true );
        $aParams['searchparam']  = oxConfig::getParameter( 'searchparam', true );
        $aParams['searchtag']    = oxConfig::getParameter( 'searchtag', true );

        $aParams['searchvendor'] = oxConfig::getParameter( 'searchvendor' );
        $aParams['searchcnid']   = oxConfig::getParameter( 'searchcnid' );
        $aParams['searchmanufacturer'] = oxConfig::getParameter( 'searchmanufacturer' );

        return $aParams;
    }

    public function setItemSorting( $sSortIdent, $sSortBy, $sSortDir = null )
    {
        $aSorting = oxRegistry::getSession()->getVariable( 'aSorting' );
        $aSorting[$sSortIdent]['sortby']  = $sSortBy;
        $aSorting[$sSortIdent]['sortdir'] = $sSortDir ? $sSortDir : null;

        oxRegistry::getSession()->setVariable( 'aSorting', $aSorting );
    }

    public function getSorting( $sSortIdent )
    {
        $aSorting = null;

        if ( $aSorting = $this->getUserSelectedSorting() ) {
            $this->setItemSorting( $sSortIdent, $aSorting['sortby'], $aSorting['sortdir'] );
        } elseif ( !$aSorting = $this->getSavedSorting( $sSortIdent ) ) {
            $aSorting = $this->getDefaultSorting();
        }

        if ( $aSorting ) {
            $this->setListOrderBy( $aSorting['sortby'] );
            $this->setListOrderDirection( $aSorting['sortdir'] );
        }

        return $aSorting;
    }

    public function getSortingSql( $sIdent )
    {
        $aSorting = $this->getSorting( $sIdent );
        if ( is_array( $aSorting ) ) {
            return implode( " ", $aSorting );
        }
    }

    public function getTitleSuffix()
    {
        return $this->getConfig()->getActiveShop()->oxshops__oxtitlesuffix->value;
    }

    public function getTitlePageSuffix()
    {
    }

    public function getTitlePrefix()
    {
        return $this->getConfig()->getActiveShop()->oxshops__oxtitleprefix->value;
    }



    protected function _getSubject( $iLang )
    {
        return null;
    }

    public function getDynUrlParams()
    {
        $sRet = '';
        $sListType = $this->getListType();

        switch ($sListType) {
            default:
                break;
            case 'search':
                $sRet .= "&amp;listtype={$sListType}";
                if ( $sSearchParamForLink = rawurlencode( oxConfig::getParameter( 'searchparam', true ) ) ) {
                    $sRet .= "&amp;searchparam={$sSearchParamForLink}";
                }

                if ( ( $sVar = oxConfig::getParameter( 'searchcnid', true ) ) ) {
                    $sRet .= '&amp;searchcnid='.rawurlencode( rawurldecode( $sVar ) );
                }
                if ( ( $sVar = oxConfig::getParameter( 'searchvendor', true ) ) ) {
                    $sRet .= '&amp;searchvendor='.rawurlencode( rawurldecode( $sVar ) );
                }
                if ( ( $sVar = oxConfig::getParameter( 'searchmanufacturer', true ) ) ) {
                    $sRet .= '&amp;searchmanufacturer='.rawurlencode( rawurldecode( $sVar ) );
                }
                break;
            case 'tag':
                $sRet .= "&amp;listtype={$sListType}";
                if ( $sParam = rawurlencode( oxConfig::getParameter( 'searchtag', true ) ) ) {
                    $sRet .= "&amp;searchtag={$sParam}";
                }
                break;
        }

        return $sRet;
    }

    public function getLink( $iLang = null )
    {
        if ( !isset( $iLang ) ) {
            $iLang = oxRegistry::getLang()->getBaseLanguage();
        }

        $oDisplayObj = null;
        $blTrySeo = false;
        if ( oxRegistry::getUtils()->seoIsActive() ) {
            $blTrySeo = true;
            $oDisplayObj = $this->_getSubject( $iLang );
        }
        $iActPageNr = $this->getActPage();

        if ( $oDisplayObj ) {
            return $this->_addPageNrParam( $oDisplayObj->getLink( $iLang ), $iActPageNr, $iLang );
        }

        $myConfig = $this->getConfig();

        if ( $blTrySeo ) {
            $oEncoder = oxRegistry::get("oxSeoEncoder");
            if ( ( $sSeoUrl = $oEncoder->getStaticUrl( $myConfig->getShopHomeURL( $iLang ) . $this->_getSeoRequestParams(), $iLang ) ) ) {
                return $this->_addPageNrParam( $sSeoUrl, $iActPageNr, $iLang );
            }
        }

        $sUrl = oxRegistry::get("oxUtilsUrl")->processUrl( $myConfig->getShopCurrentURL( $iLang ) . $this->_getRequestParams(), true, null, $iLang);

        // fallback to old non seo url
        return $this->_addPageNrParam( $sUrl, $iActPageNr, $iLang );
    }

    public function getCanonicalUrl()
    {
    }

    public function getSimilarRecommListIds()
    {
        return false;
    }
    public function getSearchParamForHtml()
    {
    }

    protected function _getRequestParams( $blAddPageNr  = true )
    {
        $sClass = $this->getClassName();
        $sFnc   = $this->getFncName();

        $aFnc = array( 'tobasket', 'login_noredirect', 'addVoucher', 'moveleft', 'moveright' );
        if ( in_array( $sFnc, $aFnc ) ) {
            $sFnc = '';
        }

        // #680
        $sURL = "cl={$sClass}";
        if ( $sFnc ) {
            $sURL .= "&amp;fnc={$sFnc}";
        }
        if ( $sVal = oxConfig::getParameter( 'cnid' ) ) {
            $sURL .= "&amp;cnid={$sVal}";
        }
        if ( $sVal = oxConfig::getParameter( 'mnid' ) ) {
            $sURL .= "&amp;mnid={$sVal}";
        }
        if ( $sVal= oxConfig::getParameter( 'anid' ) ) {
            $sURL .= "&amp;anid={$sVal}";
        }

        if ( $sVal = basename( oxConfig::getParameter( 'page' ) ) ) {
            $sURL .= "&amp;page={$sVal}";
        }

        if ( $sVal = basename( oxConfig::getParameter( 'tpl' ) ) ) {
            $sURL .= "&amp;tpl={$sVal}";
        }

        if ( $sVal = oxConfig::getParameter( 'oxloadid' ) ) {
            $sURL .= "&amp;oxloadid={$sVal}";
        }

        $iPgNr = (int) oxConfig::getParameter( 'pgNr' );
        // don't include page number for navigation
        // it will be done in oxubase::generatePageNavigation
        if ( $blAddPageNr && $iPgNr > 0 ) {
            $sURL .= "&amp;pgNr={$iPgNr}";
        }

        // #1184M - specialchar search
        if ( $sVal = rawurlencode( oxConfig::getParameter( 'searchparam', true ) ) ) {
            $sURL .= "&amp;searchparam={$sVal}";
        }

        if ( $sVal = oxConfig::getParameter( 'searchcnid' ) ) {
            $sURL .= "&amp;searchcnid={$sVal}";
        }

        if ( $sVal = oxConfig::getParameter( 'searchvendor' ) ) {
            $sURL .= "&amp;searchvendor={$sVal}";
        }

        if ( $sVal = oxConfig::getParameter( 'searchmanufacturer' ) ) {
            $sURL .= "&amp;searchmanufacturer={$sVal}";
        }

        if ( $sVal = oxConfig::getParameter( 'searchrecomm' ) ) {
            $sURL .= "&amp;searchrecomm={$sVal}";
        }

        if ( $sVal = oxConfig::getParameter( 'searchtag' ) ) {
            $sURL .= "&amp;searchtag={$sVal}";
        }

        if ( $sVal = oxConfig::getParameter( 'recommid' ) ) {
            $sURL .= "&amp;recommid={$sVal}";
        }

        return $sURL;
    }

    protected function _getSeoRequestParams()
    {
        $sClass = $this->getClassName();
        $sFnc   = $this->getFncName();

        // #921 S
        $aFnc = array( 'tobasket', 'login_noredirect', 'addVoucher' );
        if ( in_array( $sFnc, $aFnc ) ) {
            $sFnc = '';
        }

        // #680
        $sURL = "cl={$sClass}";
        if ( $sFnc ) {
            $sURL .= "&amp;fnc={$sFnc}";
        }
        if ( $sVal = basename( oxConfig::getParameter( 'page' ) ) ) {
            $sURL .= "&amp;page={$sVal}";
        }

        if ( $sVal = basename( oxConfig::getParameter( 'tpl' ) ) ) {
            $sURL .= "&amp;tpl={$sVal}";
        }

        if ( $sVal = oxConfig::getParameter( 'oxloadid' ) ) {
            $sURL .= "&amp;oxloadid={$sVal}";
        }

        $iPgNr = (int) oxConfig::getParameter( 'pgNr' );
        if ( $iPgNr > 0 ) {
            $sURL .= "&amp;pgNr={$iPgNr}";
        }

        return $sURL;
    }

    public function showSearch()
    {
        $blShow = true;
        if ( $this->getConfig()->getConfigParam( 'blDisableNavBars' ) && $this->getIsOrderStep() ) {
            $blShow = false;
        }
        return (int) $blShow;
    }

    public function getRssLinks()
    {
        return $this->_aRssLinks;
    }

    public function getSortColumns()
    {
        if ( $this->_aSortColumns === null ) {
            $this->setSortColumns( $this->getConfig()->getConfigParam( 'aSortCols' ) );
        }
        return $this->_aSortColumns;
    }


    public function setSortColumns( $aSortColumns )
    {
        $this->_aSortColumns = $aSortColumns;
    }

    public function getEditTags()
    {
    }

    public function getRecommSearch()
    {
    }

    public function getPaymentList()
    {
    }

    public function getActiveRecommList()
    {
        if ( $this->_oActiveRecommList === null ) {
            $this->_oActiveRecommList = false;
            if ( $sOxid = oxConfig::getParameter( 'recommid' ) ) {
                $this->_oActiveRecommList = oxNew( 'oxrecommlist' );
                $this->_oActiveRecommList->load( $sOxid );
            }
        }
        return $this->_oActiveRecommList;
    }

    public function getAccessoires()
    {
    }

    public function getCrossSelling()
    {
    }

    public function getSimilarProducts()
    {
    }

    public function getAlsoBoughtTheseProducts()
    {
    }

    public function getArticleId()
    {
    }

    public function getTitle()
    {
        $sTranslationName = 'PAGE_TITLE_'.strtoupper($this->getConfig()->getActiveView()->getClassName());
        $sTranslated = oxRegistry::getLang()->translateString( $sTranslationName, oxRegistry::getLang()->getBaseLanguage(), false );
        return $sTranslationName == $sTranslated? null : $sTranslated;
    }

    public function getActiveLangAbbr()
    {
        // Performance
        if ( !$this->getConfig()->getConfigParam( 'bl_perfLoadLanguages' ) ) {
            return;
        }

        if ( !isset($this->_sActiveLangAbbr ) ) {
            $aLanguages = oxRegistry::getLang()->getLanguageArray();
            while ( list( $sKey, $oVal ) = each( $aLanguages ) ) {
                if ( $oVal->selected ) {
                    $this->_sActiveLangAbbr = $oVal->abbr;
                    break;
                }
            }
        }

        return $this->_sActiveLangAbbr;
    }

    public function addGlobalParams( $oShop = null)
    {
        $oViewConf = parent::addGlobalParams( $oShop );

        $this->_setNrOfArtPerPage();

        return $oViewConf;
    }

    public function getAdditionalParams()
    {
        if ( $this->_sAdditionalParams === null ) {
            // #1018A
            $this->_sAdditionalParams  = parent::getAdditionalParams();
            $this->_sAdditionalParams .= 'cl='.$this->getConfig()->getTopActiveView()->getClassName();

            // #1834M - specialchar search
            $sSearchParamForLink = rawurlencode( oxConfig::getParameter( 'searchparam', true ) );
            if ( isset( $sSearchParamForLink ) ) {
                $this->_sAdditionalParams .= "&amp;searchparam={$sSearchParamForLink}";
            }
            if ( ( $sVar = oxConfig::getParameter( 'searchtag' ) ) ) {
                $this->_sAdditionalParams .= '&amp;searchtag='.rawurlencode( rawurldecode( $sVar ) );
            }
            if ( ( $sVar = oxConfig::getParameter( 'searchcnid' ) ) ) {
                $this->_sAdditionalParams .= '&amp;searchcnid='.rawurlencode( rawurldecode( $sVar ) );
            }
            if ( ( $sVar = oxConfig::getParameter( 'searchvendor' ) ) ) {
                $this->_sAdditionalParams .= '&amp;searchvendor='.rawurlencode( rawurldecode( $sVar ) );
            }
            if ( ( $sVar = oxConfig::getParameter( 'searchmanufacturer' ) ) ) {
                $this->_sAdditionalParams .= '&amp;searchmanufacturer='.rawurlencode( rawurldecode( $sVar ) );
            }
            if ( ( $sVar = oxConfig::getParameter( 'cnid' ) ) ) {
                $this->_sAdditionalParams .= '&amp;cnid='.rawurlencode( rawurldecode( $sVar ) );
            }
            if ( ( $sVar = oxConfig::getParameter( 'mnid' ) ) ) {
                $this->_sAdditionalParams .= '&amp;mnid='.rawurlencode( rawurldecode( $sVar ) );
            }
        }

        return $this->_sAdditionalParams;
    }

    public function generatePageNavigationUrl()
    {
        return $this->getConfig()->getShopHomeURL().$this->_getRequestParams( false );
    }

    protected function _addPageNrParam( $sUrl, $iPage, $iLang = null )
    {
        if ( $iPage ) {
            if ( ( strpos( $sUrl, 'pgNr=' ) ) ) {
                $sUrl = preg_replace('/pgNr=[0-9]*/', 'pgNr='.$iPage, $sUrl);
            } else {
                $sUrl .= ( ( strpos( $sUrl, '?' ) === false ) ? '?' : '&amp;' ) . 'pgNr='.$iPage;
            }
        } else {
           $sUrl = preg_replace('/pgNr=[0-9]*/', '', $sUrl);
           $sUrl = preg_replace('/\&amp\;\&amp\;/', '&amp;', $sUrl);
           $sUrl = preg_replace('/\?\&amp\;/', '?', $sUrl);
           $sUrl = preg_replace('/\&amp\;$/', '', $sUrl);
        }
        return $sUrl;
    }

    public function getPageNavigation()
    {

    }

    public function getPageNavigationLimitedTop( $iPositionCount = 7 )
    {
        $this->_oPageNavigation = $this->generatePageNavigation( $iPositionCount );
        return $this->_oPageNavigation;
    }

    public function getPageNavigationLimitedBottom( $iPositionCount = 11 )
    {
        $this->_oPageNavigation = $this->generatePageNavigation( $iPositionCount );
        return $this->_oPageNavigation;
    }


    public function generatePageNavigation( $iPositionCount = 0 )
    {
        startProfile('generatePageNavigation');

        $pageNavigation = new stdClass();

        $pageNavigation->NrOfPages = $this->_iCntPages;
        $iActPage = $this->getActPage();
        $pageNavigation->actPage   = $iActPage + 1;
        $sUrl = $this->generatePageNavigationUrl();

        if ( $iPositionCount == 0 || ($iPositionCount >= $pageNavigation->NrOfPages) ) {
             $iStartNo = 2;
             $iFinishNo = $pageNavigation->NrOfPages;
             $bStart = false;
             $bFinish =false;
        } else {
            $iTmpVal = $iPositionCount - 3;
            $iTmpVal2 = floor( ( $iPositionCount - 4 ) / 2 );

            // actual page is at the start
            if ( $pageNavigation->actPage <= $iTmpVal ) {
                $iStartNo = 2;
                $iFinishNo = $iTmpVal + 1;
                $bStart = false;
                $bFinish = true;
            // actual page is at the end
            } elseif ( $pageNavigation->actPage >= $pageNavigation->NrOfPages - $iTmpVal ) {
                $iStartNo = $pageNavigation->NrOfPages - $iTmpVal;
                $iFinishNo = $pageNavigation->NrOfPages - 1;
                $bStart = true;
                $bFinish = false;
            // actual page is in the midle
            } else {
                $iStartNo = $pageNavigation->actPage - $iTmpVal2;
                $iFinishNo = $pageNavigation->actPage + $iTmpVal2;
                $bStart = true;
                $bFinish = true;
            }
        }

        if ( $iActPage > 0) {
            $pageNavigation->previousPage = $this->_addPageNrParam( $sUrl, $iActPage - 1 );
        }

        if ( $iActPage < $pageNavigation->NrOfPages - 1 ) {
            $pageNavigation->nextPage = $this->_addPageNrParam( $sUrl, $iActPage + 1 );
        }

        if ( $pageNavigation->NrOfPages > 1 ) {

            for ( $i=1; $i < $pageNavigation->NrOfPages + 1; $i++ ) {

                if ( $i == 1 || $i == $pageNavigation->NrOfPages || ( $i >= $iStartNo && $i <= $iFinishNo ) ) {
                    $page = new stdClass();
                    $page->url = $this->_addPageNrParam( $sUrl, $i - 1 );
                    $page->selected = ( $i == $pageNavigation->actPage ) ? 1 : 0;
                    $pageNavigation->changePage[$i] = $page;
                }
            }

            // first/last one
            $pageNavigation->firstpage = $this->_addPageNrParam( $sUrl, 0 );
            $pageNavigation->lastpage  = $this->_addPageNrParam( $sUrl, $pageNavigation->NrOfPages - 1 );
        }

        stopProfile('generatePageNavigation');

        return $pageNavigation;
    }

    public function render()
    {
        foreach ( array_keys( $this->_oaComponents ) as $sComponentName ) {
            $this->_aViewData[$sComponentName] = $this->_oaComponents[$sComponentName]->render();
        }

        parent::render();

        if ( $this->getIsOrderStep() ) {

            // disabling navigation during order ...
            if ( $this->getConfig()->getConfigParam( 'blDisableNavBars' ) ) {
                $this->_iNewsRealStatus = 1;
                $this->setShowNewsletter( 0 );
            }
        }
        return $this->_sThisTemplate;
    }

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

    public function setViewProduct( $oProduct )
    {
        $this->_oProduct = $oProduct;
    }

    public function getViewProductList()
    {
        return $this->_aArticleList;
    }

    public function getActPage()
    {
        if ( $this->_iActPage === null ) {
            $this->_iActPage = ( int ) oxConfig::getParameter( 'pgNr' );
            $this->_iActPage = ( $this->_iActPage < 0 ) ? 0 : $this->_iActPage;
        }
        return $this->_iActPage;
    }

    public function getActTag()
    {
        if ( $this->_oActTag === null ) {
            $this->_oActTag = new stdClass();
            $this->_oActTag->sTag = $sTag = oxConfig::getParameter("searchtag", 1);
            $oSeoEncoderTag = oxRegistry::get("oxSeoEncoderTag");

            $sLink = false;
            if ( oxRegistry::getUtils()->seoIsActive() ) {
                $sLink = $oSeoEncoderTag->getTagUrl( $sTag, oxRegistry::getLang()->getBaseLanguage() );
            }

            $this->_oActTag->link = $sLink ? $sLink : $this->getConfig()->getShopHomeURL().$oSeoEncoderTag->getStdTagUri( $sTag, false );
        }
        return $this->_oActTag;
    }

    public function getActVendor()
    {
        // if active vendor is not set yet - trying to load it from request params
        // this may be usefull when category component was unable to load active vendor
        // and we still need some object to mount navigation info
        if ( $this->_oActVendor === null ) {
            $this->_oActVendor = false;
            $sVendorId = oxConfig::getParameter( 'cnid' );
            $sVendorId = $sVendorId ? str_replace( 'v_', '', $sVendorId ) : $sVendorId;
            $oVendor = oxNew( 'oxvendor' );
            if ( $oVendor->load( $sVendorId ) ) {
                $this->_oActVendor = $oVendor;
            }
        }

        return $this->_oActVendor;
    }

    public function getActManufacturer()
    {
        // if active Manufacturer is not set yet - trying to load it from request params
        // this may be usefull when category component was unable to load active Manufacturer
        // and we still need some object to mount navigation info
        if ( $this->_oActManufacturer === null ) {

            $this->_oActManufacturer = false;
            $sManufacturerId = oxConfig::getParameter( 'mnid' );
            $oManufacturer = oxNew( 'oxmanufacturer' );
            if ( $oManufacturer->load( $sManufacturerId ) ) {
                $this->_oActManufacturer = $oManufacturer;
            }
        }

        return $this->_oActManufacturer;
    }

    public function setActVendor( $oVendor )
    {
        $this->_oActVendor = $oVendor;
    }

    public function setActManufacturer( $oManufacturer )
    {
        $this->_oActManufacturer = $oManufacturer;
    }

    public function getActSearch()
    {
        if ( $this->_oActSearch === null ) {
            $this->_oActSearch = new stdClass();
            $sUrl = $this->getConfig()->getShopHomeURL();
            $this->_oActSearch->link = "{$sUrl}cl=search";
        }
        return $this->_oActSearch;
    }

    public function getCategoryTree()
    {
        return $this->_oCategoryTree;
    }

    public function setCategoryTree( $oCatTree )
    {
        $this->_oCategoryTree = $oCatTree;
    }

    public function getManufacturerTree()
    {
        return $this->_oManufacturerTree;
    }

    public function setManufacturerTree( $oManufacturerTree )
    {
        $this->_oManufacturerTree = $oManufacturerTree;
    }

    public function getAddUrlParams()
    {
    }

    public function getTop5ArticleList( $iCount = null )
    {
        if ( $this->_blTop5Action ) {
            if ( $this->_aTop5ArticleList === null ) {
                $this->_aTop5ArticleList = false;
                $myConfig = $this->getConfig();
                if ( $myConfig->getConfigParam( 'bl_perfLoadAktion' ) ) {
                    // top 5 articles
                    $oArtList = oxNew( 'oxarticlelist' );
                    $oArtList->loadTop5Articles( $iCount );
                    if ( $oArtList->count() ) {
                        $this->_aTop5ArticleList = $oArtList;
                    }
                }
            }
        }
        return $this->_aTop5ArticleList;
    }

    public function getBargainArticleList()
    {
        if ( $this->_blBargainAction ) {
            if ( $this->_aBargainArticleList === null ) {
                $this->_aBargainArticleList = array();
                if ( $this->getConfig()->getConfigParam( 'bl_perfLoadAktion' ) ) {
                    $oArtList = oxNew( 'oxarticlelist' );
                    $oArtList->loadActionArticles( 'OXBARGAIN' );
                    if ( $oArtList->count() ) {
                        $this->_aBargainArticleList = $oArtList;
                    }
                }
            }
        }
        return $this->_aBargainArticleList;
    }

    public function isLowOrderPrice()
    {
        if ( $this->_blLowOrderPrice === null && ( $oBasket = $this->getSession()->getBasket() ) ) {
            $this->_blLowOrderPrice = $oBasket->isBelowMinOrderPrice();
        }

        return $this->_blLowOrderPrice;
    }

    public function getMinOrderPrice()
    {
        if ( $this->_sMinOrderPrice === null && $this->isLowOrderPrice() ) {
            $dMinOrderPrice = oxPrice::getPriceInActCurrency( $this->getConfig()->getConfigParam( 'iMinOrderPrice' ) );
            $this->_sMinOrderPrice = oxRegistry::getLang()->formatCurrency( $dMinOrderPrice );
        }
        return $this->_sMinOrderPrice;
    }

    public function getNewsRealStatus()
    {
        return $this->_iNewsRealStatus;
    }

    protected function _canRedirect()
    {
        foreach ( $this->_aBlockRedirectParams as $sParam ) {
            if ( oxConfig::getParameter( $sParam ) !== null ) {
                return false;
            }
        }

        return true;
    }

    public function getProduct()
    {
    }

    public function getManufacturerlist()
    {
        return $this->_aManufacturerlist;
    }

    public function setManufacturerlist( $aList )
    {
        $this->_aManufacturerlist = $aList;
    }

    public function setRootVendor( $oVendor )
    {
        $this->_oRootVendor = $oVendor;
    }

    public function getRootVendor()
    {
        return $this->_oRootVendor;
    }

    public function setRootManufacturer( $oManufacturer )
    {
        $this->_oRootManufacturer = $oManufacturer;
    }

    public function getRootManufacturer()
    {
        return $this->_oRootManufacturer;
    }

    public function getVendorId()
    {
        if ( $this->_sVendorId === null ) {
            $this->_sVendorId = false;
            if ( ( $oVendor = $this->getActVendor() ) ) {
                $this->_sVendorId = $oVendor->getId();
            }
        }
        return $this->_sVendorId;
    }

    public function getManufacturerId()
    {
        if ( $this->_sManufacturerId === null ) {
            $this->_sManufacturerId = false;
            if ( ( $oManufacturer = $this->getActManufacturer() ) ) {
                $this->_sManufacturerId = $oManufacturer->getId();
            }
        }
        return $this->_sManufacturerId;
    }

    public function getSearchCatTree()
    {
        return $this->_aSearchCatTree;
    }

    public function setSearchCatTree( $aTree )
    {
        $this->_aSearchCatTree = $aTree;
    }

    public function getCatMoreUrl()
    {
        return $this->getConfig()->getShopHomeURL().'cnid=oxmore';
    }

    public function getCatTreePath()
    {
        return $this->_sCatTreePath;
    }

    public function getContentByIdent( $sIdent )
    {
        if ( !isset( $this->_aContents[$sIdent] ) ) {
            $this->_aContents[$sIdent] = oxNew( 'oxcontent' );
            $this->_aContents[$sIdent]->loadByIdent( $sIdent );
        }
        return $this->_aContents[$sIdent];
    }

    public function getContentCategory()
    {
        return false;
    }

    public function getMustFillFields()
    {
        if ( $this->_aMustFillFields === null ) {
            $this->_aMustFillFields = false;

            // passing must-be-filled-fields info
            $aMustFillFields = $this->getConfig()->getConfigParam( 'aMustFillFields' );
            if ( is_array( $aMustFillFields ) ) {
                $this->_aMustFillFields = array_flip( $aMustFillFields );
            }
        }
        return $this->_aMustFillFields;
    }

    public function isFieldRequired( $sField )
    {
        if ( $aMustFillFields = $this->getMustFillFields() ) {
            if ( isset( $aMustFillFields[$sField] ) ) {
                return true;
            }
        }

        return false;
    }

    public function getFormId()
    {
        if ( $this->_sFormId === null ) {
            $this->_sFormId = oxUtilsObject::getInstance()->generateUId();
            oxSession::setVar( 'sessionuformid', $this->_sFormId );
        }

        return $this->_sFormId;
    }

    public function canAcceptFormData()
    {
        if ( $this->_blCanAcceptFormData === null ) {
            $this->_blCanAcceptFormData = false;

            $sFormId = oxConfig::getParameter( "uformid" );
            $sSessionFormId = oxRegistry::getSession()->getVariable( "sessionuformid" );

            // testing if form and session ids matches
            if ( $sFormId && $sFormId === $sSessionFormId ) {
                $this->_blCanAcceptFormData = true;
            }

            // regenerating form data
            $this->getFormId();
        }
        return $this->_blCanAcceptFormData;
    }

    public function getPromoFinishedList()
    {
        if (isset($this->_oPromoFinishedList)) {
            return $this->_oPromoFinishedList;
        }
        $this->_oPromoFinishedList = oxNew( 'oxActionList' );
        $this->_oPromoFinishedList->loadFinishedByCount(2);
        return $this->_oPromoFinishedList;
    }

    public function getPromoCurrentList()
    {
        if (isset($this->_oPromoCurrentList)) {
            return $this->_oPromoCurrentList;
        }
        $this->_oPromoCurrentList = oxNew( 'oxActionList' );
        $this->_oPromoCurrentList->loadCurrent();
        return $this->_oPromoCurrentList;
    }

    public function getPromoFutureList()
    {
        if (isset($this->_oPromoFutureList)) {
            return $this->_oPromoFutureList;
        }
        $this->_oPromoFutureList = oxNew( 'oxActionList' );
        $this->_oPromoFutureList->loadFutureByCount(2);
        return $this->_oPromoFutureList;
    }

    public function getShowPromotionList()
    {
        if (isset($this->_blShowPromotions)) {
            return $this->_blShowPromotions;
        }
        $this->_blShowPromotions = false;
        if (oxNew('oxActionList')->areAnyActivePromotions()) {
            $this->_blShowPromotions = ( count( $this->getPromoFinishedList() ) + count( $this->getPromoCurrentList() ) + count( $this->getPromoFutureList() ) ) > 0;
        }
        return $this->_blShowPromotions;
    }

    public function isEnabledPrivateSales()
    {
        if ( $this->_blEnabledPrivateSales === null ) {
            $this->_blEnabledPrivateSales = (bool) $this->getConfig()->getConfigParam( 'blPsLoginEnabled' );
            if ( $this->_blEnabledPrivateSales && ( $blCanPreview = oxRegistry::getUtils()->canPreview() ) !== null ) {
                $this->_blEnabledPrivateSales = !$blCanPreview;
            }
        }
        return $this->_blEnabledPrivateSales;
    }

    public function getFieldValidationErrors()
    {
        return oxRegistry::get("oxInputValidator")->getFieldValidationErrors();
    }

    public function getBreadCrumb()
    {
        return null;
    }

    public function setRootCatChanged( $blRootCatChanged )
    {
        $this->_blRootCatChanged = $blRootCatChanged;
    }

    public function isRootCatChanged()
    {
        return $this->_blRootCatChanged;
    }

    public function getInvoiceAddress()
    {
        if ( $this->_aInvoiceAddress == null ) {
            $aAddress = oxConfig::getParameter( 'invadr');
            if ( $aAddress ) {
                $this->_aInvoiceAddress = $aAddress;
            }
        }
        return $this->_aInvoiceAddress;
    }

    public function getDeliveryAddress()
    {
        if ( $this->_aDeliveryAddress == null ) {
            $oConfig = $this->getConfig();
            //do not show deladr if address was reloaded
            if ( !$oConfig->getRequestParameter( 'reloadaddress' ) ) {
                $this->_aDeliveryAddress = $oConfig->getRequestParameter( 'deladr');
            }
        }
        return $this->_aDeliveryAddress;
    }

    public function setDeliveryAddress($aDeliveryAddress)
    {
        $this->_aDeliveryAddress = $aDeliveryAddress;
    }

    public function setInvoiceAddress( $aAddress )
    {
        $this->_aInvoiceAddress = $aAddress;
    }

    public function getActiveUsername()
    {
        if ( $this->_sActiveUsername == null ) {
            $this->_sActiveUsername = false;
            $sUsername = oxConfig::getParameter( 'lgn_usr' );
            if ( $sUsername ) {
                $this->_sActiveUsername = $sUsername;
            } elseif ( $oUser = $this->getUser() ) {
                $this->_sActiveUsername = $oUser->oxuser__oxusername->value;
            }
        }
        return $this->_sActiveUsername;
    }

    public function getWishlistUserId()
    {
        return oxConfig::getParameter( 'wishid' );
    }

    public function getSearchCatId()
    {
    }

    public function getSearchVendor()
    {
    }

    public function getSearchManufacturer()
    {
    }

    public function getLastProducts()
    {

    }

    public function getNewBasketItemMsgType()
    {
        return (int) $this->getConfig()->getConfigParam( "iNewBasketItemMessage" );
    }

    public function isActive( $sName )
    {
        return $this->getConfig()->getConfigParam( "bl".$sName."Enabled" );
    }

    public function isFbWidgetVisible()
    {
        if ( $this->_blFbWidgetsOn === null ) {
            $oUtils = oxRegistry::get("oxUtilsServer");

            // reading ..
            $this->_blFbWidgetsOn = (bool) $oUtils->getOxCookie( "fbwidgetson" );
        }
        return $this->_blFbWidgetsOn;
    }

    public function isEnabledDownloadableFiles()
    {
        return (bool) $this->getConfig()->getConfigParam( "blEnableDownloads" );
    }

    public function showRememberMe()
    {
        return (bool) $this->getConfig()->getConfigParam('blShowRememberMe');
    }

    public function isVatIncluded()
    {
        $blResult = true;
        $oUser = $this->getUser();
        $oConfig = $this->getConfig();

        if ( $oConfig->getConfigParam( 'blShowNetPrice' ) || $oConfig->getConfigParam( 'bl_perfCalcVatOnlyForBasketOrder' ) ) {
            $blResult = false;
        } elseif ( $oUser && $oUser->isPriceViewModeNetto() ) {
            $blResult = false;
        }

        return $blResult;
    }

    public function isPriceCalculated()
    {
        return (bool) $this->getConfig()->getConfigParam( 'bl_perfLoadPrice' );
    }

    public function showTags()
    {
         return (bool) $this->_blShowTagCloud && $this->getConfig()->getConfigParam( "blShowTags" );
    }

    public function getWishlistName()
    {
        if ( $this->getUser() ) {
            $sUserId = oxConfig::getParameter( 'wishid') ? oxConfig::getParameter( 'wishid' ): oxRegistry::getSession()->getVariable( 'wishid');
            if ( $sUserId ) {
                $oWishUser = oxNew( 'oxuser' );
                if ( $oWishUser->load( $sUserId ) ) {
                    return $oWishUser;
                }
            }
        }
        return false;
    }

    public function getWidgetLink()
    {
        return oxRegistry::getConfig()->getWidgetUrl();
    }
}