oxcategorylist.php

Go to the documentation of this file.

<?php


class oxCategoryList extends oxList
{
    protected $_sObjectsInListName = 'oxcategory';

    protected $_blHideEmpty = false;

    protected $_blForceFull = false;

    protected $_iForceLevel = 1;

    protected $_sActCat     = null;

    protected $_aPath = array();

    protected $_aUpdateInfo = array();

    public function __construct( $sObjectsInListName = 'oxcategory')
    {
        $this->_blHideEmpty = $this->getConfig()->getConfigParam('blDontShowEmptyCategories');
        parent::__construct( $sObjectsInListName );
    }

    protected function _getSqlSelectFieldsForTree($sTable, $aColumns = null)
    {
        if ($aColumns && count($aColumns)) {
            foreach ($aColumns as $key=>$val) {
                $aColumns[$key].=' as '.$val;
            }
            return "$sTable.".implode(", $sTable.", $aColumns);
        }

        $oBaseObject = $this->getBaseObject();
        $sLangSuffix = oxLang::getInstance()->getLanguageTag();

        $sFieldList = "$sTable.oxid as oxid, $sTable.oxactive$sLangSuffix as oxactive,"
                    ." $sTable.oxhidden as oxhidden, $sTable.oxparentid as oxparentid,"
                    ." $sTable.oxdefsort as oxdefsort, $sTable.oxdefsortmode as oxdefsortmode,"
                    ." $sTable.oxleft as oxleft, $sTable.oxright as oxright,"
                    ." $sTable.oxrootid as oxrootid, $sTable.oxsort as oxsort,"
                    ." $sTable.oxtitle$sLangSuffix as oxtitle, $sTable.oxdesc$sLangSuffix as oxdesc,"
                    ." $sTable.oxpricefrom as oxpricefrom, $sTable.oxpriceto as oxpriceto,"
                    ." $sTable.oxicon as oxicon, $sTable.oxextlink as oxextlink ";

            $sFieldList.= ",not $sTable.".$oBaseObject->getSqlFieldName( 'oxactive' )." as oxppremove";


        return $sFieldList;
    }

    protected function _getSelectString($blReverse = false, $aColumns = null, $sOrder = null)
    {
        $sViewName  = $this->getBaseObject()->getViewName();
        $sFieldList = $this->_getSqlSelectFieldsForTree($sViewName, $aColumns);

        //excluding long desc
        if (!$this->isAdmin() && !$this->_blHideEmpty && !$this->_blForceFull) {
            $oCat = oxNew('oxcategory');
            if (!($this->_sActCat && $oCat->load($this->_sActCat) && $oCat->oxcategories__oxrootid->value)) {
                $oCat = null;
                $this->_sActCat = null;
            }
            $sUnion = $this->_getDepthSqlUnion($oCat, $aColumns);
            $sWhere = $this->_getDepthSqlSnippet($oCat);
        } else {
            $sUnion = '';
            $sWhere = '1';
        }

        if (!$sOrder) {
            $sOrdDir    = $blReverse?'desc':'asc';
            $sOrder     = "oxrootid $sOrdDir, oxleft $sOrdDir";
        }

        return "select $sFieldList from $sViewName where $sWhere $sUnion order by $sOrder";
    }

    protected function _getDepthSqlSnippet($oCat)
    {
        $sViewName  = $this->getBaseObject()->getViewName();
        $sDepthSnippet = ' ( 0';

        // load compleate tree of active category, if it exists
        if ($oCat) {
            // select children here, siblings will be selected from union
            $sDepthSnippet .= " or ($sViewName.oxparentid = ".oxDb::getDb()->quote($oCat->oxcategories__oxid->value).")";
        }

        // load 1'st category level (roots)
        if ($this->_iForceLevel >= 1) {
            $sDepthSnippet .= " or $sViewName.oxparentid = 'oxrootid'";
        }

        // load 2'nd category level ()
        if ($this->_iForceLevel >= 2) {
            $sDepthSnippet .= " or $sViewName.oxrootid = $sViewName.oxparentid or $sViewName.oxid = $sViewName.oxrootid";
        }

        $sDepthSnippet .= ' ) ';
        return $sDepthSnippet;
    }

