root/include/class.tags.php

<?php

class tags {</span>
<span class="code-keyword">
    static $fast_mode = false;
    static $auth_check = false;
    static $tag_cat_id = 0;
    static $tag_owner = 0;

    //fast mode is for first add tags, in uploading for example
    function set_fast_add_mode () {
        if ( !self::$tag_cat_id || !self::$tag_owner ) {
            throw new Exception('set cat_id and owner first');
        }
        self::$fast_mode = true;
    }

    function tag_cloud_for_cat ( $cat_id ) {
        global $db, $userdata, $config;

        $tags = array();

        $cats_sql = '';

        if ( is_array($cat_id) && sizeof($cat_id) ) {
            $cats_sql .=  ' AND tt.tag_cat_id IN (' . implode(', ', $cat_id) . ')';
        }
        elseif ( $cat_id ) {
            $cats_sql .=  ' AND tt.tag_cat_id = ' . $cat_id;
        }

        $sql = 'SELECT tt.tag_name, SUM(tt.tag_count) AS tag_count
                FROM ' . TAGS_TABLE . ' tt, ' . CATEGORIES_TABLE . ' c
                WHERE tt.tag_type = ' . TYPE_TORRENT . '
                AND tt.tag_cat_id = c.id ' . ( $userdata['session_logged_in'] ? '' : ' AND c.anonymous_view = 1 ' ) . $cats_sql . '
                GROUP BY tt.tag_name
                ORDER BY tag_count DESC';
        $result = $db->sql_query_limit($sql, 30, 0, 3600);

        if ( $row = $db->sql_fetchrow($result) ) {
            $max_qty = $min_qty = 0;
            do {
                $tags[] = $row;
                $max_qty = max($max_qty, $row['tag_count']);
                $min_qty = min($min_qty, $row['tag_count']);
            }
            while ( $row = $db->sql_fetchrow($result) );

            $spread = $max_qty - $min_qty;
            $spread = ( $spread == 0 ? 1 : $spread );

            $step = ( $config['max_tag_size'] - $config['min_tag_size'] ) / $spread;

            foreach ( $tags AS $_null => &$tag_ary ) {
                $tag_ary['enc_tag_name'] = tags::encode_tag_name($tag_ary['tag_name']);
                $tag_ary['size'] = tags::get_tag_size($tag_ary['tag_count'], $min_qty, $step);
            }

            shuffle($tags);
        }

        return $tags;
    }

    function encode_tag_name ( $tag_name ) {
        $enc_tag_name = undo_htmlspecialchars($tag_name);
        $enc_tag_name = rawurlencode($enc_tag_name);

        return $enc_tag_name;
    }

    function get_tag_size ( $tag_count, $min_qty, $step ) {
        global $config;

        return round($config['min_tag_size'] + (($tag_count - $min_qty) * $step));
    }

    function tags_for_single ( $type, $id ) {
        global $db, $config;

        $sql = 'SELECT tag_name, tag_count
                FROM ' . TAGS_TABLE . '
                WHERE tag_type = ' . $type . '
                AND tag_for_id = ' . $id;
        $result = $db->sql_query($sql);

        $tags = array();

        while ( $row = $db->sql_fetchrow($result) ) {
            $tags[$row['tag_name']] = $row['tag_count'];
        }

        return tags::build_tag_cloud_by_ary($tags);
    }

    function build_tag_cloud_by_ary ( $tags = array() ) {
        global $config;

        $new_tags = array();

        if ( !sizeof($tags) ) {
            return $new_tags;
        }

        //simple tag cloud find here http://www.bytemycode.com/snippets/snippet/415/
        $max_qty = max(array_values($tags));
        $min_qty = min(array_values($tags));

        $spread = $max_qty - $min_qty;
        $spread = ( $spread == 0 ? 1 : $spread );

        $step = ( $config['max_tag_size'] - $config['min_tag_size'] ) / $spread;

        $i = 0;

        foreach ( $tags AS $tag_name => $tag_count ) {
            $size = tags::get_tag_size($tag_count, $min_qty, $step);
            ++$i;

            $new_tags[] = array(
                'tag_name' => $tag_name,
                'js_tag_name' => str_replace("'", "\'", $tag_name),
                'enc_tag_name' => tags::encode_tag_name($tag_name),
                'tag_size' => $size,
                'tag_num' => $i,
            );
        }

        return $new_tags;
    }

