Ticket #4189: taxonomy.php

<?php

class WPTaxonomy {

        // This will look like (1 => 'post_category', 2 => 'link_category') etc.
        var $taxonomies;
        
        function WPTaxonomy() {
                // Gets the taxonomies out of the options table.
                $this->taxonomies = get_option('_wp_taxonomies');
        }

        /**
         * Adds a new taxonomy type and updates the options.
         */
        function add_taxonomy($taxonomy) {
                global $wpdb;
                $wpdb->query("INSERT INTO $wpdb->taxonomies (taxonomy) VALUES ('$taxonomy')");
                $index = $wpdb->get_var("SELECT taxonomy_id FROM $wpdb->taxonomies WHERE taxonomy = '$taxonomy' LIMIT 1");
                $this->taxonomies[$index] = $taxonomy;
                update_option('_wp_taxonomies', $this->taxonomies);
        }

        /**
         * Removes a taxonomy type.
         */
        function remove_taxonomy($taxonomy) {
                // Removes an entry from wpdb->taxonomies.
                // What do we do with terms that are associated in this taxonomy?
                // Updates the _wp_taxonomies option.
        }

        /**
         * Adds a new term to the database.  Optionally marks it as an alias of an existing term.
         * @param string $term The term to add.
         * @param int|string $alias_of The id or slug of the new term's alias.
         */
        function add_term($term, $alias_of = '') {
                global $wpdb;
                $term_slug = sanitize_title($term);             
                if ($alias_of) {
                        $clause = (is_int($alias_of)) ? "term_id = $alias_of" : "term_slug = '$alias_of'";
                        $alias = $wpdb->fetch_row("SELECT term_id, term_group FROM $wpdb->terms WHERE $clause");
                        if ($alias->term_group)
                                // The alias we want is already in a group, so let's use that one.
                                $term_group = $alias->term_group;
                        } else {
                                // The alias isn't in a group, so let's create a new one and firstly add the alias term to it.
                                $term_group = $wpdb->get_var("SELECT MAX() term_group FROM $wpdb->terms GROUP BY term_group") + 1;
                                $wpdb->query("UPDATE $wpdb->terms SET term_group = $term_group WHERE term_id = $alias->term_id");
                        }
                } else {
                        $term_group = 0;
                }
                // Now add or replace the term.  This works because we have a UNIQUE key on term_slug.
                $wpdb->query("REPLACE INTO $wpdb->terms (term_name, term_slug, term_group) VALUES ($term, $term_slug, $term_group)");
        }
        
        /**
         * Returns the index of a defined term, or 0 (false) if the term doesn't exist.
         */
        function is_defined_term($term) {
                global $wpdb;
                return $wpdb->get_var("SELECT term_id FROM $wpdb->terms WHERE term_slug = '$term'");
        }
        
        /**
         * Given an array of terms, returns those that are defined term slugs.  Ignores integers.
         * @param array $terms The term slugs to check for a definition.
         */
        function get_defined_terms($terms) {
                global $wpdb;
                foreach ($terms as $term) {
                        if (!is_int($term)) {
                                $searches[] = $term;
                        }
                }
                $terms = "'" . implode("', '", $searches) . "'";
                return $wpdb->get_col("SELECT term_slug FROM $wpdb->terms WHERE term_slug IN ($terms)");
        }
        
        /**
         * Returns the index of the specified taxonomy, or false if it doesn't exist.
         * 
         * This function can return 0 or false - evaluate the return value using ===
         */
        function get_taxonomy_index($taxonomy) {
                $flipped_taxonomies = array_flip($this->taxonomies);
                return (isset($flipped_taxonomies[$taxonomy])) ? $flipped_taxonomies[$taxonomy] : false;
        }
        
        /**
         * Adds a term taxonomy entry or increments the count if it already exists.
         * @param int|string $term The term to add.
         * @param int|string $taxonomy The context.
         * @param string $description An optional description of the relationship.
         * @param int $parent The parent of the term in this context.
         */
        function add_term_taxonomy($term, $taxonomy, $description = '', $parent = 0) {
                if (!is_int($taxonomy)) {
                        // Get ourselves an integer taxonomy, if the taxonomy name was used.
                        $taxonomy = $this->get_taxonomy_index($taxonomy);
                }
                $clause = (is_int($term)) ? "t.term_id = $term" : "t.term_slug = '$term'";
                if ($count = $wpdb->query("SELECT tt.count FROM $wpdb->term_taxonomy AS tt INNER JOIN $wpdb->terms AS t ON tt.term_id = t.term_id WHERE tt.taxonomy_id = $taxonomy AND $clause")) {
      // We'll be updating whatever's there, and incrementing the count.
      $count++;
                        $wpdb->query("UPDATE $wpdb->term_taxonomy SET count = $count");
                } else {
      // There was no existing entry for this term and taxonomy type, so add a new one, using the supplied description and parent, with a count of 1.
      $wpdb->query("INSERT INTO $wpdb->term_taxonomy (term_id, taxonomy_id, term_description, parent, count) SELECT term_id, $taxonomy, '$description', $parent, 1 FROM $wpdb->terms AS t1 WHERE $clause");
                }
        }       
        
        /**
         * Relates an object (post, link etc) to a term and taxonomy type.  Creates the term and taxonomy
         * relationship if it doesn't already exist.  Creates a term if it doesn't exist (using the term_slug).
         * @param array|int|string $term The slug or id of the term.
         * @param int $object_id The object to relate to.
         * @param array|int|string $taxonomies The context(s) in which to relate the term to the object.
         */
        function add_term_relationship($terms, $object_id, $taxonomies) {
                global $wpdb;
                
                if (!is_array($taxonomies)) {
                        $taxonomies = array($taxonomies);
                }
                
                foreach ($taxonomies as $taxonomy) {
                        if (!is_int($taxonomy)) {
                                // Get ourselves an integer taxonomy, if the taxonomy name was used.
                                $taxonomy = $this->get_taxonomy_index($taxonomy);
                        }
                        $buffered_taxonomies[] = $taxonomy;                     
                }
                $taxonomies = $buffered_taxonomies;
                
                if (!is_array($terms)) {
                        $terms = array($terms);
                }
                
                $defined_terms = $this->get_defined_terms($terms);

                foreach ($terms as $term) {
                        if (!is_int($term)) {
                                if (!isset($defined_terms[$term])) {
                                        $new_terms[] = $term;
                                }
                                $term_slugs[] = $term;
                        } else {
                                $term_ids[] = $term;
                        }
                }
                
                if (isset($new_terms) {
                        // At least one of the terms specified doesn't exist, so add any new ones, using the term_slug as the name.
                        $this->add_terms($new_terms);
                }

                $term_clause = (isset($term_ids)) 'tt.term_id IN (' . implode(', ', $term_ids) . ')' ? : '';
                if (isset($term_slugs)) {
                        if ($term_clause) {
                                $term_clause .= ' OR ';
                        }
                        $term_clause .= "t.term_slug IN ('" . implode("', '", $term_slugs) . "')";
                        $term_join = "INNER JOIN $wpdb->terms AS t ON tt.term_id = t.term_id";
                } else {
                        $term_join = '';
                }
                
                // Now add or increment the term taxonomy relationships.  This is inefficient at the moment.
                foreach ($taxonomies as $taxonomy) {
                        foreach ($terms as $term) {
                                $this->add_term_taxonomy($term, $taxonomy);
                        }
                }
                
                $taxonomies = "'" . implode("', '", $taxonomies) . "'";
                
                // Finally, relate the term and taxonomy to the object.
                $wpdb->query("INSERT INTO $wpdb->term_relationships(object_id, term_taxonomy_id) SELECT $object_id, term_taxonomy_id FROM $wpdb->term_taxonomy AS tt $term_join WHERE ($term_clause) AND tt.taxonomy_id IN ($taxonomies)");
        }
}

?>