    protected function _getDepthSqlUnion($oCat, $aColumns = null)
    {
        if (!$oCat) {
            return '';
        }

        $sViewName = $this->getBaseObject()->getViewName();

        return "UNION SELECT ".$this->_getSqlSelectFieldsForTree('maincats', $aColumns)
                ." FROM oxcategories AS subcats"
                ." LEFT JOIN $sViewName AS maincats on maincats.oxparentid = subcats.oxparentid"
                ." WHERE subcats.oxrootid = ".oxDb::getDb()->quote($oCat->oxcategories__oxrootid->value)
                ." AND subcats.oxleft <= ". (int)$oCat->oxcategories__oxleft->value
                ." AND subcats.oxright >= ".(int)$oCat->oxcategories__oxright->value;
    }


    public function buildTree($sActCat, $blLoadFullTree, $blPerfLoadTreeForSearch, $blTopNaviLayout)
    {
        startProfile("buildTree");

        $this->_sActCat     = $sActCat;
        $this->_blForceFull = $blLoadFullTree || $blPerfLoadTreeForSearch;
        $this->_iForceLevel = $blTopNaviLayout?2:1;

        $sSelect = $this->_getSelectString(true);
        $this->selectString($sSelect);

        // PostProcessing
        if ( !$this->isAdmin() ) {
            // remove inactive categories
            $this->_ppRemoveInactiveCategories();

            // add active cat as full object
            $this->_ppLoadFullCategory($sActCat);

            // builds navigation path
            $this->_ppAddPathInfo();

            // add content categories
            $this->_ppAddContentCategories();

            // build tree structure
            $this->_ppBuildTree();
        }

        stopProfile("buildTree");
    }

    protected function _ppLoadFullCategory( $sId )
    {
        if ( isset($this->_aArray[$sId])) {
            $oNewCat = oxNew('oxcategory');
            if ( $oNewCat->load($sId)) {
                // replace aArray object with fully loaded category
                $this->_aArray[$sId] = $oNewCat;
            }
        } else {
            $this->_sActCat = null;
        }
    }

    public function buildList($blLoad)
    {

        if (!$blLoad) {
            return;
        }

        startProfile('buildCategoryList');

        $this->_blForceFull = true;
        $this->selectString($this->_getSelectString(false));

        // PostProcessing
        // add tree depth info
        $this->_ppAddDepthInformation();
        stopProfile('buildCategoryList');
    }

    public function setShopID($sShopID)
    {
        $this->_sShopID = $sShopID;
    }

    public function getPath()
    {
        return $this->_aPath;
    }

    public function getHtmlPath()
    {
        $sHtmlCatTree = '';
        $sSep         = '';
        foreach ( $this->_aPath as $oCategory ) {
            $sHtmlCatTree .= " $sSep<a href='".$oCategory->getLink()."'>".$oCategory->oxcategories__oxtitle->value."</a>";
            $sSep = '/ ';
        }
        return $sHtmlCatTree;
    }

    public function getClickCat()
    {
        if (count($this->_aPath)) {
            return end($this->_aPath);
        }
    }

    public function getClickRoot()
    {
        if (count($this->_aPath)) {
            return array(reset($this->_aPath));
        }
    }

