oxutilscount.php

Go to the documentation of this file.

<?php

class oxUtilsCount extends oxSuperCfg
{
    private static $_instance = null;

    protected $_sUserViewId = null;

    public static function getInstance()
    {
        // disable caching for test modules
        if ( defined( 'OXID_PHP_UNIT' ) ) {
            static $inst = array();
            self::$_instance = $inst[oxClassCacheKey()];
        }

        if ( !self::$_instance instanceof oxUtilsCount ) {

            self::$_instance = oxNew( 'oxUtilsCount' );
            if ( defined( 'OXID_PHP_UNIT' ) ) {
                $inst[oxClassCacheKey()] = self::$_instance;
            }
        }
        return self::$_instance;
    }

    public function getCatArticleCount( $sCatId )
    {
        // current status unique ident
        $sActIdent = $this->_getUserViewId();

        // loading from cache
        $aCatData = $this->_getCatCache();

        if ( !$aCatData || !isset( $aCatData[$sCatId][$sActIdent] ) ) {
            $iCnt = $this->setCatArticleCount( $aCatData, $sCatId, $sActIdent );
        } else {
            $iCnt = $aCatData[$sCatId][$sActIdent];
        }
        return $iCnt;
    }

    public function getPriceCatArticleCount( $sCatId, $dPriceFrom, $dPriceTo )
    {
        // current status unique ident
        $sActIdent = $this->_getUserViewId();

        // loading from cache
        $aCatData = $this->_getCatCache();

        if ( !$aCatData || !isset( $aCatData[$sCatId][$sActIdent] ) ) {
            $iCnt = $this->setPriceCatArticleCount( $aCatData, $sCatId, $sActIdent, $dPriceFrom, $dPriceTo );
        } else {
            $iCnt = $aCatData[$sCatId][$sActIdent];
        }
        return $iCnt;
    }

    public function getVendorArticleCount( $sVendorId )
    {
        // current category unique ident
        $sActIdent = $this->_getUserViewId();

        // loading from cache
        $aVendorData = $this->_getVendorCache();

        if ( !$aVendorData || !isset( $aVendorData[$sVendorId][$sActIdent] ) ) {
            $iCnt = $this->setVendorArticleCount( $aVendorData, $sVendorId, $sActIdent );
        } else {
            $iCnt = $aVendorData[$sVendorId][$sActIdent];
        }
        return $iCnt;
    }

    public function setCatArticleCount( $aCache, $sCatId, $sActIdent )
    {
        $oArticle = oxNew( 'oxarticle' );
        $sTable   = $oArticle->getViewName();
        $sO2CView = getViewName( 'oxobject2category' );

        $sQ  = "select count( * ) from $sO2CView as oxobject2category WHERE oxobject2category.oxcatnid = '".$sCatId."' ";
        $sQ .= "and oxobject2category.oxobjectid in ( SELECT oxid FROM $sTable where ".$oArticle->getSqlActiveSnippet().")";

        $aCache[$sCatId][$sActIdent] = oxDb::getDb()->getOne( $sQ );
        $this->_setCatCache( $aCache );
        return $aCache[$sCatId][$sActIdent];
    }

    public function setPriceCatArticleCount( $aCache, $sCatId, $sActIdent, $dPriceFrom, $dPriceTo )
    {
        $oArticle = oxNew( 'oxarticle' );
        $sTable   = $oArticle->getViewName();

        $sSubSelect  = "select if(oxparentid='',oxid,oxparentid) as id from oxarticles where oxprice >0 ";
        $sSubSelect .= $dPriceTo?"and oxprice <= $dPriceTo ":" ";
        $sSubSelect .= "group by id having ";
        $sSubSelect .= $dPriceFrom?"min(oxprice) >= $dPriceFrom ":" ";

        $sSelect  = "select count($sTable.oxid) from $sTable where ";
        $sSelect .= "$sTable.oxid in ($sSubSelect) ";
        $sSelect .= "and $sTable.oxissearch = 1 and ".$oArticle->getSqlActiveSnippet();

        $aCache[$sCatId][$sActIdent] = oxDb::getDb()->getOne( $sSelect );

        $this->_setCatCache( $aCache );
        return $aCache[$sCatId][$sActIdent];
    }

    public function setVendorArticleCount( $aCache, $sCatId, $sActIdent )
    {
        // if vendor/category name is 'root', skip counting
        if ( $sCatId == 'root' ) {
            return 0;
        }

        $oArticle = oxNew( 'oxarticle' );
        $sTable   = $oArticle->getViewName();

        // select each vendor articles count
        $sQ  = "select $sTable.oxvendorid AS vendorId, count(*) from $sTable where ";
        $sQ .= "$sTable.oxvendorid <> '' and ".$oArticle->getSqlActiveSnippet()." group by $sTable.oxvendorid ";
        $aDbResult = oxDb::getDb()->getAssoc( $sQ );

        foreach ( $aDbResult as $sKey => $sValue ) {
            $aCache[$sKey][$sActIdent] = $sValue;
        }

        $this->_setVendorCache( $aCache );
        return $aCache[$sCatId][$sActIdent];
    }

