oxcategory.php

Go to the documentation of this file.

<?php

class oxCategory extends oxI18n implements oxIUrl
{
    protected $_aSubCats = array();

    protected $_aContentCats = array();

    protected $_sClassName = 'oxcategory';

    protected $_iNrOfArticles;

    protected $_blIsVisible;

    protected $_blExpanded;

    protected $_blHasSubCats;

    protected $_blHasVisibleSubCats;

    protected $_blIsSeoObject = true;

    protected $_blUseLazyLoading = false;

    protected $_sDynImageDir = null;

    protected $_blTopCategory = null;

    protected $_aIds = array();

    protected $_aStdUrls = array();

    protected $_aSeoUrls = array();

    public function __construct()
    {
        parent::__construct();
        $this->init( 'oxcategories' );
    }

    public function __get( $sName )
    {
        switch ( $sName ) {
            case 'aSubCats':
                return $this->_aSubCats;
                break;
            case 'aContent':
                return $this->_aContentCats;
                break;
            case 'iArtCnt':
                return $this->getNrOfArticles();
                break;
            case 'isVisible':
                return $this->getIsVisible();
                break;
            case 'expanded':
                return $this->getExpanded();
                break;
            case 'hasSubCats':
                return $this->getHasSubCats();
                break;
            case 'hasVisibleSubCats':
                return $this->getHasVisibleSubCats();
                break;
            case 'openlink':
            case 'closelink':
            case 'link':
                //case 'toListLink':
                //case 'noparamlink':
                return $this->getLink();
                break;
            case 'dimagedir':
                return $this->getPictureUrl();
                break;
        }
        return parent::__get($sName);
    }

    public function assign( $dbRecord )
    {
        $this->_iNrOfArticles = null;
        return parent::assign( $dbRecord );
    }

