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 $_blTop5Action = true;
    protected $_blShowTagCloud = true;

    protected $_blBargainAction = false;

    public function getViewId()
    {
        if ( !isset( $this->_sViewId ) ) {
            $sCatId   = oxConfig::getParameter( 'cnid' );
            $iActPage = $this->getActPage();
            $iArtPerPage = oxSession::getVar( '_artperpage' );
            $sListDisplayType = oxSession::getVar( 'ldtype' );
            $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' == oxConfig::getParameter( 'cnid' ) ) {
            // overriding some standard value and parameters
            $this->_sThisTemplate = $this->_sThisMoreTemplate;
            $oCategory = oxNew( 'oxcategory' );
            $oCategory->oxcategories__oxactive = new oxField( 1, oxField::T_RAW );
            $this->setActCategory( $oCategory );

            $this->_blShowTagCloud = true;

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


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

        $oCat = $this->getActCategory();
        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();
        // redirecting to first page in case requested page does not exist
        if ( $iPageCnt && ( ( $iPageCnt - 1 ) < $this->getActPage() ) ) {
            oxUtils::getInstance()->redirect( $this->getActiveCategory()->getLink(), false );
        }
    }

    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 ( !oxUtils::getInstance()->seoIsActive() ) {
            $iPgNr = (int) oxConfig::getParameter( 'pgNr' );
            if ( $iPgNr > 0 ) {
                $sParams .= ($sParams?'&amp;':'') . "pgNr={$iPgNr}";
            }
        }

        return $sParams;
    }

    public function getAddSeoUrlParams()
    {
    }

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

    public function executefilter()
    {
        $iLang = oxLang::getInstance()->getBaseLanguage();
        // store this into session
        $aFilter = oxConfig::getParameter( 'attrfilter', 1 );
        $sActCat = oxConfig::getParameter( 'cnid' );

        if ( !empty( $aFilter ) ) {
            $aSessionFilter = oxSession::getVar( '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;
            oxSession::setVar( '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( $oCategory->getId() ) );

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

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

            $sActCat = oxConfig::getParameter( 'cnid' );
            $this->_iAllArtCnt = $oArtList->loadCategoryArticles( $sActCat, $aSessionFilter );
        }

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

        return $oArtList;
    }

    public function getActPage()
    {
        return $this->_getRequestPageNr();
    }

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

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

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

            // marking as allready 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 )
    {
        // using language constant ..
        $sDescription = oxLang::getInstance()->translateString( 'ALIST_META_DESCRIPTION_PREFIX' );

        // appending parent title
        if ( $oCategory = $this->getActCategory() ) {
            if ( ( $oParent = $oCategory->getParentCategory() ) ) {
                $sDescription .= " {$oParent->oxcategories__oxtitle->value} -";
            }

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

        // and final component ..
        if ( ( $sSuffix = $this->getConfig()->getActiveShop()->oxshops__oxstarttitle->value ) ) {
            $sDescription .= " {$sSuffix}";
        }

        // making safe for output
        $sDescription = getStr()->cleanStr($sDescription);
        $sDescription = strip_tags( getStr()->html_entity_decode( $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
        $sAddText = ( $oCategory = $this->getActCategory() ) ? 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->getActCategory() ) ) {
            $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 = strip_tags( trim( $oStr->strtolower( $oProduct->getArticleLongDesc()->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( oxConfig::getParameter( 'tpl' ) ) ) ) {
            $this->_sThisTemplate = $sTplName;
        } elseif ( ( $oCategory = $this->getActCategory() ) && $oCategory->oxcategories__oxtemplate->value ) {
            $this->_sThisTemplate = $oCategory->oxcategories__oxtemplate->value;
        }

        return $this->_sThisTemplate;
    }

    protected function _addPageNrParam( $sUrl, $iPage, $iLang = null)
    {
        if ( oxUtils::getInstance()->seoIsActive() && ( $oCategory = $this->getActCategory() ) ) {
            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 ( ( oxUtils::getInstance()->seoIsActive() && ( $oCategory = $this->getActCategory() ) ) ) {
            return $oCategory->getLink();
        }
        return parent::generatePageNavigationUrl( );
    }

    public function getSorting( $sCnid )
    {
        // category has own sorting
        $aSorting = parent::getSorting( $sCnid );
        $oActCat = $this->getActCategory();
        if ( !$aSorting && $oActCat && $oActCat->oxcategories__oxdefsort->value ) {
            $sSortBy  = $oActCat->oxcategories__oxdefsort->value;
            $sSortDir = ( $oActCat->oxcategories__oxdefsortmode->value ) ? "desc" : null;

            $this->setItemSorting( $sCnid, $sSortBy, $sSortDir );
            $aSorting = array ( 'sortby' => $sSortBy, 'sortdir' => $sSortDir );
        }
        return $aSorting;
    }

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

    public function getTitlePageSuffix()
    {
        if ( ( $iPage = $this->getActPage() ) ) {
            return oxLang::getInstance()->translateString( 'INC_HEADER_TITLEPAGE' ). ( $iPage + 1 );
        }
    }

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

    public function getAttributes()
    {
        $this->_aAttributes = false;
        if ( ( $oCategory = $this->getActCategory() ) ) {
            $aAttributes = $oCategory->getAttributes();
            if ( count( $aAttributes ) ) {
                $this->_aAttributes = $aAttributes;
            }
        }

        return $this->_aAttributes;
    }

    public function getArticleList()
    {
        if ( $this->_aArticleList === null ) {
            if ( /*$this->_isActCategory() &&*/ ( $oCategory = $this->getActCategory() ) ) {
                $aArticleList = $this->_loadArticles( $oCategory );
                if ( count( $aArticleList ) ) {
                    $this->_aArticleList = $aArticleList;
                }
            }
        }

        return $this->_aArticleList;
    }

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

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

        if ( $this->_oRecommList === null ) {
            $this->_oRecommList = false;
            if ( $aCatArtList = $this->getArticleList() ) {
                $oRecommList = oxNew('oxrecommlist');
                $this->_oRecommList = $oRecommList->getRecommListsByIds( $aCatArtList->arrayKeys());
            }
        }
        return $this->_oRecommList;
    }

    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' == oxConfig::getParameter( 'cnid' ) ) {
            $aPath = array();
            $aPath['title'] = oxLang::getInstance()->translateString( 'PAGE_PRODUCT_MORECATEGORIES', oxLang::getInstance()->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->getActCategory() ) {
                $this->_blHasVisibleSubCats = $oClickCat->getHasVisibleSubCats();
            }
        }
        return $this->_blHasVisibleSubCats;
    }

    public function getSubCatList()
    {
        if ( $this->_aSubCatList === null ) {
            $this->_aSubCatList = array();
            if ( $oClickCat = $this->getActCategory() ) {
                $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 ( ( $oCategory = $this->getActCategory() ) ) {
                $this->_sCatTitle = $oCategory->oxcategories__oxtitle->value;
            }
        }
        return $this->_sCatTitle;
    }

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

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

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

    public function getCanonicalUrl()
    {
        if ( ( $oCategory = $this->getActiveCategory() ) ) {
            $oUtils = oxUtilsUrl::getInstance();
            if ( oxUtils::getInstance()->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;
    }

    public function isMoreTagsVisible()
    {
        return true;
    }
}