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 $_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 $_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 (oxRegistry::getConfig()->getRequestParameter('_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 no index/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;
        }

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


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

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

        // #0004798: SSL should be included in viewId
        if ($oConfig->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 = $this->getConfig()->getRequestParameter('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 ($this->getConfig()->getRequestParameter('ldtype')) {
                oxRegistry::getSession()->setVariable('ldtype', $this->_sListDisplayType);
            }
        }

        return $this->_sListDisplayType;
    }

    public function getCustomListDisplayType()
    {
        if ($this->_sCustomListDisplayType == null) {
            $this->_sCustomListDisplayType = $this->getConfig()->getRequestParameter('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');

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

        if ($sSortBy && oxDb::getInstance()->isValidFieldName($sSortBy) && $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 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 ($this->getConfig()->getRequestParameter('cur')) {
            $this->_iViewIndexState = VIEW_INDEXSTATE_NOINDEXNOFOLLOW;
        } else {
            switch ($this->getConfig()->getRequestParameter('fnc')) {
                case 'tocomparelist':
                case 'tobasket':
                    $this->_iViewIndexState = VIEW_INDEXSTATE_NOINDEXNOFOLLOW;
                    break;
            }
        }

        return $this->_iViewIndexState;
    }

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

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

    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
        $oSession = oxRegistry::getSession();
        if (($iNrofArticles = (int) oxRegistry::getConfig()->getRequestParameter('_artperpage'))) {
            // M45 Possibility to push any "Show articles per page" number parameter
            $iNrofCatArticles = (in_array($iNrofArticles, $aNrofCatArticles)) ? $iNrofArticles : $iNrofCatArticles;
            $oViewConf->setViewConfigParam('iartPerPage', $iNrofCatArticles);
            $oSession->setVariable('_artperpage', $iNrofCatArticles);
        } elseif (($iSessArtPerPage = $oSession->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()
    {
        $oConfig = $this->getConfig();
        $aParams['cnid'] = $this->getCategoryId();
        $aParams['mnid'] = $oConfig->getRequestParameter('mnid');

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

        $aParams['recommid'] = $oConfig->getRequestParameter('recommid');

        $aParams['searchrecomm'] = $oConfig->getRequestParameter('searchrecomm', true);
        $aParams['searchparam'] = $oConfig->getRequestParameter('searchparam', true);
        $aParams['searchtag'] = $oConfig->getRequestParameter('searchtag', true);

        $aParams['searchvendor'] = $oConfig->getRequestParameter('searchvendor');
        $aParams['searchcnid'] = $oConfig->getRequestParameter('searchcnid');
        $aParams['searchmanufacturer'] = $oConfig->getRequestParameter('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;
    }


    public function getPageTitle()
    {
        $sTitle = '';

        $aTitleParts = array();
        $aTitleParts[] = $this->getTitlePrefix();
        $aTitleParts[] = $this->getTitle();
        $aTitleParts[] = $this->getTitleSuffix();
        $aTitleParts[] = $this->getTitlePageSuffix();

        $aTitleParts = array_filter($aTitleParts);

        if (count($aTitleParts)) {
            $sTitle = implode(' | ', $aTitleParts);
        }


        return $sTitle;
    }


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

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

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

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

        return $sRet;
    }

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

        $oConfig = $this->getConfig();

        if (oxRegistry::getUtils()->seoIsActive()) {
            if ($oDisplayObj = $this->_getSubject($iLang)) {
                $sUrl = $oDisplayObj->getLink($iLang);
            } else {
                $oEncoder = oxRegistry::get("oxSeoEncoder");
                $sConstructedUrl = $oConfig->getShopHomeURL($iLang) . $this->_getSeoRequestParams();
                $sUrl = $oEncoder->getStaticUrl($sConstructedUrl, $iLang);
            }
        }

        if (!$sUrl) {
            $sConstructedUrl = $oConfig->getShopCurrentURL($iLang) . $this->_getRequestParams();
            $sUrl = oxRegistry::get("oxUtilsUrl")->processUrl($sConstructedUrl, true, null, $iLang);
        }

        return $sUrl;
    }


    public function getLink($iLang = null)
    {
        return $this->_addPageNrParam($this->getBaseLink($iLang), $this->getActPage(), $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 = oxRegistry::getConfig()->getRequestParameter('cnid')) {
            $sURL .= "&amp;cnid={$sVal}";
        }
        if ($sVal = oxRegistry::getConfig()->getRequestParameter('mnid')) {
            $sURL .= "&amp;mnid={$sVal}";
        }
        if ($sVal = oxRegistry::getConfig()->getRequestParameter('anid')) {
            $sURL .= "&amp;anid={$sVal}";
        }

        if ($sVal = basename(oxRegistry::getConfig()->getRequestParameter('page'))) {
            $sURL .= "&amp;page={$sVal}";
        }

        if ($sVal = basename(oxRegistry::getConfig()->getRequestParameter('tpl'))) {
            $sURL .= "&amp;tpl={$sVal}";
        }

        if ($sVal = oxRegistry::getConfig()->getRequestParameter('oxloadid')) {
            $sURL .= "&amp;oxloadid={$sVal}";
        }

        $iPgNr = (int) oxRegistry::getConfig()->getRequestParameter('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(oxRegistry::getConfig()->getRequestParameter('searchparam', true))) {
            $sURL .= "&amp;searchparam={$sVal}";
        }

        if ($sVal = oxRegistry::getConfig()->getRequestParameter('searchcnid')) {
            $sURL .= "&amp;searchcnid={$sVal}";
        }

        if ($sVal = oxRegistry::getConfig()->getRequestParameter('searchvendor')) {
            $sURL .= "&amp;searchvendor={$sVal}";
        }

        if ($sVal = oxRegistry::getConfig()->getRequestParameter('searchmanufacturer')) {
            $sURL .= "&amp;searchmanufacturer={$sVal}";
        }

        if ($sVal = oxRegistry::getConfig()->getRequestParameter('searchrecomm')) {
            $sURL .= "&amp;searchrecomm={$sVal}";
        }

        if ($sVal = oxRegistry::getConfig()->getRequestParameter('searchtag')) {
            $sURL .= "&amp;searchtag={$sVal}";
        }

        if ($sVal = oxRegistry::getConfig()->getRequestParameter('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(oxRegistry::getConfig()->getRequestParameter('page'))) {
            $sURL .= "&amp;page={$sVal}";
        }

        if ($sVal = basename(oxRegistry::getConfig()->getRequestParameter('tpl'))) {
            $sURL .= "&amp;tpl={$sVal}";
        }

        if ($sVal = oxRegistry::getConfig()->getRequestParameter('oxloadid')) {
            $sURL .= "&amp;oxloadid={$sVal}";
        }

        $iPgNr = (int) oxRegistry::getConfig()->getRequestParameter('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 = $this->getConfig()->getRequestParameter('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()
    {
        $oLang = oxRegistry::getLang();
        $sTranslationName = 'PAGE_TITLE_' . strtoupper($this->getConfig()->getActiveView()->getClassName());
        $sTranslated = $oLang->translateString($sTranslationName, oxRegistry::getLang()->getBaseLanguage(), false);

        return $sTranslationName == $sTranslated ? null : $sTranslated;
    }

    public function getActiveLangAbbr()
    {
        if (!isset($this->_sActiveLangAbbr)) {
            $languageService = oxRegistry::getLang();
            if ($this->getConfig()->getConfigParam('bl_perfLoadLanguages')) {
                $languages = $languageService->getLanguageArray();
                while (list($key, $language) = each($languages)) {
                    if ($language->selected) {
                        $this->_sActiveLangAbbr = $language->abbr;
                        break;
                    }
                }
            } else {
                // Performance
                // use oxid shop internal languageAbbr, this might be correct in the most cases but not guaranteed to be that
                // configured in the admin backend for that language
                $this->_sActiveLangAbbr = $languageService->getLanguageAbbr();
            }
        }

        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(oxRegistry::getConfig()->getRequestParameter('searchparam', true));
            if (isset($sSearchParamForLink)) {
                $this->_sAdditionalParams .= "&amp;searchparam={$sSearchParamForLink}";
            }
            if (($sVar = oxRegistry::getConfig()->getRequestParameter('searchtag'))) {
                $this->_sAdditionalParams .= '&amp;searchtag=' . rawurlencode(rawurldecode($sVar));
            }
            if (($sVar = oxRegistry::getConfig()->getRequestParameter('searchcnid'))) {
                $this->_sAdditionalParams .= '&amp;searchcnid=' . rawurlencode(rawurldecode($sVar));
            }
            if (($sVar = oxRegistry::getConfig()->getRequestParameter('searchvendor'))) {
                $this->_sAdditionalParams .= '&amp;searchvendor=' . rawurlencode(rawurldecode($sVar));
            }
            if (($sVar = oxRegistry::getConfig()->getRequestParameter('searchmanufacturer'))) {
                $this->_sAdditionalParams .= '&amp;searchmanufacturer=' . rawurlencode(rawurldecode($sVar));
            }
            if (($sVar = oxRegistry::getConfig()->getRequestParameter('cnid'))) {
                $this->_sAdditionalParams .= '&amp;cnid=' . rawurlencode(rawurldecode($sVar));
            }
            if (($sVar = oxRegistry::getConfig()->getRequestParameter('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;
        } else {
            $iTmpVal = $iPositionCount - 3;
            $iTmpVal2 = floor(($iPositionCount - 4) / 2);

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

        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 ) $this->getConfig()->getRequestParameter('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 = $this->getConfig()->getRequestParameter("searchtag", 1);
            $oSeoEncoderTag = oxRegistry::get("oxSeoEncoderTag");

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

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

        return $this->_oActTag;
    }

    public function getActVendor()
    {
        // if active vendor is not set yet - trying to load it from request params
        // this may be useful 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 = $this->getConfig()->getRequestParameter('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 useful 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 = $this->getConfig()->getRequestParameter('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 ($this->getConfig()->getRequestParameter($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 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();
            oxRegistry::getSession()->setVariable('sessionuformid', $this->_sFormId);
        }

        return $this->_sFormId;
    }

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

            $sFormId = $this->getConfig()->getRequestParameter("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 = $this->getConfig()->getRequestParameter('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 = $this->getConfig()->getRequestParameter('lgn_usr');
            if ($sUsername) {
                $this->_sActiveUsername = $sUsername;
            } elseif ($oUser = $this->getUser()) {
                $this->_sActiveUsername = $oUser->oxuser__oxusername->value;
            }
        }

        return $this->_sActiveUsername;
    }

    public function getWishlistUserId()
    {
        return $this->getConfig()->getRequestParameter('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();

        $blShowNetPriceParameter = $oConfig->getConfigParam('blShowNetPrice');
        $blPerfCalcVatOnlyForBasketOrderParameter = $oConfig->getConfigParam('bl_perfCalcVatOnlyForBasketOrder');
        if ($blShowNetPriceParameter || $blPerfCalcVatOnlyForBasketOrderParameter) {
            $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()) {
            $sWishId = $this->getConfig()->getRequestParameter('wishid');
            $sUserId = ($sWishId) ? $sWishId : oxRegistry::getSession()->getVariable('wishid');
            if ($sUserId) {
                $oWishUser = oxNew('oxUser');
                if ($oWishUser->load($sUserId)) {
                    return $oWishUser;
                }
            }
        }

        return false;
    }

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