oxtagcloud.php

Go to the documentation of this file.

<?php

if (!defined('OXTAGCLOUD_MINFONT')) {
    define('OXTAGCLOUD_MINFONT', 100);
    define('OXTAGCLOUD_MAXFONT', 400);
    define('OXTAGCLOUD_MINOCCURENCETOSHOW', 2);
    define('OXTAGCLOUD_STARTPAGECOUNT', 20);
    define('OXTAGCLOUD_EXTENDEDCOUNT', 200);
}

class oxTagCloud extends oxSuperCfg
{
    protected $_sCacheKey = "tagcloud";

    protected $_iMaxHit = null;

    protected $_aCloudArray = null;

    protected $_blExtended = false;

    protected $_sSeparator = ',';

    protected $_iTagMaxLength = 60;

    protected $_sProductId = null;

    protected $_iLangId = null;

    protected $_aMetaChars = array('+','-','>','<','(',')','~','*','"','\'','\\','[',']','{','}',';',':','.','/','|','!','@','#','$','%','^','&','?','=','`');

    public function __construct()
    {
    }

    public function setProductId( $sProductId )
    {
        $this->_sProductId = $sProductId;
        $oTagList = oxNew('oxarticletaglist');
        $oTagList->setArticleId( $sProductId );
        $oTagList->setLanguage( $this->getLanguageId() );
        $this->setTagList($oTagList);
    }

    public function getProductId()
    {
        return $this->_sProductId;
    }

    public function setLanguageId( $iLangId )
    {
        $this->_iLangId = $iLangId;
    }

    public function getLanguageId()
    {
        if ( $this->_iLangId === null ) {
            $this->_iLangId = oxRegistry::getLang()->getBaseLanguage();
        }
        return $this->_iLangId;
    }

    public function setExtendedMode( $blExtended )
    {
        $this->_blExtended = $blExtended;
    }

    public function isExtended()
    {
        return $this->_blExtended;
    }

    public function setTagList( oxITagList $oTagList )
    {
        $this->_oTagList = $oTagList;
    }

    public function getTagList()
    {
        return $this->_oTagList;
    }

    public function setCloudArray( $aTagCloudArray )
    {
        $sCacheIdent = $this->_formCacheKey();
        $this->_aCloudArray[$sCacheIdent] = $aTagCloudArray;
    }

    public function getCloudArray( $sProductId = null, $blExtended = null, $iLang = null )
    {
        // used to make deprecated functionality working
        if ( $iLang !== null ) {
            $this->setLanguageId( $iLang );
        }
        // used to make deprecated functionality working
        if ( $sProductId !== null ) {
            $this->setProductId( $sProductId );
        }
        // used to make deprecated functionality working
        if ( $blExtended !== null ) {
            $this->setExtendedMode($blExtended);
        }
        $sCacheIdent = $this->_formCacheKey();
        if ( !isset( $this->_aCloudArray[ $sCacheIdent ] ) ) {
            $oTagList = $this->getTagList();
            // used to make deprecated functionality working
            if ( $oTagList === null ) {
                $oTagList = oxNew('oxTagList');
                $oTagList->setLanguage( $this->getLanguageId() );
            }
            $this->_aCloudArray[$sCacheIdent] = $this->formCloudArray( $oTagList );
        }
        return $this->_aCloudArray[$sCacheIdent];
    }

    public function formCloudArray( oxITagList $oTagList )
    {
        // checking if current data is allready loaded
        if ( $oTagList->getCacheId() ) {
            $sCacheIdent = $this->_formCacheKey( $oTagList->getCacheId() );
            $myUtils = oxRegistry::getUtils();
            // checking cache
            $aCloudArray = $myUtils->fromFileCache( $sCacheIdent );
        }

        // loading cloud info
        if ( $aCloudArray === null ) {
            $oTagList->loadList();
            $oTagSet = $oTagList->get();
            if ( count( $oTagSet->get() ) > $this->getMaxAmount() ) {
                $oTagSet->sortByHitCount();
                $oTagSet->slice( 0, $this->getMaxAmount() );
            }
            $oTagSet->sort();
            $aCloudArray = $oTagSet->get();
            // updating cache
            if ( $sCacheIdent ) {
                $myUtils->toFileCache( $sCacheIdent, $aCloudArray );
            }
        }

        return $aCloudArray;
    }

