alist.php

Go to the documentation of this file.

<?php

class aList extends oxUBase
{

    protected $_iAllArtCnt = 0;

    protected $_iCntPages = 0;

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

    protected $_sThisMoreTemplate = 'page/list/morecategories.tpl';

    protected $_sCatPathString = null;

    protected $_blShowSorting = true;

    protected $_aAttributes = null;

    protected $_aCatArtList = null;

    protected $_blHasVisibleSubCats = null;

    protected $_aSubCatList = null;

    protected $_oPageNavigation = null;

    protected $_blIsCat = null;

    protected $_oRecommList = null;

    protected $_sCatTitle = null;

    protected $_blShowTagCloud = true;

    protected $_blBargainAction = false;

    protected $_aSimilarRecommListIds = null;


    public function getViewId()
    {
        if (!isset($this->_sViewId)) {
            $sCatId = oxRegistry::getConfig()->getRequestParameter('cnid');
            $iActPage = $this->getActPage();
            $iArtPerPage = oxRegistry::getSession()->getVariable('_artperpage');
            $sListDisplayType = $this->_getListDisplayType();
            $sParentViewId = parent::getViewId();

            // shorten it
            $this->_sViewId = md5(
                $sParentViewId . '|' . $sCatId . '|' . $iActPage . '|' . $iArtPerPage . '|' . $sListDisplayType
            );

        }

        return $this->_sViewId;
    }

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

        $oCategory = null;
        $blContinue = true;
        $this->_blIsCat = false;

        // A. checking for fake "more" category
        if ('oxmore' == $myConfig->getRequestParameter('cnid')) {
            // overriding some standard value and parameters
            $this->_sThisTemplate = $this->_sThisMoreTemplate;
            $oCategory = oxNew('oxcategory');
            $oCategory->oxcategories__oxactive = new oxField(1, oxField::T_RAW);
            $this->setActiveCategory($oCategory);

            $this->_blShowTagCloud = true;

        } elseif (($oCategory = $this->getActiveCategory())) {
            $blContinue = ( bool ) $oCategory->oxcategories__oxactive->value;
            $this->_blIsCat = true;
            $this->_blBargainAction = true;
        }


        // category is inactive ?
        if (!$blContinue || !$oCategory) {
            oxRegistry::getUtils()->redirect($myConfig->getShopURL() . 'index.php', true, 302);
        }

        $oCat = $this->getActiveCategory();
        if ($oCat && $myConfig->getConfigParam('bl_rssCategories')) {
            $oRss = oxNew('oxrssfeed');
            $this->addRssFeed(
                $oRss->getCategoryArticlesTitle($oCat),
                $oRss->getCategoryArticlesUrl($oCat),
                'activeCategory'
            );
        }

        //checking if actual pages count does not exceed real articles page count
        $this->getArticleList();

        if ($this->_blIsCat) {
            $this->_checkRequestedPage();
        }

        parent::render();

        // processing list articles
        $this->_processListArticles();

