<?php

/**

 * Taxonomy API

 *

 * @package WordPress

 * @subpackage Taxonomy

 * @since 2.3.0

 */

//

// Taxonomy Registration

//

/**

 * Creates the initial taxonomies when 'init' action is fired.

 */

function create_initial_taxonomies() {

	register_taxonomy( 'category', 'post', array('hierarchical' => true, 'update_count_callback' => '_update_post_term_count', 'label' => __('Categories'), 'query_var' => false, 'rewrite' => false) ) ;

	register_taxonomy( 'post_tag', 'post', array('hierarchical' => false, 'update_count_callback' => '_update_post_term_count', 'label' => __('Post Tags'), 'query_var' => false, 'rewrite' => false) ) ;

	register_taxonomy( 'link_category', 'link', array('hierarchical' => false, 'label' => __('Categories'), 'query_var' => false, 'rewrite' => false) ) ;

}

add_action( 'init', 'create_initial_taxonomies', 0 ); // highest priority

/**

 * Return all of the taxonomy names that are of $object_type.

 *

 * It appears that this function can be used to find all of the names inside of

 * $wp_taxonomies global variable.

 *

 * <code><?php $taxonomies = get_object_taxonomies('post'); ?></code> Should

 * result in <code>Array('category', 'post_tag')</code>

 *

 * @package WordPress

 * @subpackage Taxonomy

 * @since 2.3.0

 *

 * @uses $wp_taxonomies

 *

 * @param array|string|object $object Name of the type of taxonomy object, or an object (row from posts)

 * @return array The names of all taxonomy of $object_type.

 */

function get_object_taxonomies($object) {

	global $wp_taxonomies;

	if ( is_object($object) ) {

		if ( $object->post_type == 'attachment' )

			return get_attachment_taxonomies($object);

		$object = $object->post_type;

	}

	$object = (array) $object;

	$taxonomies = array();

	foreach ( (array) $wp_taxonomies as $taxonomy ) {

		if ( array_intersect($object, (array) $taxonomy->object_type) )

			$taxonomies[] = $taxonomy->name;

	}

	return $taxonomies;

}

/**

 * Retrieves the taxonomy object of $taxonomy.

 *

 * The get_taxonomy function will first check that the parameter string given

 * is a taxonomy object and if it is, it will return it.

 *

 * @package WordPress

 * @subpackage Taxonomy

 * @since 2.3.0

 *

 * @uses $wp_taxonomies

 * @uses is_taxonomy() Checks whether taxonomy exists

 *

 * @param string $taxonomy Name of taxonomy object to return

 * @return object|bool The Taxonomy Object or false if $taxonomy doesn't exist

 */

function get_taxonomy( $taxonomy ) {

	global $wp_taxonomies;

	if ( ! is_taxonomy($taxonomy) )

		return false;

	return $wp_taxonomies[$taxonomy];

}

/**

 * Checks that the taxonomy name exists.

 *

 * @package WordPress

 * @subpackage Taxonomy

 * @since 2.3.0

 *

 * @uses $wp_taxonomies

 *

 * @param string $taxonomy Name of taxonomy object

 * @return bool Whether the taxonomy exists or not.

 */

function is_taxonomy( $taxonomy ) {

	global $wp_taxonomies;

	return isset($wp_taxonomies[$taxonomy]);

}

/**

 * Whether the taxonomy object is hierarchical.

 *

 * Checks to make sure that the taxonomy is an object first. Then Gets the

 * object, and finally returns the hierarchical value in the object.

 *

 * A false return value might also mean that the taxonomy does not exist.

 *

 * @package WordPress

 * @subpackage Taxonomy

 * @since 2.3.0

 *

 * @uses is_taxonomy() Checks whether taxonomy exists

 * @uses get_taxonomy() Used to get the taxonomy object

 *

 * @param string $taxonomy Name of taxonomy object

 * @return bool Whether the taxonomy is hierarchical

 */

function is_taxonomy_hierarchical($taxonomy) {

	if ( ! is_taxonomy($taxonomy) )

		return false;

	$taxonomy = get_taxonomy($taxonomy);

	return $taxonomy->hierarchical;

}