    public function getTagSize( $sTag )
    {
        $aCloudArray = $this->getCloudArray();
        if ( is_null($aCloudArray[$sTag]) ) {
            return 1;
        }
        $iCurrSize = $this->_getFontSize( $aCloudArray[$sTag]->getHitCount(), $this->_getMaxHit() );

        // calculating min size
        return floor( $iCurrSize / OXTAGCLOUD_MINFONT ) * OXTAGCLOUD_MINFONT;
    }

    public function getMaxAmount()
    {
        if ( $this->isExtended() ) {
            return OXTAGCLOUD_EXTENDEDCOUNT;
        } else {
            return OXTAGCLOUD_STARTPAGECOUNT;
        }
    }

    public function resetTagCache( $iLang = null )
    {
        if ( $iLang ) {
            $this->setLanguageId( $iLang );
        }
        $this->resetCache();
    }

    public function resetCache()
    {
        $myUtils = oxRegistry::getUtils();

        $sCacheId = null;
        if ( ( $oTagList = $this->getTagList() ) !== null ) {
            $sCacheId = $oTagList->getCacheId();
        }

        $myUtils->toFileCache( $this->_formCacheKey( $sCacheId ), null );

        $this->_aCloudArray = null;
    }

    public function getTags( $sArtId = null, $blExtended = false, $iLang = null )
    {
        if ( $iLang !== null ) {
            $this->setLanguageId( $iLang );
        }
        // used to make deprecated functionality working
        if ( $sArtId !== null ) {
            $this->setProductId( $sArtId );
            $oTagList = $this->getTagList();
        } else {
            $oTagList = oxNew('oxTagList');
        }
        // used to make deprecated functionality working
        if ( $blExtended !== null ) {
            $this->setExtendedMode($blExtended);
        }
        $oTagList->load();
        $oTagSet = $oTagList->get();
        $oTagSet->sort();

        $aTags = array();
        foreach ( $oTagSet->get() as $sKey => $oTag ) {
            $aTags[$sKey] = $oTag->getHitCount();
        }

        return $aTags;
    }

    public function prepareTags( $sTags )
    {
        $sTags = $this->stripMetaChars($sTags);
        $aTags = explode( $this->_sSeparator, $sTags );
        $aRes = array();
        $oStr = getStr();

        foreach ( $aTags as $sTag ) {
            if ( ( $sTag = trim( $sTag ) ) ) {
                $sRes = '';
                $iLen = $oStr->strlen( $sTag );
                if ( $iLen > $this->_iTagMaxLength ) {
                    $sTag = $oStr->substr($sTag, 0, $this->_iTagMaxLength);
                }
                $sTag = trim( $sTag );
                $aMatches = explode(' ', $sTag);
                foreach ( $aMatches as $iKey => $sMatch ) {
                    $sRes .= $oStr->strtolower( $this->_fixTagLength($sMatch ) )." ";
                }
                $aRes[] = trim( $sRes );
            }
        }

        return implode( $this->_sSeparator, $aRes );
    }

    public function trimTags( $sTags )
    {
        $oStr = getStr();
        $sTags = $oStr->preg_replace( "/(\s*\,+\s*)+/", ",", trim( $sTags ) );
        $sRes = '';

        if ( $oStr->preg_match_all( "/([\s\,\-]?)([^\s\,\-]+)([\s\,\-]?)/", $sTags, $aMatches ) ) {
            foreach ( $aMatches[0] as $iKey => $sMatch ) {
                $sProc = $aMatches[2][$iKey];
                if ( $oStr->strlen( $sProc ) <= OXTAGCLOUD_MINTAGLENGTH ) {
                    $sProc = rtrim( $sProc, "_" );
                }
                $sRes .= $aMatches[1][$iKey] . $sProc . $aMatches[3][$iKey];
            }
        }

        return trim( $sRes, $this->_sSeparator );
    }

    public function stripMetaChars( $sText )
    {
        $oStr  = getStr();

        // Remove meta chars
        $sText = str_replace($this->_aMetaChars, ' ', $sText);

        // Replace multiple spaces with single space
        $sText = $oStr->preg_replace( "/\s+/", " ", trim( $sText ) );

        return $sText;
    }