    function simple_get_tag_for_single ( $type, $id ) {
        global $db;

        $tags = array();

        $sql = 'SELECT tag_count, tag_name
                    FROM ' . TAGS_TABLE . '
                    WHERE tag_type = ' . $type . '
                    AND tag_for_id = ' . $id;
        $result = $db->sql_query($sql);
        while( $row = $db->sql_fetchrow($result) ){
            $tags[$row['tag_name']] = $row['tag_count'];
        }

        return $tags;
    }

    function set_tag_cat_id( $cat_id = 0 ){
        self::$tag_cat_id = $cat_id;
    }

    function set_tag_owner( $owner = 0 ){
        self::$tag_owner = $owner;
    }

    function add_tag ( $type, $id, $tag_name, $vote_type ) {
        global $config, $lang;

        $tag_name = urldecode($tag_name);
        $ret_message = array();
        $prev_tags = array();

        if ( strpos($tag_name, ',') !== false ) {
            $tag_name = explode(',', $tag_name);
        }
        else {
            $tag_name = array($tag_name);
        }
        tags::clean_tag($tag_name);

        if ( !self::$fast_mode ) {
            if ( !sizeof($tag_name) ) {
                return $lang['access_denied'];
            }

            if ( !$error = add_tags_for::getHandle($type, $id) ) {
                return $lang['access_denied'];
            }

            if ( !self::$auth_check && !tags::check_allow_add($config['tags_who_allowed']) ) {
                return $lang['access_denied'];
            }

            if ( !tags::check_max_user_tags($config['tags_max_allow'], $id, $type, $tag_name) ) {
                return sprintf($lang['no_more_tags_allowed'], $config['tags_max_allow']);
            }
        }

        $prev_tags = tags::simple_get_tag_for_single($type, $id);

        foreach ( $tag_name AS $_null => $name ) {
            if ( !tags::check_tag_length($config['tags_min_length'], $config['tags_max_length'], $name) ) {
                $ret_message[] = sprintf($lang['tag_is_too_short_or_long'], $name, $config['tags_min_length'], $config['tags_max_length']);
                continue;
            }

            if ( !self::$fast_mode && tags::check_dupe_tag($id, $type, $name) ) {
                $ret_message[] = $lang['dupe_vote'] . ' ' . $name;
                continue;
            }

            $prev_tags_count = ( isset($prev_tags[$name]) ? (int) $prev_tags[$name] : 0 ); // 2 is for tag vote down

            $func = 'tag_vote_' . $vote_type;
            tags::$func($type, $id, $name, $prev_tags_count);

            tags::insert_tag_user($type, $id, $name);
        }

        return implode("\n", $ret_message);
    }

    function clean_tag ( &$tag_name ) {
        if ( is_array($tag_name) ) {
            array_walk($tag_name, 'tags::clean_tag');
            array_filter($tag_name);
            return;
        }
        $tag_name = trim($tag_name);
        $tag_name = preg_replace('/[\.,:\^]/', '', $tag_name);
        $tag_name = utf_strtolower($tag_name);
    }

    function insert_tag_user ($type, $id, $name ) {
        global $db, $userdata;

        $sql = 'INSERT INTO ' . TAGS_USERS_TABLE . ' ' . $db->sql_build_array('INSERT', array(
            'tag_users_uid' => $userdata['uid'],
            'tag_users_for_id' => $id,
            'tag_users_type' => $type,
            'tag_users_name' => $name,
        ));
        $db->sql_query($sql);
    }

    function tag_vote_down ( $type, $id, $tag_name, &$tags_count ) {
        global $db;

        if ( !$tags_count ) {
            return;
        }

        if ( $tags_count <= 1 ) {
            $sql = 'DELETE FROM ' . TAGS_TABLE . '
                    WHERE tag_name = \'' . $db->sql_escape($tag_name) . '\'
                    AND tag_type = ' . $type . '
                    AND tag_for_id = ' . $id;
        }
        else {
            $sql = 'UPDATE ' . TAGS_TABLE . '
                    SET tag_count = tag_count - 1
                    WHERE tag_name = \'' . $db->sql_escape($tag_name) . '\'
                    AND tag_type = ' . $type . '
                    AND tag_for_id = ' . $id;
        }
        $db->sql_query($sql);

        --$tags_count;

        return;
    }

