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

<?php
require_once(WCF_DIR.'/lib/util/TaggingUtil.class.php');
require_once(WCF_DIR.'/lib/util/ArrayUtil.class.php');
require_once(WCF_DIR.'/lib/util/StringUtil.class.php');
require_once(WCF_DIR.'lib/data/tag/Tag.class.php');
require_once(WCF_DIR.'lib/data/tag/TagCloudWrapper.class.php');
require_once(WCF_DIR.'lib/data/tag/TagEngine.class.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-3.0.html>
 */
class TaggingReloadedUtil {
        public static function readFormParameters() {
                $tags3 = array();

                // handle reloaded input
                if (isset($_REQUEST['taggingname']) && isset($_REQUEST['taggingval'])) {
                        if(count($_REQUEST['taggingname']) > count($_REQUEST['taggingval'])) {
                                $_REQUEST['taggingval'] = array_slice($_REQUEST['taggingval'], 0, count($_REQUEST['taggingname']));
                        } else if(count($_REQUEST['taggingname']) < count($_REQUEST['taggingval'])) {
                                $_REQUEST['taggingname'] = array_slice($_REQUEST['taggingname'], 0, count($_REQUEST['taggingval']));
                        }
                        $tags3 = array_combine($_REQUEST['taggingname'], $_REQUEST['taggingval']);
                }

                // handle classic input
                if (!isset($_REQUEST['wheeltags_enabled']) || !($_REQUEST['wheeltags_enabled'])) {
                        // copy reference
                        $tags = $tags3;
                        $tags3 = array();
                        
                        // proceed with classic
                        if (isset($_REQUEST['tags']) && !empty($_REQUEST['tags'])) {
                                foreach(TaggingUtil::splitString($_REQUEST['tags']) as $tag) {
                                        // use weights from modern input (even if hidden)
                                        if(array_key_exists($tag, $tags)) {
                                                $tags3[$tag] = $tags[$tag];
                                        } else if(array_key_exists($tag, $tags3)) {
                                                $tags3[$tag] *= 1.33; // increase with 33%
                                        } else {
                                                $tags3[$tag] = 100;
                                        }
                                }
                        }
                }
                
                // conversion from post to Tag
                foreach($tags3 as $name => $weight) {
                        if(strlen($name) < 3) {
                                unset($tags3[$name]);
                                continue;
                        }

                        $tags3[$name] = new Tag(null, array(
                                'name' => $name,
                                'weight' => $weight
                        ));
                }
                
                return $tags3;
        }
        
        protected static function deleteFromTagging3($userID, $tags, Tagged $object, $languageIDArray) {
                if(!count($tags)) return;
                
                $ids = array();
                foreach($tags as $tag) {
                        $ids[] = $tag->tagID;
                }
                
                $sql = "DELETE FROM     wcf".WCF_N."_tagging3
                        WHERE           taggableID = ".$object->getTaggable()->getTaggableID()."
                                        AND languageID IN (".implode(',', $languageIDArray).")
                                        AND objectID = ".$object->getObjectID()."
                                        AND tagID IN (".implode(",", $ids).")
                                        AND userID = ".intval($userID);
                WCF::getDB()->sendQuery($sql);
                $result = WCF::getDB()->sendQuery($sql);
        }
        
        /**
         * this is a reimplemenation of TagEngine::deleteObjectTags with a slite modification.
         * not all tags are deleted. just some tagIDs
         */
        protected static function deleteFromSystem($tags, Tagged $object, $languageIDArray) {
                if(!count($tags)) return;
                
                $ids = array();
                foreach($tags as $tag) {
                        $ids[] = $tag->tagID;
                }
                
                $sql = "DELETE FROM     wcf".WCF_N."_tag_to_object
                        WHERE           taggableID = ".$object->getTaggable()->getTaggableID()."
                                        AND languageID IN (".implode(',', $languageIDArray).")
                                        AND objectID = ".$object->getObjectID()."
                                        AND tagID IN (".implode(",", $ids).")";
                WCF::getDB()->sendQuery($sql);
                $result = WCF::getDB()->sendQuery($sql);
        }
        
        protected static function addToSystem($tags, Tagged $object, $languageID) {
                if(!count($tags)) return;
                
                $tags = array_keys($tags);
                try {
                        TagEngine::getInstance()->addTags($tags, $object, $languageID);
                } catch(Exception $e) {
                        // please handle
                }
        }
        
        /**
         * this is a reimplementation of TagEngine::addTags with a slite modification to write to our table and to update existing tables with weight
         */
        protected static function addToTagging3($userID, $tags, Tagged $object, $languageID) {
                if(!count($tags)) return;
                
                // store tagging3 database
                $tagIDs = array();
                foreach ($tags as $tag) {
                        $tagID = $tag->tagID ? $tag->tagID : Tag::test($tag->name, $languageID);
                        if (!$tagID) $tagID = Tag::insert($tag->name, $languageID);
                        
                        if (empty($tag->userID)) $tag->userID = $userID;
                        $tagIDs[$tagID] = $tag;
                }
                
                $sql = "REPLACE INTO    wcf".WCF_N."_tagging3
                                        (objectID, tagID, taggableID, languageID, userID, weight)
                        VALUES ";
                foreach ($tagIDs as $tagID => $tag) {
                        $sql .= "(" . $object->getObjectID() . ", " . $tagID . ", " . $object->getTaggable()->getTaggableID() . ", 
                                ".$languageID.", ".$tag->userID.", ".$tag->weight."),";
                }
                $sql = StringUtil::substring($sql, 0, StringUtil::length($sql) - 1);
                $result = WCF::getDB()->sendQuery($sql);
        }
        
        /**
         * save
         */
        public static function tagging3Save($userID, $tagged, $languageID, array $tags3, array $existingTagsUser = array(), array $existingTagsObject = array()) {
                $languageIDArray = array($languageID);
                
                // remove old links
                if(count($existingTagsUser) || count($existingTagsObject)) {
                
                        // tagging3: remove the link to the current user
                        $deleteFromTagging3 = TaggingReloadedUtil::diff($existingTagsUser, $tags3);
                
                        // woltlab system: when no other user has this tag, remove the link from tag to object
                        $deleteFromSystem = TaggingReloadedUtil::diff($deleteFromTagging3, $existingTagsObject);
                        
                        // tagging3: ids are known.. delete is easy
                        self::deleteFromTagging3($userID, $deleteFromTagging3, $tagged, $languageIDArray);
                        
                        // woltlab system: ids are known.. delete is easy
                        self::deleteFromSystem($deleteFromSystem, $tagged, $languageIDArray);
                }
                
                // tagging3: add user specific tags
                $addToTagging3 = TaggingReloadedUtil::diff($tags3, $existingTagsUser);
                
                // woltlab system: add link from tag to object
                $addToSystem = TaggingReloadedUtil::diff($addToTagging3, $existingTagsObject);
                
                // woltlab system: save
                self::addToSystem($addToSystem, $tagged, $languageID);
                
                // tagging3: save
                // attention: use $tags3 instead of the diff, because we want to update all weights
                self::addToTagging3($userID, $tags3, $tagged, $languageID);
        }

        /**
         * @return Tag[]
         */
        public static function getTagsByObject($userID, Tagged $tagged, $languageID, $even = true) {
                $taggableID = $tagged->getTaggable()->getTaggableID();
                $objectID = $tagged->getObjectID();
                
                $sign = $even ? '=' : '!=';
                $signline = $even === null ? '' : "AND userID $sign ".intval($userID);
        
                $sql = "SELECT          tag.*,
                                        userID,
                                        weight
                        FROM (
                                SELECT          tagID,
                                                userID,
                                                weight
                                FROM            wcf".WCF_N."_tagging3
                                WHERE           taggableID = ".intval($taggableID)."
                                AND             languageID = ".intval($languageID)."
                                AND             objectID = ".intval($objectID)."
                                ".$signline."
                        ) x
                        INNER JOIN      wcf".WCF_N."_tag tag USING(tagID)
                        ";
                $result = WCF::getDB()->sendQuery($sql);
                $tags = array();
                while ($row = WCF::getDB()->fetchArray($result)) {
                        $tags[$row['name']] = new Tag(null, $row);
                }
                return $tags;
        }

        /**
         * gets possible tags depending on rewrite rules
         *
         * @param       string          $name
         */
        public static function getPossibleFromRewritten($name) {
                // try with "-" and without
                if(strpos($name, '-') !== null) {
                        $names[] = str_replace('-', ' ', $name);
                }
                
                // try umlauts
                $umlauts = array(
                        'ae' => 'À',
                        'oe' => 'ö',
                        'ue' => 'Ì',
                        'ß' => 'ss',
                );
                if(preg_match('/('.implode('|', array_keys($umlauts)).')/', $name)) {
                        $names[] = str_replace(array_keys($umlauts), $umlauts, $name);
                }
                return $names;
        }

        /**
         * returns difference between two lists full of tag objects
         *
         * @param       array<Tag>      $list1
         * @param       array<Tag>      $list2
         */
        public static function diff($list1, $list2) {
                $diff = array_diff(array_keys($list1), array_keys($list2));
                foreach($list1 as $key => $val) {
                        if(!in_array($key, $diff)) {
                                unset($list1[$key]);
                        }
                }
                return $list1;
        }
        
        /**
         * begins with biggest value
         */
        public static function sort($result, $column = 'counter', $sort = 'ASC') {
                uasort($result, "TaggingReloadedUtil::sort".ucfirst($column));
                if($sort == 'DESC') {
                        arsort($result);
                }
                return $result;
        }
        
        public static function sortCounter($a, $b) {
                $key = 'counter';
                if ($a->$key == $b->$key) {
                        return 0;
                }
                return ($a->$key > $b->$key) ? 1 : -1;
        }
        
        public static function sortName($a, $b) {
                $key = 'name';
                if ($a->$key == $b->$key) {
                        return 0;
                }
                return ($a->$key > $b->$key) ? 1 : -1;
        }
        
        /**
         *
         */
        public static function fromMagicString($query) {
                $list = array();

                // clean
                $query = preg_replace('/(site:[^ ]+)/', '', $query);
                $query = str_replace('\\', '', $query);
                
                // aggregated
                if(preg_match_all('/"([^"]+)"|\'([^"]+)\'/', $query, $match)) {
                        $list = array_merge($match[1], $match[2]);
                        $list = array_filter($list);
                        $query = str_replace($match[0], ' ', $query);
                }
                
                // c++
                $query = preg_replace('/[Cc]\+\+/', 'cpp', $query);
                $query = preg_replace('/[\(\)\+\/]/', ' ', $query);
                
                $list2 = TaggingUtil::splitString($query, ',. ');
                $list = array_merge($list, $list2);
                
                $negative_file = dirname(__FILE__).'/negative.list';
                if(file_exists($negative_file)) {
                        $negative = file($negative_file);
                        $negative = array_map("StringUtil::trim", $negative);
                        $list = array_diff($list, $negative);
                }

                $arr = array();
                foreach($list as $tag) {
                        $arr[$tag] = new Tag(null, array(
                                'name' => $tag
                        ));
                }
                
                return $arr;
        }
}
?>