    public function resetCatArticleCount( $sCatId = null )
    {
        if ( !$sCatId ) {
            $this->getConfig()->setGlobalParameter( 'aLocalCatCache', null );
        } else {   // loading from cache
            $aCatData = $this->_getCatCache();
            if ( isset( $aCatData[$sCatId] ) ) {
                unset( $aCatData[$sCatId] );
                $this->_setCatCache( $aCatData );
            }
        }

    }

    public function resetPriceCatArticleCount( $iPrice )
    {
        // loading from cache
        if ( $aCatData = $this->_getCatCache() ) {

            $sTable  = getViewName( 'oxcategories' );
            $sSelect = "select $sTable.oxid from $sTable where '$iPrice' >= $sTable.oxpricefrom and '$iPrice' <= $sTable.oxpriceto ";

            $rs = oxDb::getDb()->execute( $sSelect );
            if ( $rs != false && $rs->recordCount() > 0 ) {
                while ( !$rs->EOF ) {
                    if ( isset( $aCatData[$rs->fields[0]] ) ) {
                        unset( $aCatData[$rs->fields[0]] );
                    }
                    $rs->moveNext();
                }

                // writing back to cache
                $this->_setCatCache( $aCatData );
            }

        }
    }

    public function getTagArticleCount( $sTag, $iLang )
    {
        $sLangExt = oxLang::getInstance()->getLanguageTag( $iLang );

        $oArticle = oxNew("oxarticle");
        $sArticleTable  = $oArticle->getViewName();
        $sActiveSnippet = $oArticle->getSqlActiveSnippet();

        $sQ = "select count(*) from oxartextends inner join $sArticleTable
               on $sArticleTable.oxid = oxartextends.oxid where $sActiveSnippet
               and match(oxartextends.oxtags$sLangExt)
               against ( ".oxDb::getDb()->Quote( $sTag )." ) ";

        return oxDb::getDb()->getOne( $sQ );
    }

    public function resetVendorArticleCount( $sVendorId = null )
    {
        if ( !$sVendorId ) {
            $this->getConfig()->setGlobalParameter( 'aLocalVendorCache', null );
            oxUtils::getInstance()->toFileCache( 'aLocalVendorCache', '' );
        } else { // loading from cache
            $aVendorData = $this->_getVendorCache();
            if ( isset( $aVendorData[$sVendorId] ) ) {
                unset( $aVendorData[$sVendorId] );
                $this->_setVendorCache( $aVendorData );
            }
        }

    }

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

        // first look at the local cache
        $aLocalCatCache = $myConfig->getGlobalParameter( 'aLocalCatCache' );

        // if local cache is not set - loading from file cache
        if ( !$aLocalCatCache ) {
            $sLocalCatCache = oxUtils::getInstance()->fromFileCache( 'aLocalCatCache');
            if ( $sLocalCatCache ) {
                $aLocalCatCache = unserialize( $sLocalCatCache );
            } else {
                $aLocalCatCache = null;
            }
            $myConfig->setGlobalParameter( 'aLocalCatCache', $aLocalCatCache );
        }
        return $aLocalCatCache;
    }

    protected function _setCatCache( $aCache )
    {
        $this->getConfig()->setGlobalParameter( 'aLocalCatCache', $aCache );
        oxUtils::getInstance()->toFileCache( 'aLocalCatCache', serialize( $aCache ) );
    }

    protected function _setVendorCache( $aCache )
    {
        $this->getConfig()->setGlobalParameter( 'aLocalVendorCache', $aCache );
        oxUtils::getInstance()->toFileCache( 'aLocalVendorCache', serialize( $aCache ) );
    }

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

        // first look at the local cache
        $aLocalVendorCache = $myConfig->getGlobalParameter('aLocalVendorCache');
        // if local cache is not set - loading from file cache
        if ( !$aLocalVendorCache ) {
            $sLocalVendorCache = oxUtils::getInstance()->fromFileCache( 'aLocalVendorCache' );
            if ( $sLocalVendorCache ) {
                $aLocalVendorCache = unserialize( $sLocalVendorCache );
            } else {
                $aLocalVendorCache = null;
            }
            $myConfig->setGlobalParameter( 'aLocalVendorCache', $aLocalVendorCache );
        }
        return $aLocalVendorCache;
    }

    protected function _getUserViewId( $blReset = false )
    {
        if ( $this->_sUserViewId != null && !$blReset ) {
            return $this->_sUserViewId;
        }

        // loading R&R data from session
        $aRRIdx = null;

        $this->_sUserViewId = md5($this->getConfig()->getShopID().oxLang::getInstance()->getLanguageTag().serialize($aRRIdx).(int) $this->isAdmin() );
        return $this->_sUserViewId;
    }

}

---