    public function getTagMaxLength()
    {
        $oTags = oxNew( 'oxtag' );
        return $oTags->getMaxLength();
    }

    public function getTagLink( $sTag )
    {
        $aCloudArray = $this->getCloudArray();
        return $aCloudArray[$sTag]->getLink();
    }

    public function getTagTitle( $sTag )
    {
        $aCloudArray = $this->getCloudArray();
        return $aCloudArray[$sTag]->getTitle();
    }

    public function canBeTagged( $sTagTitle )
    {
        $oTags = oxNew( 'oxarticletaglist' );
        $oTags->load($this->getProductId());
        return $oTags->canBeTagged($sTagTitle);
    }

    public function _fixTagLength( $sTag )
    {
        $oStr = getStr();
        $sTag = trim( $sTag );
        $iLen = $oStr->strlen( $sTag );

        if ( $iLen < OXTAGCLOUD_MINTAGLENGTH ) {
            $sTag .= str_repeat( '_', OXTAGCLOUD_MINTAGLENGTH - $iLen );
        }

        return $sTag;
    }

    protected function _getCacheKey( $blExtended, $iLang = null )
    {
        return $this->_sCacheKey."_".$this->getConfig()->getShopId()."_".( ( $iLang !== null ) ? $iLang : oxRegistry::getLang()->getBaseLanguage() ) ."_".($blExtended?1:0);
    }

    protected function _formCacheKey( $sTagListCacheId = null )
    {
        $sExtended = $this->isExtended()? '1' : '0';
        return $this->_sCacheKey."_".$this->getConfig()->getShopId()."_".$sExtended."_".$sTagListCacheId;
    }

    protected function _getMaxHit()
    {
        if ( $this->_iMaxHit === null ) {
            $aHits = array_map( array($this, '_getTagHitCount'), $this->getCloudArray());
            $this->_iMaxHit = max( $aHits );
        }
        return $this->_iMaxHit;
    }

    protected function _getTagHitCount( $oTag )
    {
        return $oTag->getHitCount();
    }

    protected function _getFontSize( $iHit, $iMaxHit )
    {
        //handling special case
        if ($iMaxHit <= OXTAGCLOUD_MINOCCURENCETOSHOW || !$iMaxHit) {
            return OXTAGCLOUD_MINFONT;
        }

        $iFontDiff = OXTAGCLOUD_MAXFONT - OXTAGCLOUD_MINFONT;
        $iMaxHitDiff = $iMaxHit - OXTAGCLOUD_MINOCCURENCETOSHOW;
        $iHitDiff = $iHit - OXTAGCLOUD_MINOCCURENCETOSHOW;

        if ($iHitDiff < 0) {
            $iHitDiff = 0;
        }

        $iSize = round($iHitDiff * $iFontDiff / $iMaxHitDiff) + OXTAGCLOUD_MINFONT;

        return $iSize;
    }

    protected function _sortTags( $aTags, $iLang = null )
    {
        if ( is_array( $aTags ) && count( $aTags ) ) {
            $oDb = oxDb::getDb( oxDb::FETCH_MODE_ASSOC );
            $sSubQ = '';
            foreach ( $aTags as $sKey => $sTag ) {
                if ( $sSubQ ) {
                    $sSubQ .= ' union all ';
                }
                $sSubQ .= 'select '.$oDb->quote( $sKey ).' as _oxsort, '.$oDb->quote( $sTag ).' as _oxval';
            }

            $sViewName = getViewName( "oxartextends", $iLang );

            // forcing collation
            $sSubQ = "select {$sViewName}.oxtags as _oxsort, 'ox_skip' as _oxval from {$sViewName} limit 1 union $sSubQ";
            $sQ = "select _oxtable._oxsort, _oxtable._oxval from ( {$sSubQ} ) as _oxtable order by _oxtable._oxsort desc";

            $aTags = array();
            $oDb->setFetchMode( oxDb::FETCH_MODE_ASSOC );
            $oRs = $oDb->select( $sQ );
            while ( $oRs && $oRs->recordCount() && !$oRs->EOF ) {
                if ( $oRs->fields['_oxval'] != 'ox_skip' ) {
                    $aTags[$oRs->fields['_oxsort']] = $oRs->fields['_oxval'];
                }
                $oRs->moveNext();
            }
        }
        return $aTags;
    }

}