Sabot

class Tag_Model extends Model
{
    public function get_related_tags( $tags )
    {
        ## Get db entries with specific tags and build array with counts

        ## is it cached already? ------------------------------------------------
        $this->cache = Cache::instance();
        $tags = array_filter( array_flip(array_flip($tags)) );
        sort($tags);
        $cache_name = implode('', $tags);
        $cache = $this->cache->get( $cache_name );

        if( $cache )
         return $cache;

        ## not cached, fire up ---------------------------------------------------

        $db = Database::instance();

        ## count tagged items ----------------------------------------------------

        // build like string
        $like = array();
        foreach( $tags as $tag )
           $like[] = "tags LIKE '%$tag%'";

        $like = implode(' AND ', $like);

        // get counts
        $count = $db->query("SELECT count(id) AS count FROM `articles` WHERE $like")->current()->count;

        ## check what tags are related ------------------------------------------

        $offset = 0;
        $step = 300;

        $related_tags = array();

        while( $offset < $count )
        {
            $assets = $db->query("SELECT tags FROM `articles` WHERE $like ORDER BY id ASC LIMIT $step OFFSET $offset");

            foreach($assets as $asset)
            {
                // tags
                $input = explode( ' ', trim($asset->tags) );
                foreach( $input as $k => $v )
                {
                     if( $v == ''){
                         //do nothing, shouldnt be here anyway
                     }
                     elseif( array_key_exists($v, $related_tags) ){
                         $related_tags[$v]++;
                     }
                     else{
                        $related_tags[$v] = 1;
                     }
                }
            }
            $offset += $step;
        }

        // remove already displayed from list
        foreach( $tags as $tag )
            unset( $related_tags[$tag] );

        ksort($related_tags);

        // set cache
        $this->cache->set( $cache_name, array($related_tags, $count), 'related_tags_counts', 0);

        return array($related_tags, $count);
    }

    public function update_tags( $tags, $saved_tags )
    {
        // make array if not already
        if( ! is_array($tags) )
        {
            $tags = explode(' ', trim($tags) );
        }

        if( ! is_array($saved_tags) )
        {
            $saved_tags = explode(' ', trim($saved_tags) );
        }

        // find new tags
        $new_tags = array_filter( array_diff($tags, $saved_tags) );

            // update counts
            if( count($new_tags) > 0 )
            {
                $this->add_tags($new_tags);
            }

        // find removed tags
        $removed_tags = array_filter( array_diff($saved_tags, $tags) );

            // update counts
            if( count($removed_tags) > 0 )
            {
                $this->remove_tags($removed_tags);
            }
    }

    private function add_tags( $new_tags )
    {
        $db = Database::instance();

        // check if tags are new system wide
        // try to load all and then compare
        $tags_db = array();
        $tags_in_db = $db->in('tag_name', $new_tags)->get('tags');

        foreach( $tags_in_db as $t )
        {
            $tags_db[] = $t->tag_name;
        }

        $system_new_tags = array_filter( array_diff($new_tags, $tags_db) );

        // insert new tags to db if necessary
        if( count($system_new_tags) > 0 )
        {
            $tag_array = array();
            foreach( $system_new_tags as $t )
            {
                $tag_array[] = "('$t')";
            }

            $tag_str = implode(',', $tag_array);

            $sql = "INSERT INTO tags (tag_name) VALUES $tag_str";
            $db->query($sql);
        }

        // update counts
        $tag_array = array();
        foreach( $new_tags as $t )
        {
            $tag_array[] = "'$t'";
        }

        $tag_str = implode(',', $tag_array);

        $sql = "UPDATE tags SET `tag_count`=`tag_count`+1 WHERE `tag_name` IN ($tag_str)";
        $db->query($sql);
    }

    private function remove_tags( $removed_tags )
    {
        $db = Database::instance();

        // update counts
        $tag_array = array();
        foreach( $removed_tags as $t )
        {
            $tag_array[] = "'$t'";
        }

        $tag_str = implode(',', $tag_array);

        $sql = "UPDATE tags SET `tag_count`=`tag_count`-1 WHERE `tag_name` IN ($tag_str)";
        $db->query($sql);
    }

}