root/taggingreloaded/files/lib/util/TaggingReloadedUtil.class.php @ 77

<?php

/**
 * Util for Tagging Operations
 *
 * @author      Torben Brodt
 * @package     de.easy-coding.wcf.taggingreloaded
 * @license     GNU Lesser General Public License <http://opensource.org/licenses/lgpl-license.php>
 */
class TaggingReloadedUtil {
        protected $stopwordList;

        /**
         * returns the stopwordlist
         */
        public function getStopwordList() {
                if($this->stopwordList === null) {
                        $this->stopwordList = array();

                        $sql = "SELECT          stowprd
                                FROM            wcf".WCF_N."_taggingreloaded_stopwords
                                WHERE           languagecode = '".WCF::getLanguage()->getLanguageCode()."'; ";
                        $result = WCF::getDB()->sendQuery($sql);
                        while ($row = WCF::getDB()->fetchArray($result)) {
                                $this->stopwordList[] = $row['stopword'];
                        }
                }
                
                return $this->stopwordList;
        }
        
        /**
         * returns true if the word is NOT a stopword
         * @param word
         */
        protected function noStopword($word) {
                if($this->stopwordList === null) {
                        //$this->getStopwordList();
                        $this->stopwordList = array('wie','ich','mit');
                }
                
                return !in_array($word, $this->stopwordList);
        }

        /**
         * removes bbcodes and adds some tagging optimizations (just for tagging usage)
         * @param text
         * @return text
         */
        public static function bbcode2text($text) {
                // if there is bold text, then repeat the words
                $text = preg_replace('/\[b\](.+)\[\/b\]/', '$1 $1', $text);
                
                // make pseudo html
                $text = str_replace(array('[',']'), array('<','>'), $text);
                
                // strip this html
                $text = strip_tags($text);
                
                return $text;
        }
        
        /**
         * gets a text and returns a list of weighted tags
         * @param text
         * @param limit (optional)
         * @return array
         */
        public static function text2tags($text, $limit=15) {
                $tags = array();

                // find words beginning with capitals
                preg_match_all('/([A-Z][a-zA-Z]+)/e', $text, $words);

                // lower them
                $words = array_map(create_function('$a','return trim(strtolower($a));'), $words[1]);

                // filter stopwords
                //$words = array_filter($words, array($this, "noStopword"));

                // search weights
                foreach($words as $word) {
                        $tags[$word] = array_key_exists($word, $tags) ? $tags[$word]+1 : 1;
                }

                // limit to words with minimum one occurent
                $tags = array_filter($tags, create_function('$a','return $a > 1;'));

                // sort by weight
                arsort($tags);

                // extend to beautify
                array_walk($tags, create_function('&$val, $key','$val = array("weight"=>$val*100);'));

                $tags = TaggingReloadedUtil::beautify($tags, 100, 200);

                // replace weights with sizes TODO: replace through array_walk
                array_walk($tags, create_function('&$val, $key','$val = $val["size"];'));

                $tags = array_slice($tags, 0, $limit);

                return $tags;
        }
        
        /**
         * saves tags
         * @param taggingID -> taggingID
         * @param tags -> array of tags
         * @param userID -> (optional)
         */
        public static function tags2db($taggingID, $tags, $userID=null) {
                if(count($tags) == 0) return;

                $userID = $userID === null ? WCF::getUser()->userID : -1;
        
                // INSERT tags          
                $sql = "INSERT INTO     wcf".WCF_N."_taggingreloaded
                                        (taggingID,userID,tag,weight) 
                        VALUES          ";

                $sql_append = array();
                foreach($tags as $tag => $weight) {
                        $sql_append[] = "({$taggingID}, {$userID}, '".escapeString($tag)."', '".escapeString($weight)."')";
                        $i++;
                }
                
                $sql .= implode(',', $sql_append);
                if($i>0) WCF::getDB()->sendQuery($sql);
        }
        
        /**
         * beautify tags with size and color
         * @param tags
         * @param minsize -> optional
         * @param maxsize -> optional
         * @param array
         */
        public static function beautify($tags, $forced_minsize=null, $forced_maxsize=null) {
                // TODO: auslagern
                $minsize = $forced_minsize === null ? 75 : $forced_minsize;
                $maxsize = $forced_maxsize === null ? 275 : $forced_maxsize;
                $mincolor = 75;
                $maxcolor = 255;
        
                $min = array_reduce($tags, create_function('$a, $b', 'return $a !== null && $a < $b["weight"] ? $a : $b["weight"];'));
                $max = array_reduce($tags, create_function('$a, $b', 'return $a !== null && $a > $b["weight"] ? $a : $b["weight"];'));
        
                if($min == $max) {
                        $max = $max + 1;
                }
                
                if($forced_minsize === null && $min > $minsize) {
                        $minsize = $min;
                }

                if($forced_maxsize === null && $max < $maxsize) {
                        $maxsize = $max;
                }

                $b = $maxsize -($max * ($maxsize-$minsize) / ($max-$min));
                $c = $maxcolor -($max * ($maxcolor-$mincolor) / ($max-$min));

                $tmp = array();
                foreach($tags as $key => $tag) {
                        $key = strtolower($key);
                        $size = ($tag['weight'] * ($maxsize-$minsize) / ($max-$min) )+$b;
                        $color = 255 - (($tag['weight'] * ($maxcolor-$mincolor) / ($max-$min) )+$c);
                        
                        $tmp[$key] = array(
                                        'weight'=> $tag['weight'],
                                        'color'=> intval($color),
                                        'size'=> intval($size)
                                );
                }
                return $tmp;
        }
}
?>