    public function delete( $sOXID = null)
    {
        if ( !$this->getId() ) {
            $this->load( $sOXID);
        }


        $myConfig = $this->getConfig();
        $oDB      = oxDb::getDb();
        $blRet    = false;

        if ( $this->oxcategories__oxright->value == ($this->oxcategories__oxleft->value+1) ) {
            $myUtilsPic = oxUtilsPic::getInstance();

            // only delete empty categories
            // #1173M - not all pic are deleted, after article is removed
            $myUtilsPic->safePictureDelete($this->oxcategories__oxthumb->value, $myConfig->getPictureDir(false).'/0', 'oxcategories', 'oxthumb' );

            $myUtilsPic->safePictureDelete($this->oxcategories__oxicon->value, $myConfig->getPictureDir(false).'/icon', 'oxcategories', 'oxicon' );

            $myUtilsPic->safePictureDelete($this->oxcategories__oxpromoicon->value, $myConfig->getPictureDir(false).'/icon', 'oxcategories', 'oxpromoicon' );

            $sAdd = " and oxshopid = '" . $this->getShopId() . "' ";

            $oDB->execute( "UPDATE oxcategories SET OXLEFT = OXLEFT - 2
                            WHERE  OXROOTID = ".$oDB->quote($this->oxcategories__oxrootid->value)."
                            AND OXLEFT >   ".((int) $this->oxcategories__oxleft->value).$sAdd );

            $oDB->execute( "UPDATE oxcategories SET OXRIGHT = OXRIGHT - 2
                            WHERE  OXROOTID = ".$oDB->quote($this->oxcategories__oxrootid->value)."
                            AND OXRIGHT >   ".((int) $this->oxcategories__oxright->value).$sAdd );

            // delete entry
            $blRet = parent::delete();

            $sOxidQuoted = $oDB->quote($this->oxcategories__oxid->value);
            // delete links to articles
            $oDB->execute( "delete from oxobject2category where oxobject2category.oxcatnid=$sOxidQuoted ");

            // #657 ADDITIONAL delete links to attributes
            $oDB->execute( "delete from oxcategory2attribute where oxcategory2attribute.oxobjectid=$sOxidQuoted ");

            // A. removing assigned:
            // - deliveries
            $oDB->execute( "delete from oxobject2delivery where oxobject2delivery.oxobjectid=$sOxidQuoted ");
            // - discounts
            $oDB->execute( "delete from oxobject2discount where oxobject2discount.oxobjectid=$sOxidQuoted ");

            oxSeoEncoderCategory::getInstance()->onDeleteCategory($this);
        }
        return $blRet;
    }

    public function getSubCats()
    {
        return $this->_aSubCats;
    }

    public function getSubCat($sKey)
    {
        return $this->_aSubCats[$sKey];
    }

    public function setSubCats( $aCats )
    {
        $this->_aSubCats = $aCats;

        foreach ( $aCats as $oCat ) {
            if ( $oCat->getIsVisible() ) {
                $this->setHasVisibleSubCats( true );
            }
        }
    }

    public function setSubCat($oCat, $sKey=null, $blSkipSorting = false)
    {
        if ( $sKey ) {
            $this->_aSubCats[$sKey] = $oCat;
        } else {
            $this->_aSubCats[] = $oCat;
        }

        // keeping ref. to parent
        $oCat->setParentCategory( $this );

        if ( $oCat->getIsVisible() ) {
            $this->setHasVisibleSubCats( true );
        }
    }

    public function sortSubCats()
    {
        if ( count( $this->_aIds ) > 0 ) {
            uasort($this->_aSubCats, array( $this, 'cmpCat' ) );
        }
    }

    public function cmpCat( $a,$b )
    {
        if ( count( $this->_aIds ) == 0 ) {
            return;
        }

        $sNumA = $this->_aIds[$a->oxcategories__oxid->value];
        $sNumB = $this->_aIds[$b->oxcategories__oxid->value];

        if ($sNumA  < $sNumB ) {
            return -1;
        } if ( $sNumA == $sNumB) {
            return 0;
        }
        return 1;
    }

    public function setSortingIds( $aSorIds )
    {
        $this->_aIds = $aSorIds;
    }

    public function getContentCats()
    {
        return $this->_aContentCats;
    }

    public function setContentCats( $aContent )
    {
        $this->_aContentCats = $aContent;
    }

    public function setContentCat( $oContent, $sKey=null )
    {
        if ( $sKey ) {
            $this->_aContentCats[$sKey] = $oContent;
        } else {
            $this->_aContentCats[] = $oContent;
        }
    }

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

        if ( !isset($this->_iNrOfArticles)
          && !$this->isAdmin()
          && (
                 $myConfig->getConfigParam( 'bl_perfShowActionCatArticleCnt' )
              || $myConfig->getConfigParam('blDontShowEmptyCategories')
             ) ) {

            if ( $this->isPriceCategory() ) {
                $this->_iNrOfArticles = oxUtilsCount::getInstance()->getPriceCatArticleCount( $this->getId(), $this->oxcategories__oxpricefrom->value, $this->oxcategories__oxpriceto->value );
            } else {
                $this->_iNrOfArticles = oxUtilsCount::getInstance()->getCatArticleCount( $this->getId() );
            }
        }

        return (int)$this->_iNrOfArticles;
    }

    public function setNrOfArticles( $iNum )
    {
        $this->_iNrOfArticles = $iNum;
    }

    public function getIsVisible()
    {
        if (!isset( $this->_blIsVisible ) ) {

            if ( $this->getConfig()->getConfigParam( 'blDontShowEmptyCategories' ) ) {
                $blEmpty = ($this->getNrOfArticles() < 1) && !$this->getHasVisibleSubCats();
            } else {
                $blEmpty = false;
            }

            $this->_blIsVisible = !($blEmpty || $this->oxcategories__oxhidden->value);
        }

        return $this->_blIsVisible;
    }

    public function setIsVisible( $blVisible )
    {
        $this->_blIsVisible = $blVisible;
    }

    public function getPictureUrl()
    {
        if ( $this->_sDynImageDir === null ) {
            $sThisShop = $this->oxcategories__oxshopid->value;
            $this->_sDynImageDir = $this->getConfig()->getPictureUrl( null, false, null, null, $sThisShop);
        }
        return $this->_sDynImageDir;
    }

    public function getBaseSeoLink( $iLang, $iPage = 0 )
    {
        $oEncoder = oxSeoEncoderCategory::getInstance();
        if ( !$iPage ) {
            return $oEncoder->getCategoryUrl( $this, $iLang );
        }
        return $oEncoder->getCategoryPageUrl( $this, $iPage, $iLang );
    }

    public function getLink( $iLang = null )
    {
        if ( !oxUtils::getInstance()->seoIsActive() ||
             ( isset( $this->oxcategories__oxextlink ) && $this->oxcategories__oxextlink->value ) ) {
            return $this->getStdLink( $iLang );
        }

        if ( $iLang === null ) {
            $iLang = $this->getLanguage();
        }

        if ( !isset( $this->_aSeoUrls[$iLang] ) ) {
            $this->_aSeoUrls[$iLang] = $this->getBaseSeoLink( $iLang );
        }
        return $this->_aSeoUrls[$iLang];
    }

    public function setLink( $sLink )
    {
        $iLang = $this->getLanguage();
        if ( oxUtils::getInstance()->seoIsActive() ) {
            $this->_aSeoUrls[$iLang] = $sLink;
        } else {
            $this->_aStdUrls[$iLang] = $sLink;
        }
    }

    public function getSqlActiveSnippet( $blForceCoreTable = null )
    {
        $sQ  = parent::getSqlActiveSnippet( $blForceCoreTable );

        $sTable = $this->getViewName($blForceCoreTable);
        $sQ .= ( strlen( $sQ )? ' and ' : '' ) . " $sTable.oxhidden = '0' ";


        return "( $sQ ) ";
    }

    public function getBaseStdLink( $iLang, $blAddId = true, $blFull = true )
    {
        if ( isset( $this->oxcategories__oxextlink ) && $this->oxcategories__oxextlink->value ) {
            return  $this->oxcategories__oxextlink->value;
        }

        $sUrl = '';
        if ( $blFull ) {
            //always returns shop url, not admin
            $sUrl = $this->getConfig()->getShopUrl( $iLang, false );
        }

        //always returns shop url, not admin
        return $sUrl . "index.php?cl=alist" . ( $blAddId ? "&amp;cnid=".$this->getId() : "" );
    }

    public function getStdLink( $iLang = null, $aParams = array() )
    {
        if ( isset( $this->oxcategories__oxextlink ) && $this->oxcategories__oxextlink->value ) {
            return  oxUtilsUrl::getInstance()->processUrl( $this->oxcategories__oxextlink->value, false );
        }

        if ( $iLang === null ) {
            $iLang = $this->getLanguage();
        }

        if ( !isset( $this->_aStdUrls[$iLang] ) ) {
            $this->_aStdUrls[$iLang] = $this->getBaseStdLink( $iLang );
        }

        return oxUtilsUrl::getInstance()->processUrl( $this->_aStdUrls[$iLang], true, $aParams, $iLang );
    }

    public function getExpanded()
    {
        if ( !isset( $this->_blExpanded ) ) {
            $myConfig = $this->getConfig();
            $this->_blExpanded = ( $myConfig->getConfigParam( 'blLoadFullTree' ) && !$myConfig->getConfigParam( 'blTopNaviLayout' ) );
        }

        return $this->_blExpanded;
    }

    public function setExpanded( $blExpanded )
    {
        $this->_blExpanded = $blExpanded;
    }

    public function getHasSubCats()
    {
        if ( !isset( $this->_blHasSubCats ) ) {
            $this->_blHasSubCats = $this->oxcategories__oxright->value > $this->oxcategories__oxleft->value + 1 ;
        }

        return $this->_blHasSubCats;
    }

    public function getHasVisibleSubCats()
    {
        if ( !isset( $this->_blHasVisibleSubCats ) ) {
            $this->_blHasVisibleSubCats = false;
        }

        return $this->_blHasVisibleSubCats;
    }

    public function setHasVisibleSubCats( $blHasVisibleSubcats )
    {
        $this->_blHasVisibleSubCats = $blHasVisibleSubcats;
    }

    public function getAttributes()
    {
        $sActCat = $this->getId();

        $oAttrList = oxNew( "oxAttributeList" );
        $oAttrList->getCategoryAttributes( $sActCat, $this->getLanguage() );

        return $oAttrList;
    }

    public function getCatInLang( $oActCategory = null )
    {
        $oCategoryInDefaultLanguage= oxNew( "oxcategory" );
        if ( $this->isPriceCategory() ) {
            // get it in base language
            $oCategoryInDefaultLanguage= oxNew( "oxcategory" );
            $oCategoryInDefaultLanguage->loadInLang( 0, $this->getId());
        } else {
            $oCategoryInDefaultLanguage= oxNew( "oxcategory" );
            $oCategoryInDefaultLanguage->loadInLang( 0, $oActCategory->getId());
        }
        return $oCategoryInDefaultLanguage;
    }

    public function setParentCategory( $oCategory )
    {
        $this->_oParent = $oCategory;
    }

    public function getParentCategory()
    {
        $oCat = null;

        // loading only if parent id is not rootid
        if ( $this->oxcategories__oxparentid->value && $this->oxcategories__oxparentid->value != 'oxrootid' ) {

            // checking if object itself has ref to parent
            if ( $this->_oParent ) {
                $oCat = $this->_oParent;
            } else {
                $oCat = oxNew( 'oxcategory' );
                if ( !$oCat->loadInLang( $this->getLanguage(), $this->oxcategories__oxparentid->value ) ) {
                    $oCat = null;
                }
            }
        }
        return $oCat;
    }

    public static function getRootId($sCategoryId)
    {
        if ( !isset( $sCategoryId ) ) {
            return;
        }

        return oxDb::getDb()->getOne( 'select oxrootid from '.getViewName('oxcategories').' where oxid = ?', array( $sCategoryId ) );
    }


    public function assignViewableRecord($sSelect)
    {
            if ( $this->assignRecord( $sSelect ) ) {
                return  true;
            }


        return false;
    }

    protected function _insert()
    {


        if ( $this->oxcategories__oxparentid->value != "oxrootid") {
            // load parent

            $oParent = oxNew( "oxcategory" );
            //#M317 check if parent is loaded
            if ( !$oParent->load( $this->oxcategories__oxparentid->value) ) {
                return false;
            }

            $sAdd = " and oxshopid = '" . $this->getShopId() . "' ";

            // update existing nodes
            $oDB = oxDb::getDb();
            $oDB->execute( "UPDATE oxcategories SET OXLEFT = OXLEFT + 2
                            WHERE  OXROOTID = ".$oDB->quote($oParent->oxcategories__oxrootid->value)."
                            AND OXLEFT >   ".((int) $oParent->oxcategories__oxright->value)."
                            AND OXRIGHT >= ".((int) $oParent->oxcategories__oxright->value).$sAdd);


            $oDB->execute( "UPDATE oxcategories SET OXRIGHT = OXRIGHT + 2
                            WHERE  OXROOTID = ".$oDB->quote($oParent->oxcategories__oxrootid->value)."
                            AND OXRIGHT >= ".((int) $oParent->oxcategories__oxright->value).$sAdd );

            //if ( !isset( $this->_sOXID) || trim( $this->_sOXID) == "")
            //    $this->_sOXID = oxUtilsObject::getInstance()->generateUID();
            //$this->oxcategories__oxid->setValue($this->_sOXID);
            //refactored to:
            if ( !$this->getId() ) {
                $this->setId();
            }

            $this->oxcategories__oxrootid = new oxField($oParent->oxcategories__oxrootid->value, oxField::T_RAW);
            $this->oxcategories__oxleft = new oxField($oParent->oxcategories__oxright->value, oxField::T_RAW);
            $this->oxcategories__oxright = new oxField($oParent->oxcategories__oxright->value + 1, oxField::T_RAW);
            return parent::_insert();
        } else {
            // root entry
            if ( !$this->getId() ) {
                $this->setId();
            }

            $this->oxcategories__oxrootid = new oxField($this->getId(), oxField::T_RAW);
            $this->oxcategories__oxleft = new oxField(1, oxField::T_RAW);
            $this->oxcategories__oxright = new oxField(2, oxField::T_RAW);
            return parent::_insert();
        }
    }

    protected function _update()
    {

        $oDB = oxDb::getDb();

        $sOldParentID = $oDB->getOne( "select oxparentid from oxcategories where oxid = '".$this->getId()."'");

        if ( $this->_blIsSeoObject && $this->isAdmin() ) {
            oxSeoEncoderCategory::getInstance()->markRelatedAsExpired($this);
        }

        $blRes = parent::_update();

        // #872C - need to update category tree oxleft and oxright values (nested sets),
        // then sub trees are moved inside one root, or to another root.
        // this is done in 3 basic steps
        // 1. increase oxleft and oxright values of target root tree by $iTreeSize, where oxleft>=$iMoveAfter , oxright>=$iMoveAfter
        // 2. modify current subtree, we want to move by adding $iDelta to it's oxleft and oxright,  where oxleft>=$sOldParentLeft and oxright<=$sOldParentRight values,
        //    in this step we also modify rootid's if they were changed
        // 3. decreasing oxleft and oxright values of current root tree, where oxleft >= $sOldParentRight+1 , oxright >= $sOldParentRight+1

        // did we change position in tree ?
        if ( $this->oxcategories__oxparentid->value != $sOldParentID) {
            $sOldParentLeft = $this->oxcategories__oxleft->value;
            $sOldParentRight = $this->oxcategories__oxright->value;

            $iTreeSize = $sOldParentRight-$sOldParentLeft+1;

            $sNewRootID = $oDB->getOne( "select oxrootid from oxcategories where oxid = ".$oDB->quote($this->oxcategories__oxparentid->value));

            //If empty rootID, we set it to categorys oxid
            if ( $sNewRootID == "") {
                //echo "<br>* ) Creating new root tree ( {$this->_sOXID} )";
                $sNewRootID = $this->getId();
            }

            $sNewParentLeft = $oDB->getOne( "select oxleft from oxcategories where oxid = ".$oDB->quote($this->oxcategories__oxparentid->value));

            //if(!$sNewParentLeft){
                //the current node has become root node, (oxrootid == "oxrootid")
            //    $sNewParentLeft = 0;
            //}

            $iMoveAfter = $sNewParentLeft+1;


            //New parentid can not be set to it's child
            if ($sNewParentLeft > $sOldParentLeft && $sNewParentLeft < $sOldParentRight && $this->oxcategories__oxrootid->value == $sNewRootID) {
                //echo "<br>* ) Can't asign category to it's child";

                //Restoring old parentid, stoping further actions
                $sRestoreOld = "UPDATE oxcategories SET OXPARENTID = ".$oDB->quote($sOldParentID)." WHERE oxid = '".$this->getId()."'";
                $oDB->execute( $sRestoreOld );
                return false;
            }

            //Old parent will be shifted too, if it is in the same tree
            if ($sOldParentLeft > $iMoveAfter && $this->oxcategories__oxrootid->value == $sNewRootID) {
                $sOldParentLeft += $iTreeSize;
                $sOldParentRight += $iTreeSize;
            }

            $iDelta = $iMoveAfter-$sOldParentLeft;

            //echo "Size=$iTreeSize, NewStart=$iMoveAfter, delta=$iDelta";

            $sAddOld = " and oxshopid = '" . $this->getShopId() . "' and OXROOTID = ".$oDB->quote($this->oxcategories__oxrootid->value).";";
            $sAddNew = " and oxshopid = '" . $this->getShopId() . "' and OXROOTID = ".$oDB->quote($sNewRootID).";";

            //Updating everything after new position
            $oDB->execute( "UPDATE oxcategories SET OXLEFT = (OXLEFT + ".$iTreeSize.") WHERE OXLEFT >= ".$iMoveAfter.$sAddNew );
            $oDB->execute( "UPDATE oxcategories SET OXRIGHT = (OXRIGHT + ".$iTreeSize.") WHERE OXRIGHT >= ".$iMoveAfter.$sAddNew );
            //echo "<br>1.) + $iTreeSize, >= $iMoveAfter";

            $sChangeRootID = "";
            if ($this->oxcategories__oxrootid->value != $sNewRootID) {
                //echo "<br>* ) changing root IDs ( {$this->oxcategories__oxrootid->value} -> {$sNewRootID} )";
                $sChangeRootID = ", OXROOTID=".$oDB->quote($sNewRootID);
            }

            //Updating subtree
            $oDB->execute( "UPDATE oxcategories SET OXLEFT = (OXLEFT + ".$iDelta."), OXRIGHT = (OXRIGHT + ".$iDelta.") ".$sChangeRootID." WHERE OXLEFT >= ".$sOldParentLeft." AND OXRIGHT <= ".$sOldParentRight.$sAddOld );
            //echo "<br>2.) + $iDelta, >= $sOldParentLeft and <= $sOldParentRight";

            //Updating everything after old position
            $oDB->execute( "UPDATE oxcategories SET OXLEFT = (OXLEFT - ".$iTreeSize.") WHERE OXLEFT >=   ".($sOldParentRight+1).$sAddOld );
            $oDB->execute( "UPDATE oxcategories SET OXRIGHT = (OXRIGHT - ".$iTreeSize.") WHERE OXRIGHT >=   ".($sOldParentRight+1).$sAddOld );
            //echo "<br>3.) - $iTreeSize, >= ".($sOldParentRight+1);
        }

        if ( $blRes && $this->_blIsSeoObject && $this->isAdmin() ) {
            oxSeoEncoderCategory::getInstance()->markRelatedAsExpired($this);
        }

        return $blRes;
    }

    protected function _setFieldData( $sFieldName, $sValue, $iDataType = oxField::T_TEXT)
    {
        //preliminar quick check saves 3% of execution time in category lists by avoiding redundant strtolower() call
        if ($sFieldName[2] == 'l' || $sFieldName[2] == 'L' || (isset($sFieldName[16]) && ($sFieldName[16] == 'l' || $sFieldName[16] == 'L') ) ) {
            if ('oxlongdesc' === strtolower($sFieldName) || 'oxcategories__oxlongdesc' === strtolower($sFieldName)) {
                $iDataType = oxField::T_RAW;
            }
        }
        return parent::_setFieldData($sFieldName, $sValue, $iDataType);
    }


    public function getIconUrl()
    {
        return $this->getPictureUrlForType( $this->oxcategories__oxicon->value, 'icon');
    }

    public function getThumbUrl()
    {
        return $this->getPictureUrlForType( $this->oxcategories__oxthumb->value, '0' );
    }

    public function getPromotionIconUrl()
    {
        return $this->getPictureUrlForType( $this->oxcategories__oxpromoicon->value, 'icon');
    }

    public function getPictureUrlForType($sPicName, $sPicType)
    {

        if ( $sPicName ) {
            return $this->getPictureUrl() . $sPicType . '/' . $sPicName;
        } else {
            return false;
        }
    }

    public function isTopCategory()
    {
        if ( $this->_blTopCategory == null ) {
            $this->_blTopCategory = $this->oxcategories__oxparentid->value == 'oxrootid';
        }
        return $this->_blTopCategory;
    }

    public function isPriceCategory()
    {
        return (bool) ( $this->oxcategories__oxpricefrom->value || $this->oxcategories__oxpriceto->value );
    }

    public function getLongDesc()
    {
        return oxUtilsView::getInstance()->parseThroughSmarty( $this->oxcategories__oxlongdesc->getRawValue(), $this->getId().$this->getLanguage() );
    }
}