    protected function _ppRemoveInactiveCategories()
    {
        // Colect all items whitch must be remove
        $aRemoveList = array();
        foreach ($this->_aArray as $oCat) {
            if ($oCat->oxcategories__oxppremove->value) {
                if (isset($aRemoveList[$oCat->oxcategories__oxrootid->value])) {
                    $aRemoveRange = $aRemoveList[$oCat->oxcategories__oxrootid->value];
                } else {
                    $aRemoveRange = array();
                }
                $aRemoveList[$oCat->oxcategories__oxrootid->value] = array_merge(range($oCat->oxcategories__oxleft->value, $oCat->oxcategories__oxright->value), $aRemoveRange);
            }
            unset($oCat->oxcategories__oxppremove);
        }

        // Remove colected items from list.
        foreach ($this->_aArray as $oCat) {
            if (isset($aRemoveList[$oCat->oxcategories__oxrootid->value]) && in_array($oCat->oxcategories__oxleft->value, $aRemoveList[$oCat->oxcategories__oxrootid->value])) {
                unset( $this->_aArray[$oCat->oxcategories__oxid->value] );
            }
        }
    }

    protected function _ppAddPathInfo()
    {

        if (is_null($this->_sActCat)) {
            return;
        }

        $aPath = array();
        $sCurrentCat  = $this->_sActCat;

        while ($sCurrentCat != 'oxrootid' && isset($this[$sCurrentCat])) {
            $oCat = $this[$sCurrentCat];
            $oCat->setExpanded(true);
            $aPath[$sCurrentCat] = $oCat;
            $sCurrentCat = $oCat->oxcategories__oxparentid->value;
        }

        $this->_aPath = array_reverse($aPath);
    }

    protected function _ppAddContentCategories()
    {
        // load content pages for adding them into menue tree
        $oContentList = oxNew( "oxcontentlist" );
        $oContentList->loadCatMenues();

        foreach ($oContentList as $sCatId => $aContent) {
            if (array_key_exists($sCatId, $this->_aArray)) {
                $this[$sCatId]->setContentCats($aContent);

            }
        }
    }

    protected function _ppBuildTree()
    {
        startProfile("_sortCats");
        $aIds = $this->sortCats();
        stopProfile("_sortCats");
        $aTree = array();
        foreach ($this->_aArray as $oCat) {
            $sParentId = $oCat->oxcategories__oxparentid->value;
            if ( $sParentId != 'oxrootid') {
                if (isset($this->_aArray[$sParentId])) {
                    $this->_aArray[$sParentId]->setSortingIds( $aIds );
                    $this->_aArray[$sParentId]->setSubCat($oCat, $oCat->getId(), true);
                }
            } else {
                $aTree[$oCat->getId()] = $oCat;
            }
        }

        // run sorting only once on each parent
        $aParents = array();
        foreach ($this->_aArray as $oCat) {
            $aParents[$oCat->oxcategories__oxparentid->value] = true;
        }
        if ($aParents['oxrootid']) {
            unset($aParents['oxrootid']);
        }
        foreach (array_keys($aParents) as $sParent) {
            if (isset($this->_aArray[$sParent])) {
                $this->_aArray[$sParent]->sortSubCats();
            }
        }

        // Sort root categories
        $oCategory = oxNew('oxcategory');
        $oCategory->setSortingIds( $aIds );
        uasort($aTree, array( $oCategory, 'cmpCat' ) );

        $this->assign($aTree);
    }

    public function sortCats()
    {
        $sViewName  = getViewName('oxcategories');
        $sSortSql = $this->_getSelectString(false, array('oxid', 'oxparentid', 'oxsort', 'oxtitle'), 'oxparentid, oxsort, oxtitle');
        $aIds = array();
        $oDB = oxDb::getDb(true);
        $rs = $oDB->execute($sSortSql);
        $cnt = 0;
        if ($rs != false && $rs->recordCount() > 0) {
            while (!$rs->EOF) {
                $aIds[$rs->fields['oxid']] = $cnt;
                $cnt++;
                $rs->moveNext();
            }
        }
        return $aIds;
    }