/**

 * Create or modify a taxonomy object. Do not use before init.

 *

 * A simple function for creating or modifying a taxonomy object based on the

 * parameters given. The function will accept an array (third optional

 * parameter), along with strings for the taxonomy name and another string for

 * the object type.

 *

 * Nothing is returned, so expect error maybe or use is_taxonomy() to check

 * whether taxonomy exists.

 *

 * Optional $args contents:

 *

 * hierarachical - has some defined purpose at other parts of the API and is a

 * boolean value.

 *

 * update_count_callback - works much like a hook, in that it will be called

 * when the count is updated.

 *

 * rewrite - false to prevent rewrite, or array('slug'=>$slug) to customize

 * permastruct; default will use $taxonomy as slug.

 *

 * query_var - false to prevent queries, or string to customize query var

 * (?$query_var=$term); default will use $taxonomy as query var.

 *

 * @package WordPress

 * @subpackage Taxonomy

 * @since 2.3.0

 * @uses $wp_taxonomies Inserts new taxonomy object into the list

 * @uses $wp_rewrite Adds rewrite tags and permastructs

 * @uses $wp Adds query vars

 *

 * @param string $taxonomy Name of taxonomy object

 * @param array|string $object_type Name of the object type for the taxonomy object.

 * @param array|string $args See above description for the two keys values.

 */

function register_taxonomy( $taxonomy, $object_type, $args = array() ) {

	global $wp_taxonomies, $wp_rewrite, $wp;

	if (!is_array($wp_taxonomies))

		$wp_taxonomies = array();

	$defaults = array('hierarchical' => false, 'update_count_callback' => '', 'rewrite' => true, 'query_var' => true);

	$args = wp_parse_args($args, $defaults);

	if ( false !== $args['query_var'] && !empty($wp) ) {

		if ( true === $args['query_var'] )

			$args['query_var'] = $taxonomy;

		$args['query_var'] = sanitize_title_with_dashes($args['query_var']);

		$wp->add_query_var($args['query_var']);

	}

	if ( false !== $args['rewrite'] && !empty($wp_rewrite) ) {

		if ( !is_array($args['rewrite']) )

			$args['rewrite'] = array();

		if ( !isset($args['rewrite']['slug']) )

			$args['rewrite']['slug'] = sanitize_title_with_dashes($taxonomy);

		$wp_rewrite->add_rewrite_tag("%$taxonomy%", '([^/]+)', $args['query_var'] ? "{$args['query_var']}=" : "taxonomy=$taxonomy&term=$term");

		$wp_rewrite->add_permastruct($taxonomy, "{$args['rewrite']['slug']}/%$taxonomy%");

	}

	$args['name'] = $taxonomy;

	$args['object_type'] = $object_type;

	$wp_taxonomies[$taxonomy] = (object) $args;

}

//

// Term API

//

/**

 * Retrieve object_ids of valid taxonomy and term.

 *

 * The strings of $taxonomies must exist before this function will continue. On

 * failure of finding a valid taxonomy, it will return an WP_Error class, kind

 * of like Exceptions in PHP 5, except you can't catch them. Even so, you can

 * still test for the WP_Error class and get the error message.

 *

 * The $terms aren't checked the same as $taxonomies, but still need to exist

 * for $object_ids to be returned.

 *

 * It is possible to change the order that object_ids is returned by either

 * using PHP sort family functions or using the database by using $args with

 * either ASC or DESC array. The value should be in the key named 'order'.

 *

 * @package WordPress

 * @subpackage Taxonomy

 * @since 2.3.0

 *

 * @uses $wpdb

 * @uses wp_parse_args() Creates an array from string $args.

 *

 * @param string|array $terms String of term or array of string values of terms that will be used

 * @param string|array $taxonomies String of taxonomy name or Array of string values of taxonomy names

 * @param array|string $args Change the order of the object_ids, either ASC or DESC

 * @return WP_Error|array If the taxonomy does not exist, then WP_Error will be returned. On success

 *	the array can be empty meaning that there are no $object_ids found or it will return the $object_ids found.

 */