        return $this->getTemplateName();
    }

    protected function _checkRequestedPage()
    {
        $iPageCnt = $this->getPageCount();
        $iCurrentPageNumber = $this->getActPage();
        if ($iCurrentPageNumber && ($iPageCnt - 1) < $iCurrentPageNumber) {
            // redirecting to first page in case requested page does not exist
            if ($iPageCnt) {
                oxRegistry::getUtils()->redirect($this->getActiveCategory()->getLink(), false);
            } else {
                // display error if category has no products, but page number is entered
                $this->_iActPage = 0;
                oxRegistry::getUtils()->handlePageNotFoundError($this->getActiveCategory()->getLink());
            }
        }
    }

    protected function _processListArticles()
    {
        if ($aArtList = $this->getArticleList()) {
            $iLinkType = $this->_getProductLinkType();
            $sAddDynParams = $this->getAddUrlParams();
            $sAddSeoParams = $this->getAddSeoUrlParams();

            foreach ($aArtList as $oArticle) {
                $oArticle->setLinkType($iLinkType);

                // appending dynamic urls
                if ($sAddDynParams) {
                    $oArticle->appendStdLink($sAddDynParams);
                }

                // appending seo urls
                if ($sAddSeoParams) {
                    $oArticle->appendLink($sAddSeoParams);
                }
            }
        }
    }


    public function getAddUrlParams()
    {
        $sParams = parent::getAddUrlParams();
        if (!oxRegistry::getUtils()->seoIsActive()) {
            $iPgNr = (int) oxRegistry::getConfig()->getRequestParameter('pgNr');
            if ($iPgNr > 0) {
                $sParams .= ($sParams ? '&amp;' : '') . "pgNr={$iPgNr}";
            }
        }

        return $sParams;
    }

    public function getAddSeoUrlParams()
    {
    }

    protected function _getProductLinkType()
    {
        $iCatType = OXARTICLE_LINKTYPE_CATEGORY;
        if (($oCat = $this->getActiveCategory()) && $oCat->isPriceCategory()) {
            $iCatType = OXARTICLE_LINKTYPE_PRICECATEGORY;
        }

        return $iCatType;
    }

    public function executefilter()
    {
        $iLang = oxRegistry::getLang()->getBaseLanguage();
        // store this into session
        $aFilter = oxRegistry::getConfig()->getRequestParameter('attrfilter', true);
        $sActCat = oxRegistry::getConfig()->getRequestParameter('cnid');

        if (!empty($aFilter)) {
            $aSessionFilter = oxRegistry::getSession()->getVariable('session_attrfilter');
            //fix for #2904 - if language will be changed attributes of this category will be deleted from session
            //and new filters for active language set.
            $aSessionFilter[$sActCat] = null;
            $aSessionFilter[$sActCat][$iLang] = $aFilter;
            oxRegistry::getSession()->setVariable('session_attrfilter', $aSessionFilter);
        }
    }

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

        $iNrofCatArticles = (int) $myConfig->getConfigParam('iNrofCatArticles');
        $iNrofCatArticles = $iNrofCatArticles ? $iNrofCatArticles : 1;

        // load only articles which we show on screen
        $oArtList = oxNew('oxarticlelist');
        $oArtList->setSqlLimit($iNrofCatArticles * $this->_getRequestPageNr(), $iNrofCatArticles);
        $oArtList->setCustomSorting($this->getSortingSql($this->getSortIdent()));

        if ($oCategory->isPriceCategory()) {
            $dPriceFrom = $oCategory->oxcategories__oxpricefrom->value;
            $dPriceTo = $oCategory->oxcategories__oxpriceto->value;

            $this->_iAllArtCnt = $oArtList->loadPriceArticles($dPriceFrom, $dPriceTo, $oCategory);
        } else {
            $aSessionFilter = oxRegistry::getSession()->getVariable('session_attrfilter');

            $sActCat = oxRegistry::getConfig()->getRequestParameter('cnid');
            $this->_iAllArtCnt = $oArtList->loadCategoryArticles($sActCat, $aSessionFilter);
        }

        $this->_iCntPages = round($this->_iAllArtCnt / $iNrofCatArticles + 0.49);

        return $oArtList;
    }

    public function getActPage()
    {
        //Fake oxmore category has no subpages so we can set the page number to zero
        if ('oxmore' == oxRegistry::getConfig()->getRequestParameter('cnid')) {
            return 0;
        }

        return $this->_getRequestPageNr();
    }

    protected function _getRequestPageNr()
    {
        return parent::getActPage();
    }

    protected function _getListDisplayType()
    {
        $sListDisplayType = oxRegistry::getSession()->getVariable('ldtype');

        if (is_null($sListDisplayType)) {
            $sListDisplayType = oxRegistry::getConfig()->getConfigParam('sDefaultListDisplayType');
        }

        return $sListDisplayType;
    }

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

    protected function _getCatPathString()
    {
        if ($this->_sCatPathString === null) {

            // marking as already set
            $this->_sCatPathString = false;

            //fetching category path
            if (is_array($aPath = $this->getCatTreePath())) {

                $oStr = getStr();
                $this->_sCatPathString = '';
                foreach ($aPath as $oCat) {
                    if ($this->_sCatPathString) {
                        $this->_sCatPathString .= ', ';
                    }
                    $this->_sCatPathString .= $oStr->strtolower($oCat->oxcategories__oxtitle->value);
                }
            }
        }

        return $this->_sCatPathString;
    }

    protected function _prepareMetaDescription($sMeta, $iLength = 1024, $blDescTag = false)
    {
        $sDescription = '';
        // appending parent title
        if ($oCategory = $this->getActiveCategory()) {
            if (($oParent = $oCategory->getParentCategory())) {
                $sDescription .= " {$oParent->oxcategories__oxtitle->value} -";
            }

            // adding category title
            $sDescription .= " {$oCategory->oxcategories__oxtitle->value}.";
        }

        // and final component ..
        //changed for #2776
        if (($sSuffix = $this->getConfig()->getActiveShop()->oxshops__oxtitleprefix->value)) {
            $sDescription .= " {$sSuffix}";
        }

        // making safe for output
        $sDescription = getStr()->html_entity_decode($sDescription);
        $sDescription = getStr()->strip_tags($sDescription);
        $sDescription = getStr()->cleanStr($sDescription);
        $sDescription = getStr()->htmlspecialchars($sDescription);

        return trim($sDescription);
    }

    public function getMetaDescription()
    {
        $sMeta = parent::getMetaDescription();

        if ($sTitlePageSuffix = $this->getTitlePageSuffix()) {
            if ($sMeta) {
                $sMeta .= ", ";
            }
            $sMeta .= $sTitlePageSuffix;
        }

        return $sMeta;
    }

    protected function _collectMetaDescription($sMeta, $iLength = 1024, $blDescTag = false)
    {
        //formatting description tag
        $oCategory = $this->getActiveCategory();

        $sAddText = (($oCategory instanceof oxCategory)) ? trim($oCategory->getLongDesc()) : '';

        $aArticleList = $this->getArticleList();
        if (!$sAddText && count($aArticleList)) {
            foreach ($aArticleList as $oArticle) {
                if ($sAddText) {
                    $sAddText .= ', ';
                }
                $sAddText .= $oArticle->oxarticles__oxtitle->value;
            }
        }

        if (!$sMeta) {
            $sMeta = trim($this->_getCatPathString());
        }

        if ($sMeta) {
            $sMeta = "{$sMeta} - {$sAddText}";
        } else {
            $sMeta = $sAddText;
        }

        return parent::_prepareMetaDescription($sMeta, $iLength, $blDescTag);
    }

    protected function _prepareMetaKeyword($sKeywords, $blRemoveDuplicatedWords = true)
    {
        $sKeywords = '';
        if (($oCategory = $this->getActiveCategory())) {
            $aKeywords = array();

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

            if (count($aKeywords) > 0) {
                $sKeywords = implode(", ", $aKeywords);
            }

            $aSubCats = $oCategory->getSubCats();
            if (is_array($aSubCats)) {
                foreach ($aSubCats as $oSubCat) {
                    $sKeywords .= ', ' . $oSubCat->oxcategories__oxtitle->value;
                }
            }
        }

        $sKeywords = parent::_prepareMetaDescription($sKeywords, -1, $blRemoveDuplicatedWords);

        return trim($sKeywords);
    }

    protected function _collectMetaKeyword($sKeywords)
    {
        $iMaxTextLength = 60;
        $sText = '';

        if (count($aArticleList = $this->getArticleList())) {
            $oStr = getStr();
            foreach ($aArticleList as $oProduct) {
                $sDesc = $oStr->strip_tags(trim($oStr->strtolower($oProduct->getLongDescription()->value)));

                //removing dots from string (they are not cleaned up during general string cleanup)
                $sDesc = $oStr->preg_replace("/\./", " ", $sDesc);

                if ($oStr->strlen($sDesc) > $iMaxTextLength) {
                    $sMidText = $oStr->substr($sDesc, 0, $iMaxTextLength);
                    $sDesc = $oStr->substr(
                        $sMidText,
                        0,
                        ($oStr->strlen($sMidText) - $oStr->strpos(strrev($sMidText), ' '))
                    );
                }
                if ($sText) {
                    $sText .= ', ';
                }
                $sText .= $sDesc;
            }
        }

        if (!$sKeywords) {
            $sKeywords = $this->_getCatPathString();
        }

        if ($sKeywords) {
            $sText = "{$sKeywords}, {$sText}";
        }

        return parent::_prepareMetaKeyword($sText);
    }

    public function getTemplateName()
    {
        // assign template name
        if (($sTplName = basename(oxRegistry::getConfig()->getRequestParameter('tpl')))) {
            $this->_sThisTemplate = 'custom/' . $sTplName;
        } elseif (($oCategory = $this->getActiveCategory()) && $oCategory->oxcategories__oxtemplate->value) {
            $this->_sThisTemplate = $oCategory->oxcategories__oxtemplate->value;
        }

        return $this->_sThisTemplate;
    }

    protected function _addPageNrParam($sUrl, $iPage, $iLang = null)
    {
        if (oxRegistry::getUtils()->seoIsActive() && ($oCategory = $this->getActiveCategory())) {
            if ($iPage) {
                // only if page number > 0
                $sUrl = $oCategory->getBaseSeoLink($iLang, $iPage);
            }
        } else {
            $sUrl = parent::_addPageNrParam($sUrl, $iPage, $iLang);
        }

        return $sUrl;
    }

    protected function _isActCategory()
    {
        return $this->_blIsCat;
    }

    public function generatePageNavigationUrl()
    {
        if ((oxRegistry::getUtils()->seoIsActive() && ($oCategory = $this->getActiveCategory()))) {
            return $oCategory->getLink();
        }

        return parent::generatePageNavigationUrl();
    }

    public function getDefaultSorting()
    {
        $aSorting = parent::getDefaultSorting();

        $oCategory = $this->getActiveCategory();
        if ($oCategory && $oCategory instanceof oxCategory) {
            if ($sDefaultSorting = $oCategory->getDefaultSorting()) {
                $sArticleTable = getViewName('oxarticles');
                $sSortBy = $sArticleTable . '.' . $sDefaultSorting;
                $sSortDir = ($oCategory->getDefaultSortingMode()) ? "desc" : "asc";
                $aSorting = array('sortby' => $sSortBy, 'sortdir' => $sSortDir);
            }
        }

        return $aSorting;
    }


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

    public function getTitlePageSuffix()
    {
        if (($iPage = $this->getActPage())) {
            return oxRegistry::getLang()->translateString('PAGE') . " " . ($iPage + 1);
        }
    }

    protected function _getSubject($iLang)
    {
        return $this->getActiveCategory();
    }

    public function getAttributes()
    {
        $this->_aAttributes = false;

        if (($oCategory = $this->getActiveCategory())) {
            $aAttributes = $oCategory->getAttributes();
            if (count($aAttributes)) {
                $this->_aAttributes = $aAttributes;
            }
        }

        return $this->_aAttributes;
    }

    public function getArticleList()
    {
        if ($this->_aArticleList === null) {
            if ($oCategory = $this->getActiveCategory()) {
                $aArticleList = $this->_loadArticles($oCategory);
                if (count($aArticleList)) {
                    $this->_aArticleList = $aArticleList;
                }
            }
        }

        return $this->_aArticleList;
    }

    public function getArticleCount()
    {
        return $this->_iAllArtCnt;
    }

    public function getSimilarRecommListIds()
    {
        if ($this->_aSimilarRecommListIds === null) {
            $this->_aSimilarRecommListIds = false;

            if ($aCatArtList = $this->getArticleList()) {
                $this->_aSimilarRecommListIds = $aCatArtList->arrayKeys();
            }
        }

        return $this->_aSimilarRecommListIds;
    }

    public function getCatTreePath()
    {
        if ($this->_sCatTreePath === null) {
            $this->_sCatTreePath = false;
            // category path
            if ($oCatTree = $this->getCategoryTree()) {
                $this->_sCatTreePath = $oCatTree->getPath();
            }
        }

        return $this->_sCatTreePath;
    }

    public function getTreePath()
    {
        if ($oCatTree = $this->getCategoryTree()) {
            return $oCatTree->getPath();
        }
    }

    public function getBreadCrumb()
    {
        $aPaths = array();

        if ('oxmore' == oxRegistry::getConfig()->getRequestParameter('cnid')) {
            $aPath = array();
            $aPath['title'] = oxRegistry::getLang()->translateString(
                'CATEGORY_OVERVIEW',
                oxRegistry::getLang()->getBaseLanguage(),
                false
            );
            $aPath['link'] = $this->getLink();

            $aPaths[] = $aPath;

            return $aPaths;
        }

        if (($oCatTree = $this->getCategoryTree()) && ($oCatPath = $oCatTree->getPath())) {
            foreach ($oCatPath as $oCat) {
                $aCatPath = array();

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

                $aPaths[] = $aCatPath;
            }
        }

        return $aPaths;
    }

    public function hasVisibleSubCats()
    {
        if ($this->_blHasVisibleSubCats === null) {
            $this->_blHasVisibleSubCats = false;
            if ($oClickCat = $this->getActiveCategory()) {
                $this->_blHasVisibleSubCats = $oClickCat->getHasVisibleSubCats();
            }
        }

        return $this->_blHasVisibleSubCats;
    }

    public function getSubCatList()
    {
        if ($this->_aSubCatList === null) {
            $this->_aSubCatList = array();
            if ($oClickCat = $this->getActiveCategory()) {
                $this->_aSubCatList = $oClickCat->getSubCats();
            }
        }

        return $this->_aSubCatList;
    }

    public function getPageNavigation()
    {
        if ($this->_oPageNavigation === null) {
            $this->_oPageNavigation = $this->generatePageNavigation();
        }

        return $this->_oPageNavigation;
    }

    public function getTitle()
    {
        if ($this->_sCatTitle === null) {
            $this->_sCatTitle = false;
            if ($this->getCategoryId() == 'oxmore') {
                $oLang = oxRegistry::getLang();
                $iBaseLanguage = $oLang->getBaseLanguage();

                $this->_sCatTitle = $oLang->translateString('CATEGORY_OVERVIEW', $iBaseLanguage, false);
            } elseif (($oCategory = $this->getActiveCategory())) {
                $sTitleField = 'oxcategories__oxtitle';
                $this->_sCatTitle = $oCategory->$sTitleField->value;
            }
        }

        return $this->_sCatTitle;
    }

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

        return $this->_aBargainArticleList;
    }

    public function getActiveCategory()
    {
        if ($this->_oActCategory === null) {
            $this->_oActCategory = false;
            $oCategory = oxNew('oxCategory');
            if ($oCategory->load($this->getCategoryId())) {
                $this->_oActCategory = $oCategory;
            }
        }

        return $this->_oActCategory;
    }

    public function getCanonicalUrl()
    {
        if (($oCategory = $this->getActiveCategory())) {
            $oUtils = oxRegistry::get("oxUtilsUrl");
            if (oxRegistry::getUtils()->seoIsActive()) {
                $sUrl = $oUtils->prepareCanonicalUrl(
                    $oCategory->getBaseSeoLink($oCategory->getLanguage(), $this->getActPage())
                );
            } else {
                $sUrl = $oUtils->prepareCanonicalUrl(
                    $oCategory->getBaseStdLink($oCategory->getLanguage(), $this->getActPage())
                );
            }

            return $sUrl;
        }
    }

    public function canSelectDisplayType()
    {
        return $this->getConfig()->getConfigParam('blShowListDisplayType');
    }

    public function getPageCount()
    {
        return $this->_iCntPages;
    }
}