    protected function _ppAddDepthInformation()
    {

        $aStack = array();
        $iDepth = 0;
        $sPrevParent = '';

        foreach ($this->_aArray as $oCat) {

            $sParentId = $oCat->oxcategories__oxparentid->value;
            if ( $oCat->oxcategories__oxparentid->value == 'oxrootid' ) {
                $iDepth = 1;
                $aStack = array($sParentId => '0');
            }

            if ($sPrevParent != $sParentId && isset($aStack[$sParentId]) ) {
                $iDepth -= count($aStack)- $aStack[$sParentId];
                $aStack = array_slice($aStack, 0, $iDepth-1, true);
            }

            if ( !isset($aStack[$sParentId])) {
                $aStack[$sParentId] = $iDepth;
                $iDepth++;
            }

            $oCat->oxcategories__oxtitle->setValue(str_repeat('-', $iDepth-1).' '.$oCat->oxcategories__oxtitle->value);
            $sPrevParent = $sParentId;
        }

    }

    public function updateCategoryTree($blVerbose = true, $sShopID = null)
    {
        $oDB = oxDb::getDb();
        $sWhere = '1';


        $oDB->execute("update oxcategories set oxleft = 0, oxright = 0 where $sWhere");
        $oDB->execute("update oxcategories set oxleft = 1, oxright = 2 where oxparentid = 'oxrootid' and $sWhere");

        // Get all root categories
        $rs = $oDB->execute("select oxid, oxtitle from oxcategories where oxparentid = 'oxrootid' and $sWhere order by oxsort");
        if ($rs != false && $rs->recordCount() > 0) {
            while (!$rs->EOF) {
                $this->_aUpdateInfo[] = "<b>Processing : ".$rs->fields[1]."</b>(".$rs->fields[0].")<br>";
                if ( $blVerbose ) {
                    echo next( $this->_aUpdateInfo );
                }
                $oxRootId = $rs->fields[0];

                $updn = $this->_updateNodes($oxRootId, true, $oxRootId);
                $rs->moveNext();
            }
        }
    }

    public function getUpdateInfo()
    {
        return $this->_aUpdateInfo;
    }

    protected function _updateNodes($oxRootId, $isroot, $thisRoot)
    {
        $oDB = oxDb::getDb();

        if ($isroot) {
            $thisRoot = $oxRootId;
        }

        // Get sub categories of root categorie
        $rs = $oDB->execute("update oxcategories set oxrootid = ".$oDB->quote($thisRoot)." where oxparentid = ".$oDB->quote($oxRootId));
        $rs = $oDB->execute("select oxid, oxparentid from oxcategories where oxparentid = ".$oDB->quote($oxRootId)." order by oxsort");
        // If there are sub categories
        if ($rs != false && $rs->recordCount() > 0) {
            while (!$rs->EOF) {
                $parentId = $rs->fields[1];
                $actOxid = $rs->fields[0];
                $sActOxidQuoted = $oDB->quote($actOxid);

                // Get the data of the parent category to the current Cat
                $rs3 = $oDB->execute("select oxrootid, oxright from oxcategories where oxid = ".$oDB->quote($parentId));
                while (!$rs3->EOF) {
                    $parentOxRootId = $rs3->fields[0];
                    $parentRight    = (int)$rs3->fields[1];
                    $rs3->moveNext();
                }
                $sParentOxRootIdQuoted = $oDB->quote($parentOxRootId);
                $oDB->execute("update oxcategories set oxleft = oxleft + 2 where oxrootid = $sParentOxRootIdQuoted and oxleft > '$parentRight' and oxright >= '$parentRight' and oxid != $sActOxidQuoted");
                $oDB->execute("update oxcategories set oxright = oxright + 2 where oxrootid = $sParentOxRootIdQuoted and oxright >= '$parentRight' and oxid != $sActOxidQuoted");
                $oDB->execute("update oxcategories set oxleft = $parentRight, oxright = ($parentRight + 1) where oxid = $sActOxidQuoted");
                $this->_updateNodes($actOxid, false, $thisRoot);
                $rs->moveNext();
            }
        }
    }

    public function __get($sName)
    {
        switch ($sName) {
            case 'aPath':
            case 'aFullPath':
                return $this->getPath();
                break;
        }
        return parent::__get($sName);
    }

}