function get_objects_in_term( $terms, $taxonomies, $args = array() ) {

	global $wpdb;

	if ( !is_array( $terms) )

		$terms = array($terms);

	if ( !is_array($taxonomies) )

		$taxonomies = array($taxonomies);

	foreach ( (array) $taxonomies as $taxonomy ) {

		if ( ! is_taxonomy($taxonomy) )

			return new WP_Error('invalid_taxonomy', __('Invalid Taxonomy'));

	}

	$defaults = array('order' => 'ASC');

	$args = wp_parse_args( $args, $defaults );

	extract($args, EXTR_SKIP);

	$order = ( 'desc' == strtolower($order) ) ? 'DESC' : 'ASC';

	$terms = array_map('intval', $terms);

	$taxonomies = "'" . implode("', '", $taxonomies) . "'";

	$terms = "'" . implode("', '", $terms) . "'";

	$object_ids = $wpdb->get_col("SELECT tr.object_id FROM $wpdb->term_relationships AS tr INNER JOIN $wpdb->term_taxonomy AS tt ON tr.term_taxonomy_id = tt.term_taxonomy_id WHERE tt.taxonomy IN ($taxonomies) AND tt.term_id IN ($terms) ORDER BY tr.object_id $order");

	if ( ! $object_ids )

		return array();

	return $object_ids;

}

/**

 * Get all Term data from database by Term ID.

 *

 * The usage of the get_term function is to apply filters to a term object. It

 * is possible to get a term object from the database before applying the

 * filters.

 *

 * $term ID must be part of $taxonomy, to get from the database. Failure, might

 * be able to be captured by the hooks. Failure would be the same value as $wpdb

 * returns for the get_row method.

 *

 * There are two hooks, one is specifically for each term, named 'get_term', and

 * the second is for the taxonomy name, 'term_$taxonomy'. Both hooks gets the

 * term object, and the taxonomy name as parameters. Both hooks are expected to

 * return a Term object.

 *

 * 'get_term' hook - Takes two parameters the term Object and the taxonomy name.

 * Must return term object. Used in get_term() as a catch-all filter for every

 * $term.

 *

 * 'get_$taxonomy' hook - Takes two parameters the term Object and the taxonomy

 * name. Must return term object. $taxonomy will be the taxonomy name, so for

 * example, if 'category', it would be 'get_category' as the filter name. Useful

 * for custom taxonomies or plugging into default taxonomies.

 *

 * @package WordPress

 * @subpackage Taxonomy

 * @since 2.3.0

 *

 * @uses $wpdb

 * @uses sanitize_term() Cleanses the term based on $filter context before returning.

 * @see sanitize_term_field() The $context param lists the available values for get_term_by() $filter param.

 *

 * @param int|object $term If integer, will get from database. If object will apply filters and return $term.

 * @param string $taxonomy Taxonomy name that $term is part of.

 * @param string $output Constant OBJECT, ARRAY_A, or ARRAY_N

 * @param string $filter Optional, default is raw or no WordPress defined filter will applied.

 * @return mixed|null|WP_Error Term Row from database. Will return null if $term is empty. If taxonomy does not

 * exist then WP_Error will be returned.

 */