    function tag_vote_up ( $type, $id, $tag_name, &$tags_count ) {
        global $db;

        if ( $tags_count ) {
            $sql = 'UPDATE ' . TAGS_TABLE . '
                SET tag_count = tag_count + 1
                WHERE tag_name = \'' . $db->sql_escape($tag_name) . '\'
                AND tag_type = ' . $type . '
                AND tag_for_id = ' . $id;
            $db->sql_query($sql);
        }
        else {
            $sql = 'INSERT INTO ' . TAGS_TABLE . ' ' . $db->sql_build_array('INSERT', array(
                'tag_name' => $tag_name,
                'tag_type' => $type,
                'tag_for_id' => $id,
                'tag_count' => 1,
                'tag_cat_id' => self::$tag_cat_id,
            ));
            $db->sql_query($sql);
        }

        ++$tags_count;

        return;
    }

    function check_dupe_tag ( $id, $tag_type, $name) {
        global $db, $userdata;

        $sql = 'SELECT tag_users_for_id
                FROM ' . TAGS_USERS_TABLE . '
                WHERE tag_users_uid = ' . $userdata['uid'] . '
                AND tag_users_for_id = ' . $id . '
                AND tag_users_type = ' . $tag_type . '
                AND tag_users_name = \'' . $db->sql_escape($name) . '\'';
        $result = $db->sql_query($sql);
        return $db->sql_fetchrow($result);
    }

    function check_tag_length ( $min, $max, $tag_name ){
        $tag_length = utf_strlen($tag_name);

        if ( $max && $tag_length > $max ) {
            return false;
        }
        if ( $min && $tag_length < $min ) {
            return false;
        }

        return true;
    }

    function check_allow_add( $tags_who_allowed ) {
        global $userdata;

        if ( self::$auth_check ) {
            return true;
        }

        switch ( $tags_who_allowed ) {
            case 0:
                $allow_add_tags = true;
            break;

            case 1:
                $allow_add_tags = $userdata['uid'] == self::$tag_owner || $userdata['class'] >= UC_MODERATOR;
            break;

            case 2:
                $allow_add_tags = $userdata['class'] >= UC_MODERATOR;
            break;
        }

        self::$auth_check = true;

        return $allow_add_tags;

    }

    function return_allow_add_tag ( $type, $id, $owner = false ) {
        global $config, $userdata;

        self::$auth_check = true;

        self::$tag_owner = $owner;

        if ( !self::$tag_owner ) {
            add_tags_for::getHandle($type, $id);
        }

        if ( !self::$tag_owner ) {
            return false;
        }

        switch ( $config['tags_who_allowed'] ) {
            case 0:
                $allow_add_tags = true;
            break;

            case 1:
                $allow_add_tags = $userdata['uid'] == self::$tag_owner || $userdata['class'] >= UC_MODERATOR;
            break;

            case 2:
                $allow_add_tags = $userdata['class'] >= UC_MODERATOR;
            break;
        }

        return $allow_add_tags;
    }

    function check_max_user_tags ( $tags_max_allow, $id, $tag_type, $tag_name ) {
        global $userdata, $db;

        if ( !$tags_max_allow ) {
            return;
        }

        $sql = 'SELECT COUNT(*) AS count FROM ' . TAGS_USERS_TABLE . ' WHERE tag_users_uid = ' . $userdata['uid'] . ' AND tag_users_for_id = ' . $id . ' AND tag_users_type = ' . $tag_type;
        $result = $db->sql_query($sql);
        $count = ( $row = $db->sql_fetchrow($result) ) ? $row['count'] : 0;

        if ( $count >= $tags_max_allow || ( ( sizeof($tag_name) + $count ) >= $tags_max_allow ) ) {
            return false;
        }
        return true;
    }
}

class add_tags_for extends tags {
    function __construct() {
    }

    function getHandle($type, $id) {
        $func = 'add_for_' . $type;
        return add_tags_for::$func($id);
    }

    //torrent
    function add_for_1($id) {
        global $db;

        $sql = 'SELECT owner, category FROM ' . TORRENTS_TABLE . ' WHERE fid = ' . $id;
        $result = $db->sql_query($sql);
        if ( $row = $db->sql_fetchrow($result) ) {
            self::$tag_owner = $row['owner'];
            self::$tag_cat_id = $row['category'];
            return true;
        }
        return false;
    }
}
?>