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);
    //depends on mysql server configuration
    define('OXTAGCLOUD_MINTAGLENGTH', 4);
    define('OXTAGCLOUD_STARTPAGECOUNT', 20);
    define('OXTAGCLOUD_EXTENDEDCOUNT', 200);
}

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

    protected $_blExtended = false;

    protected $_sProductId = null;

    protected $_iLangId = null;

    protected $_iMaxHit = null;

    protected $_aCloudArray = null;

    protected $_sSeparator = ',';

    protected $_iTagMaxLength = 60;

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

    public function __construct()
    {
        $sSeparator = $this->getConfig()->getConfigParam("sTagSeparator");
        if ($sSeparator)
            $this->_sSeparator = $sSeparator;
    }

    public function setProductId( $sProductId )
    {
        $this->_sProductId = $sProductId;
    }

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

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

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

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

    public function getTagMaxLength()
    {
        return $this->_iTagMaxLength;
    }

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

    public function getCloudArray( $sProductId = null, $blExtended = null, $iLang = null )
    {
        // collecting cloud info
        $iLang      = ( $iLang === null ) ? (int) $this->getLanguageId() : $iLang;
        $blExtended = ( $blExtended === null ) ? $this->isExtended() : $blExtended;
        $sProductId = ( $sProductId === null ) ? (string) $this->getProductId() : $sProductId;

        // checking if current data is allready loaded
        $sCacheIdent = $this->_getCacheKey( $blExtended, $iLang )."_".$sProductId;
        if ( !isset( $this->_aCloudArray[$sCacheIdent] ) ) {

            $myUtils = oxRegistry::getUtils();

            // checking cache
            $aCloudArray = ( !$sProductId ) ? $myUtils->fromFileCache( $sCacheIdent ) : null;

            // loading cloud info
            if ( $aCloudArray === null ) {
                $aCloudArray = $this->getTags( $sProductId, $blExtended, $iLang );
                // updating cache
                if ( !$sProductId ) {
                    $myUtils->toFileCache( $sCacheIdent, $aCloudArray );
                }
            }

            $this->_aCloudArray[$sCacheIdent] = $aCloudArray;
        }
        return $this->_aCloudArray[$sCacheIdent];
    }

    public function getTagLink( $sTag )
    {
        $oSeoEncoderTag = oxRegistry::get("oxSeoEncoderTag");
        $iLang = $this->getLanguageId();

        $sUrl = false;
        if ( oxRegistry::getUtils()->seoIsActive() ) {
            $sUrl = $oSeoEncoderTag->getTagUrl( $sTag, $iLang );
        }
        return $sUrl ? $sUrl : $this->getConfig()->getShopUrl() . $oSeoEncoderTag->getStdTagUri( $sTag ) . "&amp;lang=" . $iLang;
    }

    public function getTagTitle( $sTag )
    {
        return getStr()->htmlentities( $sTag );
    }

    protected function _getMaxHit()
    {
        if ( $this->_iMaxHit === null ) {
            $this->_iMaxHit = max( $this->getCloudArray() );
        }
        return $this->_iMaxHit;
    }

    public function getTagSize( $sTag )
    {
        $aCloudArray = $this->getCloudArray();
        $iCurrSize = $this->_getFontSize( $aCloudArray[ $sTag ], $this->_getMaxHit() );

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


    public function getTags( $sArtId = null, $blExtended = false, $iLang = null )
    {
        $oDb = oxDb::getDb( oxDb::FETCH_MODE_ASSOC );

        if ($blExtended) {
            $iAmount = OXTAGCLOUD_EXTENDEDCOUNT;
        } else {
            $iAmount = OXTAGCLOUD_STARTPAGECOUNT;
        }

        $sArtView  = getViewName( 'oxarticles', $iLang );
        $sViewName = getViewName( 'oxartextends', $iLang );

        // check if article is still active
        $oArticle   = oxNew( 'oxarticle' );
        $oArticle->setLanguage( $iLang );
        $sArtActive = $oArticle->getActiveCheckQuery(true);


        $sQ = "SELECT {$sViewName}.`oxtags` AS `oxtags`
            FROM {$sArtView} AS `oxarticles`
                LEFT JOIN {$sViewName} ON `oxarticles`.`oxid` = {$sViewName}.`oxid`
            WHERE `oxarticles`.`oxactive` = 1 AND $sArtActive";

        if ( $sArtId ) {
            $sQ = "SELECT {$sViewName}.`oxtags` AS `oxtags` FROM {$sViewName} WHERE `oxid` = " . $oDb->quote( $sArtId );
            $iAmount = 0;
        }

        $oDb->setFetchMode( oxDb::FETCH_MODE_ASSOC );
        $rs = $oDb->select( $sQ );
        $aTags = array();
        while ( $rs && $rs->recordCount() && !$rs->EOF ) {
            $sTags = $this->trimTags( $rs->fields['oxtags'] );
            $aArticleTags = explode( $this->_sSeparator, $sTags );
            foreach ( $aArticleTags as $sTag ) {
                if ( trim( $sTag ) ) {
                    ++$aTags[$sTag];
                }
            }
            $rs->moveNext();
        }

        //taking only top tags
        if ( $iAmount ) {
            arsort( $aTags );
            $aTags = array_slice( $aTags, 0, $iAmount, true );
        }

        $aTags = $this->_sortTags( $aTags );
        return $aTags;
    }

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

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

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

    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 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 resetTagCache( $iLang = null )
    {
        $myUtils = oxRegistry::getUtils();

        $sCacheKey1 = $this->_getCacheKey( true, $iLang );
        $myUtils->toFileCache( $sCacheKey1, null );

        $sCacheKey2 = $this->_getCacheKey( false, $iLang );
        $myUtils->toFileCache( $sCacheKey2, null );
    }

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

    public function canBeTagged( $sTagTitle )
    {
        $aProducts = oxSession::getVar("aTaggedProducts");
        if ( isset($aProducts) && $aTags = $aProducts[$this->getProductId()]) {
            if ( $aTags[$sTagTitle] == 1 ) {
                return false;
            }
        }
        return true;
    }

}