function &get_term($term, $taxonomy, $output = OBJECT, $filter = 'raw') {

	global $wpdb;

	if ( empty($term) ) {

		$error = new WP_Error('invalid_term', __('Empty Term'));

		return $error;

	}

	if ( ! is_taxonomy($taxonomy) ) {

		$error = new WP_Error('invalid_taxonomy', __('Invalid Taxonomy'));

		return $error;

	}

	if ( is_object($term) && empty($term->filter) ) {

		wp_cache_add($term->term_id, $term, $taxonomy);

		$_term = $term;

	} else {

		if ( is_object($term) )

			$term = $term->term_id;

		$term = (int) $term;

		if ( ! $_term = wp_cache_get($term, $taxonomy) ) {

			$_term = $wpdb->get_row( $wpdb->prepare( "SELECT t.*, tt.* FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id WHERE tt.taxonomy = %s AND t.term_id = %s LIMIT 1", $taxonomy, $term) );

			wp_cache_add($term, $_term, $taxonomy);

		}

	}

	$_term = apply_filters('get_term', $_term, $taxonomy);

	$_term = apply_filters("get_$taxonomy", $_term, $taxonomy);

	$_term = sanitize_term($_term, $taxonomy, $filter);

	if ( $output == OBJECT ) {

		return $_term;

	} elseif ( $output == ARRAY_A ) {

		$__term = get_object_vars($_term);

		return $__term;

	} elseif ( $output == ARRAY_N ) {

		$__term = array_values(get_object_vars($_term));

		return $__term;

	} else {

		return $_term;

	}

}

/**

 * Get all Term data from database by Term field and data.

 *

 * Warning: $value is not escaped for 'name' $field. You must do it yourself, if

 * required.

 *

 * The default $field is 'id', therefore it is possible to also use null for

 * field, but not recommended that you do so.

 *

 * If $value does not exist, the return value will be false. If $taxonomy exists

 * and $field and $value combinations exist, the Term will be returned.

 *

 * @package WordPress

 * @subpackage Taxonomy

 * @since 2.3.0

 *

 * @uses $wpdb

 * @uses sanitize_term() Cleanses the term based on $filter context before returning.

 * @see sanitize_term_field() The $context param lists the available values for get_term_by() $filter param.

 *

 * @param string $field Either 'slug', 'name', or 'id'

 * @param string|int $value Search for this term value

 * @param string $taxonomy Taxonomy Name

 * @param string $output Constant OBJECT, ARRAY_A, or ARRAY_N

 * @param string $filter Optional, default is raw or no WordPress defined filter will applied.

 * @return mixed Term Row from database. Will return false if $taxonomy does not exist or $term was not found.

 */

function get_term_by($field, $value, $taxonomy, $output = OBJECT, $filter = 'raw') {

	global $wpdb;

	if ( ! is_taxonomy($taxonomy) )

		return false;

	if ( 'slug' == $field ) {

		$field = 't.slug';

		$value = sanitize_title($value);

		if ( empty($value) )

			return false;

	} else if ( 'name' == $field ) {

		// Assume already escaped

		$value = stripslashes($value);

		$field = 't.name';

	} else {

		$field = 't.term_id';

		$value = (int) $value;

	}

	$term = $wpdb->get_row( $wpdb->prepare( "SELECT t.*, tt.* FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id WHERE tt.taxonomy = %s AND $field = %s LIMIT 1", $taxonomy, $value) );

	if ( !$term )

		return false;

	wp_cache_add($term->term_id, $term, $taxonomy);

	$term = sanitize_term($term, $taxonomy, $filter);

	if ( $output == OBJECT ) {

		return $term;

	} elseif ( $output == ARRAY_A ) {

		return get_object_vars($term);

	} elseif ( $output == ARRAY_N ) {

		return array_values(get_object_vars($term));

	} else {

		return $term;

	}

}

/**

 * Merge all term children into a single array of their IDs.

 *

 * This recursive function will merge all of the children of $term into the same

 * array of term IDs. Only useful for taxonomies which are hierarchical.

 *

 * Will return an empty array if $term does not exist in $taxonomy.

 *

 * @package WordPress

 * @subpackage Taxonomy

 * @since 2.3.0

 *

 * @uses $wpdb

 * @uses _get_term_hierarchy()

 * @uses get_term_children() Used to get the children of both $taxonomy and the parent $term

 *

 * @param string $term ID of Term to get children

 * @param string $taxonomy Taxonomy Name

 * @return array|WP_Error List of Term Objects. WP_Error returned if $taxonomy does not exist

 */

function get_term_children( $term_id, $taxonomy ) {

	if ( ! is_taxonomy($taxonomy) )

		return new WP_Error('invalid_taxonomy', __('Invalid Taxonomy'));

	$term_id = intval( $term_id );