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 getManufacturerArticleCount( $sManufacturerId )
    {
        // current category unique ident
        $sActIdent = $this->_getUserViewId();

        // loading from cache
        $aManufacturerData = $this->_getManufacturerCache();
        if ( !$aManufacturerData || !isset( $aManufacturerData[$sManufacturerId][$sActIdent] ) ) {
            $iCnt = $this->setManufacturerArticleCount( $aManufacturerData, $sManufacturerId, $sActIdent );
        } else {
            $iCnt = $aManufacturerData[$sManufacturerId][$sActIdent];
        }
        return $iCnt;
    }

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

        // we use distinct if article is assigned to category twice
        $sQ = "SELECT count(*) FROM (
                   SELECT count(*) FROM $sTable LEFT JOIN $sO2CView ON $sO2CView.oxobjectid=$sTable.oxid
                       WHERE $sO2CView.oxcatnid = '".$sCatId."' AND
                             $sTable.oxparentid='' AND
                             ".$oArticle->getSqlActiveSnippet() ."
                       GROUP BY $sTable.oxid
                   ) AS ox2cat";

        $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 {$sTable} where oxprice >= 0 ";
        $sSubSelect .= $dPriceTo ? "and oxprice <= " . (double)$dPriceTo . " " : " ";
        $sSubSelect .= $dPriceFrom ? "group by id having min( oxprice ) >= " . (double)$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 $sTable.oxparentid = '' 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 setManufacturerArticleCount( $aCache, $sCatId, $sActIdent )
    {
        // if Manufacturer/category name is 'root', skip counting
        if ( $sCatId == 'root' ) {
            return 0;
        }

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

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

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

        $this->_setManufacturerCache( $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 " . (double)$iPrice . " >= $sTable.oxpricefrom and " . (double)$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 );
        $oDb = oxDb::getDb();

        $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 {$sArticleTable}.oxissearch = 1
               and match(oxartextends.oxtags{$sLangExt})
               against ( ".$oDb->quote( $sTag )." ) ";

        return $oDb->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 );
            }
        }

    }

    public function resetManufacturerArticleCount( $sManufacturerId = null )
    {
        if ( !$sManufacturerId ) {
            $this->getConfig()->setGlobalParameter( 'aLocalManufacturerCache', null );
            oxUtils::getInstance()->toFileCache( 'aLocalManufacturerCache', '' );
        } else { // loading from cache
            $aManufacturerData = $this->_getManufacturerCache();
            if ( isset( $aManufacturerData[$sManufacturerId] ) ) {
                unset( $aManufacturerData[$sManufacturerId] );
                $this->_setManufacturerCache( $aManufacturerData );
            }
        }

    }

    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 = $sLocalCatCache;
            } else {
                $aLocalCatCache = null;
            }
            $myConfig->setGlobalParameter( 'aLocalCatCache', $aLocalCatCache );
        }
        return $aLocalCatCache;
    }

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

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

    protected function _setManufacturerCache( $aCache )
    {
        $this->getConfig()->setGlobalParameter( 'aLocalManufacturerCache', $aCache );
        oxUtils::getInstance()->toFileCache( 'aLocalManufacturerCache', $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 = $sLocalVendorCache;
            } else {
                $aLocalVendorCache = null;
            }
            $myConfig->setGlobalParameter( 'aLocalVendorCache', $aLocalVendorCache );
        }
        return $aLocalVendorCache;
    }

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

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

    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;
    }

}

---