2007-09-15 13:35:32 -04:00
< ? php
2007-10-15 18:49:31 -04:00
/**
2008-08-30 17:23:43 -04:00
* Taxonomy API
*
2007-10-15 18:49:31 -04:00
* @ package WordPress
* @ subpackage Taxonomy
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-15 18:49:31 -04:00
*/
2007-09-15 13:35:32 -04:00
//
// Taxonomy Registration
//
/**
2012-01-23 14:58:26 -05:00
* Creates the initial taxonomies .
*
* This function fires twice : in wp - settings . php before plugins are loaded ( for
* backwards compatibility reasons ), and again on the 'init' action . We must avoid
* registering rewrite rules before the 'init' action .
2007-09-15 13:35:32 -04:00
*/
2009-04-16 19:17:49 -04:00
function create_initial_taxonomies () {
2011-03-09 00:18:45 -05:00
global $wp_rewrite ;
2012-01-23 14:58:26 -05:00
if ( ! did_action ( 'init' ) ) {
$rewrite = array ( 'category' => false , 'post_tag' => false , 'post_format' => false );
} else {
2014-03-28 17:29:13 -04:00
/**
* Filter the post formats rewrite base .
*
* @ since 3.1 . 0
*
* @ param string $context Context of the rewrite base . Default 'type' .
*/
2012-01-23 14:58:26 -05:00
$post_format_base = apply_filters ( 'post_format_rewrite_base' , 'type' );
$rewrite = array (
'category' => array (
'hierarchical' => true ,
'slug' => get_option ( 'category_base' ) ? get_option ( 'category_base' ) : 'category' ,
2012-01-23 15:10:01 -05:00
'with_front' => ! get_option ( 'category_base' ) || $wp_rewrite -> using_index_permalinks (),
2012-01-23 14:58:26 -05:00
'ep_mask' => EP_CATEGORIES ,
),
'post_tag' => array (
'slug' => get_option ( 'tag_base' ) ? get_option ( 'tag_base' ) : 'tag' ,
2012-01-23 15:10:01 -05:00
'with_front' => ! get_option ( 'tag_base' ) || $wp_rewrite -> using_index_permalinks (),
2012-01-23 14:58:26 -05:00
'ep_mask' => EP_TAGS ,
),
'post_format' => $post_format_base ? array ( 'slug' => $post_format_base ) : false ,
);
}
2010-05-04 02:13:28 -04:00
register_taxonomy ( 'category' , 'post' , array (
'hierarchical' => true ,
2010-10-06 07:04:03 -04:00
'query_var' => 'category_name' ,
2012-01-23 14:58:26 -05:00
'rewrite' => $rewrite [ 'category' ],
2010-05-04 02:13:28 -04:00
'public' => true ,
'show_ui' => true ,
2012-09-07 23:18:36 -04:00
'show_admin_column' => true ,
2010-05-04 02:13:28 -04:00
'_builtin' => true ,
2010-09-13 12:44:14 -04:00
) );
2010-01-26 06:32:04 -05:00
register_taxonomy ( 'post_tag' , 'post' , array (
2010-05-04 02:13:28 -04:00
'hierarchical' => false ,
2010-09-13 12:44:14 -04:00
'query_var' => 'tag' ,
2012-01-23 14:58:26 -05:00
'rewrite' => $rewrite [ 'post_tag' ],
2010-05-04 02:13:28 -04:00
'public' => true ,
'show_ui' => true ,
2012-09-07 23:18:36 -04:00
'show_admin_column' => true ,
2010-05-04 02:13:28 -04:00
'_builtin' => true ,
) );
2010-01-26 06:32:04 -05:00
2010-05-04 02:13:28 -04:00
register_taxonomy ( 'nav_menu' , 'nav_menu_item' , array (
2010-10-15 10:53:55 -04:00
'public' => false ,
2010-05-04 02:13:28 -04:00
'hierarchical' => false ,
2010-05-13 20:34:04 -04:00
'labels' => array (
'name' => __ ( 'Navigation Menus' ),
'singular_name' => __ ( 'Navigation Menu' ),
),
2010-05-04 02:13:28 -04:00
'query_var' => false ,
'rewrite' => false ,
'show_ui' => false ,
'_builtin' => true ,
2010-05-29 12:46:46 -04:00
'show_in_nav_menus' => false ,
2010-12-03 05:13:17 -05:00
) );
2010-02-20 16:57:43 -05:00
2010-05-04 02:13:28 -04:00
register_taxonomy ( 'link_category' , 'link' , array (
'hierarchical' => false ,
2010-05-13 20:34:04 -04:00
'labels' => array (
2010-08-11 17:54:51 -04:00
'name' => __ ( 'Link Categories' ),
'singular_name' => __ ( 'Link Category' ),
'search_items' => __ ( 'Search Link Categories' ),
'popular_items' => null ,
'all_items' => __ ( 'All Link Categories' ),
'edit_item' => __ ( 'Edit Link Category' ),
'update_item' => __ ( 'Update Link Category' ),
'add_new_item' => __ ( 'Add New Link Category' ),
'new_item_name' => __ ( 'New Link Category Name' ),
'separate_items_with_commas' => null ,
'add_or_remove_items' => null ,
'choose_from_most_used' => null ,
2010-05-13 20:34:04 -04:00
),
2012-08-13 12:18:42 -04:00
'capabilities' => array (
'manage_terms' => 'manage_links' ,
'edit_terms' => 'manage_links' ,
'delete_terms' => 'manage_links' ,
'assign_terms' => 'manage_links' ,
),
2010-05-04 02:13:28 -04:00
'query_var' => false ,
'rewrite' => false ,
'public' => false ,
'show_ui' => false ,
'_builtin' => true ,
2010-12-03 05:13:17 -05:00
) );
2010-11-12 05:58:58 -05:00
register_taxonomy ( 'post_format' , 'post' , array (
2010-12-03 05:13:17 -05:00
'public' => true ,
2010-10-12 14:33:14 -04:00
'hierarchical' => false ,
'labels' => array (
2011-01-31 07:18:57 -05:00
'name' => _x ( 'Format' , 'post format' ),
'singular_name' => _x ( 'Format' , 'post format' ),
2010-10-12 14:33:14 -04:00
),
2010-12-09 09:23:54 -05:00
'query_var' => true ,
2012-01-23 14:58:26 -05:00
'rewrite' => $rewrite [ 'post_format' ],
2010-10-12 14:33:14 -04:00
'show_ui' => false ,
'_builtin' => true ,
2012-02-08 12:12:02 -05:00
'show_in_nav_menus' => current_theme_supports ( 'post-formats' ),
2010-12-03 05:13:17 -05:00
) );
2009-04-16 19:17:49 -04:00
}
2009-04-29 12:40:36 -04:00
add_action ( 'init' , 'create_initial_taxonomies' , 0 ); // highest priority
2007-09-15 13:35:32 -04:00
2010-03-06 13:20:11 -05:00
/**
* Get a list of registered taxonomy objects .
*
* @ since 3.0 . 0
* @ uses $wp_taxonomies
* @ see register_taxonomy
*
2010-04-16 10:08:58 -04:00
* @ param array $args An array of key => value arguments to match against the taxonomy objects .
2010-03-06 13:20:11 -05:00
* @ param string $output The type of output to return , either taxonomy 'names' or 'objects' . 'names' is the default .
2010-05-03 16:26:11 -04:00
* @ param string $operator The logical operation to perform . 'or' means only one element
2010-04-16 10:08:58 -04:00
* from the array needs to match ; 'and' means all elements must match . The default is 'and' .
2010-03-06 13:20:11 -05:00
* @ return array A list of taxonomy names or objects
*/
2010-04-16 10:08:58 -04:00
function get_taxonomies ( $args = array (), $output = 'names' , $operator = 'and' ) {
2010-03-06 13:20:11 -05:00
global $wp_taxonomies ;
2010-04-16 10:08:58 -04:00
$field = ( 'names' == $output ) ? 'name' : false ;
2010-03-06 13:20:11 -05:00
2010-04-16 10:08:58 -04:00
return wp_filter_object_list ( $wp_taxonomies , $args , $operator , $field );
2010-03-06 13:20:11 -05:00
}
2007-09-15 13:35:32 -04:00
/**
2008-06-22 16:23:23 -04:00
* Return all of the taxonomy names that are of $object_type .
2007-09-15 13:35:32 -04:00
*
* It appears that this function can be used to find all of the names inside of
* $wp_taxonomies global variable .
*
2008-06-22 16:23:23 -04:00
* < code >< ? php $taxonomies = get_object_taxonomies ( 'post' ); ?> </code> Should
* result in < code > Array ( 'category' , 'post_tag' ) </ code >
2007-09-15 13:35:32 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2008-02-05 01:47:27 -05:00
*
2007-10-21 13:18:24 -04:00
* @ uses $wp_taxonomies
2007-09-15 13:35:32 -04:00
*
2008-03-26 02:37:19 -04:00
* @ param array | string | object $object Name of the type of taxonomy object , or an object ( row from posts )
2010-05-06 14:07:50 -04:00
* @ param string $output The type of output to return , either taxonomy 'names' or 'objects' . 'names' is the default .
2007-10-21 13:18:24 -04:00
* @ return array The names of all taxonomy of $object_type .
2007-09-15 13:35:32 -04:00
*/
2010-05-06 14:07:50 -04:00
function get_object_taxonomies ( $object , $output = 'names' ) {
2007-09-15 13:35:32 -04:00
global $wp_taxonomies ;
2008-03-26 02:37:19 -04:00
if ( is_object ( $object ) ) {
if ( $object -> post_type == 'attachment' )
return get_attachment_taxonomies ( $object );
$object = $object -> post_type ;
}
$object = ( array ) $object ;
2007-09-15 13:35:32 -04:00
$taxonomies = array ();
2010-05-06 14:07:50 -04:00
foreach ( ( array ) $wp_taxonomies as $tax_name => $tax_obj ) {
2010-05-06 14:16:39 -04:00
if ( array_intersect ( $object , ( array ) $tax_obj -> object_type ) ) {
if ( 'names' == $output )
$taxonomies [] = $tax_name ;
else
$taxonomies [ $tax_name ] = $tax_obj ;
}
2007-09-15 13:35:32 -04:00
}
return $taxonomies ;
}
/**
2008-06-22 16:23:23 -04:00
* Retrieves the taxonomy object of $taxonomy .
2007-09-15 13:35:32 -04:00
*
* The get_taxonomy function will first check that the parameter string given
* is a taxonomy object and if it is , it will return it .
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
*
* @ uses $wp_taxonomies
2010-06-11 11:53:41 -04:00
* @ uses taxonomy_exists () Checks whether taxonomy exists
2007-09-15 13:35:32 -04:00
*
2007-10-21 13:18:24 -04:00
* @ param string $taxonomy Name of taxonomy object to return
* @ return object | bool The Taxonomy Object or false if $taxonomy doesn ' t exist
2007-09-15 13:35:32 -04:00
*/
function get_taxonomy ( $taxonomy ) {
global $wp_taxonomies ;
2010-06-11 11:53:41 -04:00
if ( ! taxonomy_exists ( $taxonomy ) )
2007-09-15 13:35:32 -04:00
return false ;
return $wp_taxonomies [ $taxonomy ];
}
/**
2008-06-22 16:23:23 -04:00
* Checks that the taxonomy name exists .
2007-09-15 13:35:32 -04:00
*
2010-06-11 11:53:41 -04:00
* Formerly is_taxonomy (), introduced in 2.3 . 0.
*
* @ since 3.0 . 0
2008-02-05 01:47:27 -05:00
*
2007-10-21 13:18:24 -04:00
* @ uses $wp_taxonomies
*
2007-09-15 13:35:32 -04:00
* @ param string $taxonomy Name of taxonomy object
2010-02-24 15:13:23 -05:00
* @ return bool Whether the taxonomy exists .
2007-09-15 13:35:32 -04:00
*/
2010-06-11 11:53:41 -04:00
function taxonomy_exists ( $taxonomy ) {
2007-09-15 13:35:32 -04:00
global $wp_taxonomies ;
2010-03-17 12:27:25 -04:00
2010-06-11 11:53:41 -04:00
return isset ( $wp_taxonomies [ $taxonomy ] );
2007-09-15 13:35:32 -04:00
}
/**
2008-06-22 16:23:23 -04:00
* Whether the taxonomy object is hierarchical .
2007-09-15 13:35:32 -04:00
*
2008-06-22 16:23:23 -04:00
* Checks to make sure that the taxonomy is an object first . Then Gets the
* object , and finally returns the hierarchical value in the object .
2007-09-15 13:35:32 -04:00
*
2007-10-15 18:49:31 -04:00
* A false return value might also mean that the taxonomy does not exist .
2007-09-15 13:35:32 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
*
2010-06-11 11:53:41 -04:00
* @ uses taxonomy_exists () Checks whether taxonomy exists
2007-10-21 13:18:24 -04:00
* @ uses get_taxonomy () Used to get the taxonomy object
*
2007-09-15 13:35:32 -04:00
* @ param string $taxonomy Name of taxonomy object
* @ return bool Whether the taxonomy is hierarchical
*/
function is_taxonomy_hierarchical ( $taxonomy ) {
2010-06-11 11:53:41 -04:00
if ( ! taxonomy_exists ( $taxonomy ) )
2007-09-15 13:35:32 -04:00
return false ;
$taxonomy = get_taxonomy ( $taxonomy );
return $taxonomy -> hierarchical ;
}
/**
2008-06-22 16:23:23 -04:00
* Create or modify a taxonomy object . Do not use before init .
2007-09-15 13:35:32 -04:00
*
2008-06-22 16:23:23 -04:00
* 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 .
2007-09-15 13:35:32 -04:00
*
2010-06-11 11:53:41 -04:00
* Nothing is returned , so expect error maybe or use taxonomy_exists () to check
2008-06-22 16:23:23 -04:00
* whether taxonomy exists .
2007-09-15 13:35:32 -04:00
*
2007-10-21 13:18:24 -04:00
* Optional $args contents :
2010-05-25 22:42:15 -04:00
*
2013-08-26 16:24:08 -04:00
* - label - Name of the taxonomy shown in the menu . Usually plural . If not set , labels [ 'name' ] will be used .
* - labels - An array of labels for this taxonomy .
* * By default tag labels are used for non - hierarchical types and category labels for hierarchical ones .
* * You can see accepted values in { @ link get_taxonomy_labels ()} .
* - description - A short descriptive summary of what the taxonomy is for . Defaults to blank .
* - public - If the taxonomy should be publicly queryable ; //@TODO not implemented.
* * Defaults to true .
* - hierarchical - Whether the taxonomy is hierarchical ( e . g . category ) . Defaults to false .
* - show_ui - Whether to generate a default UI for managing this taxonomy in the admin .
* * If not set , the default is inherited from public .
2013-08-26 18:35:10 -04:00
* - show_in_menu - Where to show the taxonomy in the admin menu .
* * If true , the taxonomy is shown as a submenu of the object type menu .
* * If false , no menu is shown .
* * show_ui must be true .
* * If not set , the default is inherited from show_ui .
2013-08-26 16:24:08 -04:00
* - show_in_nav_menus - Makes this taxonomy available for selection in navigation menus .
* * If not set , the default is inherited from public .
* - show_tagcloud - Whether to list the taxonomy in the Tag Cloud Widget .
* * If not set , the default is inherited from show_ui .
2014-01-06 21:13:10 -05:00
* - show_admin_column - Whether to display a column for the taxonomy on its post type listing screens .
* * Defaults to false .
2013-10-27 12:29:09 -04:00
* - meta_box_cb - Provide a callback function for the meta box display .
* * If not set , defaults to post_categories_meta_box for hierarchical taxonomies
* and post_tags_meta_box for non - hierarchical .
* * If false , no meta box is shown .
2013-08-26 16:24:08 -04:00
* - capabilities - Array of capabilities for this taxonomy .
* * You can see accepted values in this function .
* - rewrite - Triggers the handling of rewrites for this taxonomy . Defaults to true , using $taxonomy as slug .
* * To prevent rewrite , set to false .
* * To specify rewrite rules , an array can be passed with any of these keys
* * 'slug' => string Customize the permastruct slug . Defaults to $taxonomy key
* * 'with_front' => bool Should the permastruct be prepended with WP_Rewrite :: $front . Defaults to true .
* * 'hierarchical' => bool Either hierarchical rewrite tag or not . Defaults to false .
* * 'ep_mask' => const Assign an endpoint mask .
* * If not specified , defaults to EP_NONE .
* - query_var - Sets the query_var key for this taxonomy . Defaults to $taxonomy key
* * If false , a taxonomy cannot be loaded at ? { query_var } = { term_slug }
* * If specified as a string , the query ? { query_var_string } = { term_slug } will be valid .
* - update_count_callback - Works much like a hook , in that it will be called when the count is updated .
* * Defaults to _update_post_term_count () for taxonomies attached to post types , which then confirms
* that the objects are published before counting them .
* * Defaults to _update_generic_term_count () for taxonomies attached to other object types , such as links .
* - _builtin - true if this taxonomy is a native or " built-in " taxonomy . THIS IS FOR INTERNAL USE ONLY !
2008-06-22 16:23:23 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
* @ uses $wp_taxonomies Inserts new taxonomy object into the list
2008-03-26 02:37:19 -04:00
* @ uses $wp Adds query vars
2008-02-05 01:47:27 -05:00
*
2013-08-26 16:24:08 -04:00
* @ param string $taxonomy Taxonomy key , must not exceed 32 characters .
2008-03-24 18:43:20 -04:00
* @ param array | string $object_type Name of the object type for the taxonomy object .
2013-08-26 16:24:08 -04:00
* @ param array | string $args See optional args description above .
2012-10-25 18:29:37 -04:00
* @ return null | WP_Error WP_Error if errors , otherwise null .
2007-09-15 13:35:32 -04:00
*/
function register_taxonomy ( $taxonomy , $object_type , $args = array () ) {
2012-02-28 15:29:33 -05:00
global $wp_taxonomies , $wp ;
2007-09-15 13:35:32 -04:00
2013-08-26 16:24:08 -04:00
if ( ! is_array ( $wp_taxonomies ) )
2009-04-29 12:40:36 -04:00
$wp_taxonomies = array ();
2013-03-03 21:48:20 -05:00
$defaults = array (
2013-08-26 16:24:08 -04:00
'labels' => array (),
'description' => '' ,
'public' => true ,
'hierarchical' => false ,
'show_ui' => null ,
2013-08-26 18:35:10 -04:00
'show_in_menu' => null ,
2013-08-26 16:24:08 -04:00
'show_in_nav_menus' => null ,
'show_tagcloud' => null ,
2014-01-06 21:13:10 -05:00
'show_admin_column' => false ,
2013-09-23 13:12:10 -04:00
'meta_box_cb' => null ,
2013-08-26 16:24:08 -04:00
'capabilities' => array (),
'rewrite' => true ,
'query_var' => $taxonomy ,
2013-03-03 21:48:20 -05:00
'update_count_callback' => '' ,
2013-08-26 16:24:08 -04:00
'_builtin' => false ,
2013-03-03 21:48:20 -05:00
);
2013-08-26 16:24:08 -04:00
$args = wp_parse_args ( $args , $defaults );
2007-09-15 13:35:32 -04:00
2012-11-17 10:11:29 -05:00
if ( strlen ( $taxonomy ) > 32 )
2012-10-25 18:12:02 -04:00
return new WP_Error ( 'taxonomy_too_long' , __ ( 'Taxonomies cannot exceed 32 characters in length' ) );
2013-08-26 16:24:08 -04:00
if ( false !== $args [ 'query_var' ] && ! empty ( $wp ) ) {
2008-05-15 22:35:24 -04:00
if ( true === $args [ 'query_var' ] )
2008-03-26 02:37:19 -04:00
$args [ 'query_var' ] = $taxonomy ;
2012-08-20 13:25:06 -04:00
else
2013-08-26 16:24:08 -04:00
$args [ 'query_var' ] = sanitize_title_with_dashes ( $args [ 'query_var' ] );
$wp -> add_query_var ( $args [ 'query_var' ] );
2008-03-26 02:37:19 -04:00
}
2013-08-26 16:24:08 -04:00
if ( false !== $args [ 'rewrite' ] && ( is_admin () || '' != get_option ( 'permalink_structure' ) ) ) {
2013-09-18 16:39:09 -04:00
$args [ 'rewrite' ] = wp_parse_args ( $args [ 'rewrite' ], array (
2010-03-17 12:27:25 -04:00
'with_front' => true ,
2012-01-23 14:12:04 -05:00
'hierarchical' => false ,
'ep_mask' => EP_NONE ,
2013-09-18 16:39:09 -04:00
) );
if ( empty ( $args [ 'rewrite' ][ 'slug' ] ) )
$args [ 'rewrite' ][ 'slug' ] = sanitize_title_with_dashes ( $taxonomy );
2010-10-17 00:36:26 -04:00
if ( $args [ 'hierarchical' ] && $args [ 'rewrite' ][ 'hierarchical' ] )
2010-10-17 01:41:22 -04:00
$tag = '(.+?)' ;
2010-10-04 06:37:25 -04:00
else
2010-10-17 00:36:26 -04:00
$tag = '([^/]+)' ;
2012-02-28 15:29:33 -05:00
add_rewrite_tag ( " % $taxonomy % " , $tag , $args [ 'query_var' ] ? " { $args [ 'query_var' ] } = " : " taxonomy= $taxonomy &term= " );
add_permastruct ( $taxonomy , " { $args [ 'rewrite' ][ 'slug' ] } /% $taxonomy % " , $args [ 'rewrite' ] );
2008-03-23 13:02:11 -04:00
}
2013-08-26 16:24:08 -04:00
// If not set, default to the setting for public.
if ( null === $args [ 'show_ui' ] )
2010-02-19 05:21:29 -05:00
$args [ 'show_ui' ] = $args [ 'public' ];
2013-08-26 18:35:10 -04:00
// If not set, default to the setting for show_ui.
if ( null === $args [ 'show_in_menu' ] || ! $args [ 'show_ui' ] )
$args [ 'show_in_menu' ] = $args [ 'show_ui' ];
2013-08-26 16:24:08 -04:00
// If not set, default to the setting for public.
2010-05-29 12:46:46 -04:00
if ( null === $args [ 'show_in_nav_menus' ] )
$args [ 'show_in_nav_menus' ] = $args [ 'public' ];
2013-08-26 16:24:08 -04:00
// If not set, default to the setting for show_ui.
if ( null === $args [ 'show_tagcloud' ] )
2010-02-20 21:55:07 -05:00
$args [ 'show_tagcloud' ] = $args [ 'show_ui' ];
2010-05-13 00:10:17 -04:00
$default_caps = array (
'manage_terms' => 'manage_categories' ,
'edit_terms' => 'manage_categories' ,
'delete_terms' => 'manage_categories' ,
'assign_terms' => 'edit_posts' ,
);
$args [ 'cap' ] = ( object ) array_merge ( $default_caps , $args [ 'capabilities' ] );
unset ( $args [ 'capabilities' ] );
2010-02-20 19:03:42 -05:00
2007-09-15 13:35:32 -04:00
$args [ 'name' ] = $taxonomy ;
2013-08-26 16:24:08 -04:00
$args [ 'object_type' ] = array_unique ( ( array ) $object_type );
2010-05-13 22:13:49 -04:00
2010-05-13 20:34:04 -04:00
$args [ 'labels' ] = get_taxonomy_labels ( ( object ) $args );
$args [ 'label' ] = $args [ 'labels' ] -> name ;
2010-05-25 22:42:15 -04:00
2013-09-23 13:12:10 -04:00
// If not set, use the default meta box
if ( null === $args [ 'meta_box_cb' ] ) {
if ( $args [ 'hierarchical' ] )
$args [ 'meta_box_cb' ] = 'post_categories_meta_box' ;
else
$args [ 'meta_box_cb' ] = 'post_tags_meta_box' ;
}
2013-08-26 16:24:08 -04:00
$wp_taxonomies [ $taxonomy ] = ( object ) $args ;
2010-04-02 13:07:30 -04:00
// register callback handling for metabox
2013-08-26 16:24:08 -04:00
add_filter ( 'wp_ajax_add-' . $taxonomy , '_wp_ajax_add_hierarchical_term' );
2011-09-30 05:53:35 -04:00
2014-03-28 17:29:13 -04:00
/**
* Fires after a taxonomy is registered .
*
* @ since 3.3 . 0
*
* @ param string $taxonomy Taxonomy slug .
* @ param array | string $object_type Object type or array of object types .
* @ param array | string $args Array or string of taxonomy registration arguments .
*/
2011-09-30 05:53:35 -04:00
do_action ( 'registered_taxonomy' , $taxonomy , $object_type , $args );
2007-09-15 13:35:32 -04:00
}
2010-05-13 20:34:04 -04:00
/**
* Builds an object with all taxonomy labels out of a taxonomy object
2010-05-25 22:42:15 -04:00
*
2010-05-13 20:34:04 -04:00
* Accepted keys of the label array in the taxonomy object :
2011-09-11 13:52:46 -04:00
* - name - general name for the taxonomy , usually plural . The same as and overridden by $tax -> label . Default is Tags / Categories
* - singular_name - name for one object of this taxonomy . Default is Tag / Category
2010-05-13 20:34:04 -04:00
* - search_items - Default is Search Tags / Search Categories
2010-06-04 15:21:06 -04:00
* - popular_items - This string isn ' t used on hierarchical taxonomies . Default is Popular Tags
2010-05-13 20:34:04 -04:00
* - all_items - Default is All Tags / All Categories
* - parent_item - This string isn ' t used on non - hierarchical taxonomies . In hierarchical ones the default is Parent Category
* - parent_item_colon - The same as < code > parent_item </ code > , but with colon < code >:</ code > in the end
* - edit_item - Default is Edit Tag / Edit Category
2012-04-11 16:08:30 -04:00
* - view_item - Default is View Tag / View Category
2010-05-13 20:34:04 -04:00
* - update_item - Default is Update Tag / Update Category
* - add_new_item - Default is Add New Tag / Add New Category
* - new_item_name - Default is New Tag Name / New Category Name
2012-04-11 16:08:30 -04:00
* - separate_items_with_commas - This string isn ' t used on hierarchical taxonomies . Default is " Separate tags with commas " , used in the meta box .
* - add_or_remove_items - This string isn ' t used on hierarchical taxonomies . Default is " Add or remove tags " , used in the meta box when JavaScript is disabled .
* - choose_from_most_used - This string isn ' t used on hierarchical taxonomies . Default is " Choose from the most used tags " , used in the meta box .
2013-02-25 14:39:38 -05:00
* - not_found - This string isn ' t used on hierarchical taxonomies . Default is " No tags found " , used in the meta box .
2010-05-25 22:42:15 -04:00
*
2012-04-11 16:08:30 -04:00
* Above , the first default value is for non - hierarchical taxonomies ( like tags ) and the second one is for hierarchical taxonomies ( like categories ) .
2010-05-25 22:42:15 -04:00
*
2010-05-13 20:34:04 -04:00
* @ since 3.0 . 0
* @ param object $tax Taxonomy object
* @ return object object with all the labels as member variables
*/
function get_taxonomy_labels ( $tax ) {
2013-09-21 13:44:09 -04:00
$tax -> labels = ( array ) $tax -> labels ;
2010-06-10 12:07:33 -04:00
if ( isset ( $tax -> helps ) && empty ( $tax -> labels [ 'separate_items_with_commas' ] ) )
$tax -> labels [ 'separate_items_with_commas' ] = $tax -> helps ;
2013-02-25 14:39:38 -05:00
if ( isset ( $tax -> no_tagcloud ) && empty ( $tax -> labels [ 'not_found' ] ) )
$tax -> labels [ 'not_found' ] = $tax -> no_tagcloud ;
2013-02-25 13:35:05 -05:00
2010-05-13 20:34:04 -04:00
$nohier_vs_hier_defaults = array (
2011-09-11 13:52:46 -04:00
'name' => array ( _x ( 'Tags' , 'taxonomy general name' ), _x ( 'Categories' , 'taxonomy general name' ) ),
'singular_name' => array ( _x ( 'Tag' , 'taxonomy singular name' ), _x ( 'Category' , 'taxonomy singular name' ) ),
2010-05-13 20:34:04 -04:00
'search_items' => array ( __ ( 'Search Tags' ), __ ( 'Search Categories' ) ),
2010-06-04 15:21:06 -04:00
'popular_items' => array ( __ ( 'Popular Tags' ), null ),
2010-05-13 20:34:04 -04:00
'all_items' => array ( __ ( 'All Tags' ), __ ( 'All Categories' ) ),
'parent_item' => array ( null , __ ( 'Parent Category' ) ),
'parent_item_colon' => array ( null , __ ( 'Parent Category:' ) ),
'edit_item' => array ( __ ( 'Edit Tag' ), __ ( 'Edit Category' ) ),
2011-06-08 12:49:27 -04:00
'view_item' => array ( __ ( 'View Tag' ), __ ( 'View Category' ) ),
2010-05-13 20:34:04 -04:00
'update_item' => array ( __ ( 'Update Tag' ), __ ( 'Update Category' ) ),
'add_new_item' => array ( __ ( 'Add New Tag' ), __ ( 'Add New Category' ) ),
'new_item_name' => array ( __ ( 'New Tag Name' ), __ ( 'New Category Name' ) ),
2010-06-10 12:07:33 -04:00
'separate_items_with_commas' => array ( __ ( 'Separate tags with commas' ), null ),
'add_or_remove_items' => array ( __ ( 'Add or remove tags' ), null ),
'choose_from_most_used' => array ( __ ( 'Choose from the most used tags' ), null ),
2013-02-25 14:39:38 -05:00
'not_found' => array ( __ ( 'No tags found.' ), null ),
2010-05-13 20:34:04 -04:00
);
2010-11-08 21:09:00 -05:00
$nohier_vs_hier_defaults [ 'menu_name' ] = $nohier_vs_hier_defaults [ 'name' ];
2010-05-13 20:34:04 -04:00
return _get_custom_object_labels ( $tax , $nohier_vs_hier_defaults );
}
2010-01-04 11:58:43 -05:00
/**
* Add an already registered taxonomy to an object type .
*
2010-03-26 15:13:36 -04:00
* @ since 3.0 . 0
2010-01-04 11:58:43 -05:00
* @ uses $wp_taxonomies Modifies taxonomy object
*
* @ param string $taxonomy Name of taxonomy object
2012-01-11 16:39:01 -05:00
* @ param string $object_type Name of the object type
2010-01-04 11:58:43 -05:00
* @ return bool True if successful , false if not
*/
function register_taxonomy_for_object_type ( $taxonomy , $object_type ) {
global $wp_taxonomies ;
if ( ! isset ( $wp_taxonomies [ $taxonomy ]) )
return false ;
if ( ! get_post_type_object ( $object_type ) )
return false ;
2011-04-23 05:27:37 -04:00
if ( ! in_array ( $object_type , $wp_taxonomies [ $taxonomy ] -> object_type ) )
$wp_taxonomies [ $taxonomy ] -> object_type [] = $object_type ;
2010-01-04 11:58:43 -05:00
return true ;
}
2013-09-23 22:54:08 -04:00
/**
* Remove an already registered taxonomy from an object type .
*
* @ since 3.7 . 0
*
* @ param string $taxonomy Name of taxonomy object .
* @ param string $object_type Name of the object type .
* @ return bool True if successful , false if not .
*/
function unregister_taxonomy_for_object_type ( $taxonomy , $object_type ) {
global $wp_taxonomies ;
if ( ! isset ( $wp_taxonomies [ $taxonomy ] ) )
return false ;
if ( ! get_post_type_object ( $object_type ) )
return false ;
$key = array_search ( $object_type , $wp_taxonomies [ $taxonomy ] -> object_type , true );
if ( false === $key )
return false ;
unset ( $wp_taxonomies [ $taxonomy ] -> object_type [ $key ] );
return true ;
}
2007-09-15 13:35:32 -04:00
//
// Term API
//
/**
2008-06-22 16:23:23 -04:00
* Retrieve object_ids of valid taxonomy and term .
2007-09-15 13:35:32 -04:00
*
2008-06-22 16:23:23 -04:00
* 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 .
2007-09-15 13:35:32 -04:00
*
2008-06-22 16:23:23 -04:00
* The $terms aren ' t checked the same as $taxonomies , but still need to exist
* for $object_ids to be returned .
2007-09-15 13:35:32 -04:00
*
2008-06-22 16:23:23 -04:00
* 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' .
2007-09-15 13:35:32 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
*
* @ uses $wpdb
* @ uses wp_parse_args () Creates an array from string $args .
2007-10-15 18:49:31 -04:00
*
2010-11-16 20:56:01 -05:00
* @ param int | array $term_ids Term id or array of term ids of terms that will be used
2007-09-15 13:35:32 -04:00
* @ param string | array $taxonomies String of taxonomy name or Array of string values of taxonomy names
2010-11-16 20:56:01 -05:00
* @ 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 .
2007-09-15 13:35:32 -04:00
*/
2010-11-16 20:56:01 -05:00
function get_objects_in_term ( $term_ids , $taxonomies , $args = array () ) {
2007-09-15 13:35:32 -04:00
global $wpdb ;
2010-11-16 20:56:01 -05:00
if ( ! is_array ( $term_ids ) )
$term_ids = array ( $term_ids );
2007-09-15 13:35:32 -04:00
2010-11-16 20:56:01 -05:00
if ( ! is_array ( $taxonomies ) )
$taxonomies = array ( $taxonomies );
2007-09-15 13:35:32 -04:00
2010-11-16 20:56:01 -05:00
foreach ( ( array ) $taxonomies as $taxonomy ) {
2010-06-11 11:53:41 -04:00
if ( ! taxonomy_exists ( $taxonomy ) )
2012-06-01 15:05:30 -04:00
return new WP_Error ( 'invalid_taxonomy' , __ ( 'Invalid taxonomy' ) );
2007-09-15 13:35:32 -04:00
}
2010-11-16 20:56:01 -05:00
$defaults = array ( 'order' => 'ASC' );
$args = wp_parse_args ( $args , $defaults );
extract ( $args , EXTR_SKIP );
2007-10-12 23:51:11 -04:00
2010-11-16 20:56:01 -05:00
$order = ( 'desc' == strtolower ( $order ) ) ? 'DESC' : 'ASC' ;
2007-09-15 13:35:32 -04:00
2010-11-16 20:56:01 -05:00
$term_ids = array_map ( 'intval' , $term_ids );
2010-10-06 08:06:23 -04:00
2016-03-30 13:38:15 -04:00
$taxonomies = " ' " . implode ( " ', ' " , array_map ( 'esc_sql' , $taxonomies ) ) . " ' " ;
2010-11-16 20:56:01 -05:00
$term_ids = " ' " . implode ( " ', ' " , $term_ids ) . " ' " ;
2007-09-15 13:35:32 -04:00
2010-11-16 20:56:01 -05:00
$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 ( $term_ids ) ORDER BY tr.object_id $order " );
2010-09-13 12:44:14 -04:00
2010-11-16 20:56:01 -05:00
if ( ! $object_ids )
return array ();
2010-09-13 12:44:14 -04:00
2010-11-16 20:56:01 -05:00
return $object_ids ;
2010-09-13 12:44:14 -04:00
}
2010-12-16 17:46:13 -05:00
/**
2010-12-10 03:20:46 -05:00
* Given a taxonomy query , generates SQL to be appended to a main query .
2010-11-09 18:30:35 -05:00
*
* @ since 3.1 . 0
*
2010-12-10 03:20:46 -05:00
* @ see WP_Tax_Query
2010-11-09 18:30:35 -05:00
*
2010-12-10 03:20:46 -05:00
* @ param array $tax_query A compact tax query
2010-11-16 20:56:01 -05:00
* @ param string $primary_table
* @ param string $primary_id_column
2010-11-21 09:09:01 -05:00
* @ return array
2010-11-09 18:30:35 -05:00
*/
2010-11-16 20:56:01 -05:00
function get_tax_sql ( $tax_query , $primary_table , $primary_id_column ) {
2010-12-09 14:29:21 -05:00
$tax_query_obj = new WP_Tax_Query ( $tax_query );
return $tax_query_obj -> get_sql ( $primary_table , $primary_id_column );
}
2010-11-23 15:22:27 -05:00
2010-12-10 03:20:46 -05:00
/**
* Container class for a multiple taxonomy query .
*
* @ since 3.1 . 0
*/
2010-12-09 14:29:21 -05:00
class WP_Tax_Query {
2010-12-10 03:20:46 -05:00
/**
* List of taxonomy queries . A single taxonomy query is an associative array :
* - 'taxonomy' string The taxonomy being queried
* - 'terms' string | array The list of terms
* - 'field' string ( optional ) Which term field is being used .
* Possible values : 'term_id' , 'slug' or 'name'
* Default : 'term_id'
* - 'operator' string ( optional )
2011-04-22 15:09:48 -04:00
* Possible values : 'AND' , 'IN' or 'NOT IN' .
2010-12-10 03:20:46 -05:00
* Default : 'IN'
* - 'include_children' bool ( optional ) Whether to include child terms .
* Default : true
*
* @ since 3.1 . 0
* @ access public
* @ var array
*/
2011-04-22 15:09:48 -04:00
public $queries = array ();
2010-12-09 12:05:40 -05:00
2010-12-10 03:20:46 -05:00
/**
* The relation between the queries . Can be one of 'AND' or 'OR' .
*
* @ since 3.1 . 0
* @ access public
* @ var string
*/
2011-04-22 15:09:48 -04:00
public $relation ;
2010-12-10 03:20:46 -05:00
/**
2011-04-22 15:09:48 -04:00
* Standard response when the query should not return any rows .
*
* @ since 3.2 . 0
* @ access private
* @ var string
*/
private static $no_results = array ( 'join' => '' , 'where' => ' AND 0 = 1' );
/**
* Constructor .
2010-12-10 03:20:46 -05:00
*
* Parses a compact tax query and sets defaults .
*
* @ since 3.1 . 0
* @ access public
*
* @ param array $tax_query A compact tax query :
* array (
* 'relation' => 'OR' ,
* array (
* 'taxonomy' => 'tax1' ,
* 'terms' => array ( 'term1' , 'term2' ),
* 'field' => 'slug' ,
* ),
* array (
* 'taxonomy' => 'tax2' ,
* 'terms' => array ( 'term-a' , 'term-b' ),
* 'field' => 'slug' ,
* ),
* )
*/
2011-04-22 15:09:48 -04:00
public function __construct ( $tax_query ) {
2010-12-09 14:29:21 -05:00
if ( isset ( $tax_query [ 'relation' ] ) && strtoupper ( $tax_query [ 'relation' ] ) == 'OR' ) {
$this -> relation = 'OR' ;
} else {
$this -> relation = 'AND' ;
}
2010-11-23 15:22:27 -05:00
2010-12-09 14:29:21 -05:00
$defaults = array (
'taxonomy' => '' ,
'terms' => array (),
'include_children' => true ,
'field' => 'term_id' ,
'operator' => 'IN' ,
);
2010-11-23 15:22:27 -05:00
2010-12-09 14:29:21 -05:00
foreach ( $tax_query as $query ) {
if ( ! is_array ( $query ) )
continue ;
2010-11-16 20:56:01 -05:00
2010-12-09 14:29:21 -05:00
$query = array_merge ( $defaults , $query );
2010-11-09 18:30:35 -05:00
2010-12-09 14:29:21 -05:00
$query [ 'terms' ] = ( array ) $query [ 'terms' ];
2010-12-13 16:21:50 -05:00
2010-12-09 14:29:21 -05:00
$this -> queries [] = $query ;
}
}
2010-11-09 18:30:35 -05:00
2010-12-10 03:20:46 -05:00
/**
* Generates SQL clauses to be appended to a main query .
*
* @ since 3.1 . 0
* @ access public
*
* @ param string $primary_table
* @ param string $primary_id_column
* @ return array
*/
2011-04-22 15:09:48 -04:00
public function get_sql ( $primary_table , $primary_id_column ) {
2010-12-09 14:29:21 -05:00
global $wpdb ;
2010-11-09 18:30:35 -05:00
2010-12-09 14:29:21 -05:00
$join = '' ;
$where = array ();
$i = 0 ;
2012-10-04 09:16:47 -04:00
$count = count ( $this -> queries );
2010-11-16 11:24:14 -05:00
2012-10-04 09:16:47 -04:00
foreach ( $this -> queries as $index => $query ) {
2011-04-22 15:09:48 -04:00
$this -> clean_query ( $query );
2010-11-23 15:22:27 -05:00
2012-10-04 09:16:47 -04:00
if ( is_wp_error ( $query ) )
2011-04-22 15:09:48 -04:00
return self :: $no_results ;
2010-11-16 20:56:01 -05:00
2011-04-22 15:09:48 -04:00
extract ( $query );
2010-12-09 14:29:21 -05:00
if ( 'IN' == $operator ) {
2010-11-23 15:22:27 -05:00
2010-12-09 14:29:21 -05:00
if ( empty ( $terms ) ) {
2012-10-04 09:16:47 -04:00
if ( 'OR' == $this -> relation ) {
if ( ( $index + 1 === $count ) && empty ( $where ) )
return self :: $no_results ;
2010-12-09 14:29:21 -05:00
continue ;
2012-10-04 09:16:47 -04:00
} else {
2011-04-22 15:09:48 -04:00
return self :: $no_results ;
2012-10-04 09:16:47 -04:00
}
2010-12-09 14:29:21 -05:00
}
2010-11-20 16:28:50 -05:00
2010-12-09 14:29:21 -05:00
$terms = implode ( ',' , $terms );
2010-11-20 16:28:50 -05:00
2010-12-09 14:29:21 -05:00
$alias = $i ? 'tt' . $i : $wpdb -> term_relationships ;
2010-11-23 15:22:27 -05:00
2010-12-09 14:29:21 -05:00
$join .= " INNER JOIN $wpdb->term_relationships " ;
$join .= $i ? " AS $alias " : '' ;
$join .= " ON ( $primary_table . $primary_id_column = $alias .object_id) " ;
2010-11-20 16:10:20 -05:00
2010-12-09 14:29:21 -05:00
$where [] = " $alias .term_taxonomy_id $operator ( $terms ) " ;
2011-01-09 11:19:48 -05:00
} elseif ( 'NOT IN' == $operator ) {
2010-11-23 15:22:27 -05:00
2010-12-09 14:29:21 -05:00
if ( empty ( $terms ) )
continue ;
2010-11-09 18:30:35 -05:00
2010-12-09 14:29:21 -05:00
$terms = implode ( ',' , $terms );
2010-12-09 12:05:40 -05:00
2010-12-09 14:29:21 -05:00
$where [] = " $primary_table . $primary_id_column NOT IN (
SELECT object_id
FROM $wpdb -> term_relationships
WHERE term_taxonomy_id IN ( $terms )
) " ;
2011-01-09 11:19:48 -05:00
} elseif ( 'AND' == $operator ) {
if ( empty ( $terms ) )
continue ;
$num_terms = count ( $terms );
$terms = implode ( ',' , $terms );
2011-04-18 16:38:59 -04:00
$where [] = " (
SELECT COUNT ( 1 )
2011-01-09 11:19:48 -05:00
FROM $wpdb -> term_relationships
WHERE term_taxonomy_id IN ( $terms )
2011-04-18 16:38:59 -04:00
AND object_id = $primary_table . $primary_id_column
) = $num_terms " ;
2010-12-09 14:29:21 -05:00
}
2010-12-09 12:05:40 -05:00
2010-12-09 14:29:21 -05:00
$i ++ ;
}
2010-12-09 12:05:40 -05:00
2012-10-04 09:16:47 -04:00
if ( ! empty ( $where ) )
2010-12-09 14:36:33 -05:00
$where = ' AND ( ' . implode ( " $this->relation " , $where ) . ' )' ;
2010-12-09 14:29:21 -05:00
else
$where = '' ;
2010-12-09 12:05:40 -05:00
2010-12-09 14:29:21 -05:00
return compact ( 'join' , 'where' );
2010-12-09 12:05:40 -05:00
}
2010-12-10 03:20:46 -05:00
/**
2011-04-22 15:09:48 -04:00
* Validates a single query .
2010-12-10 03:20:46 -05:00
*
2011-04-22 15:09:48 -04:00
* @ since 3.2 . 0
2010-12-10 03:20:46 -05:00
* @ access private
*
2011-04-22 15:09:48 -04:00
* @ param array & $query The single query
*/
private function clean_query ( & $query ) {
if ( ! taxonomy_exists ( $query [ 'taxonomy' ] ) ) {
$query = new WP_Error ( 'Invalid taxonomy' );
return ;
}
$query [ 'terms' ] = array_unique ( ( array ) $query [ 'terms' ] );
if ( is_taxonomy_hierarchical ( $query [ 'taxonomy' ] ) && $query [ 'include_children' ] ) {
$this -> transform_query ( $query , 'term_id' );
if ( is_wp_error ( $query ) )
return ;
$children = array ();
foreach ( $query [ 'terms' ] as $term ) {
$children = array_merge ( $children , get_term_children ( $term , $query [ 'taxonomy' ] ) );
$children [] = $term ;
}
$query [ 'terms' ] = $children ;
}
$this -> transform_query ( $query , 'term_taxonomy_id' );
}
/**
* Transforms a single query , from one field to another .
*
* @ since 3.2 . 0
*
* @ param array & $query The single query
2010-12-13 16:21:50 -05:00
* @ param string $resulting_field The resulting field
2010-12-10 03:20:46 -05:00
*/
2012-09-15 16:17:03 -04:00
public function transform_query ( & $query , $resulting_field ) {
2010-12-09 14:29:21 -05:00
global $wpdb ;
2010-11-16 20:56:01 -05:00
2011-04-22 15:09:48 -04:00
if ( empty ( $query [ 'terms' ] ) )
2010-12-09 14:29:21 -05:00
return ;
2011-04-22 15:09:48 -04:00
if ( $query [ 'field' ] == $resulting_field )
2010-12-09 14:29:21 -05:00
return ;
2013-07-16 10:21:05 -04:00
$resulting_field = sanitize_key ( $resulting_field );
2010-12-09 14:29:21 -05:00
2011-04-22 15:09:48 -04:00
switch ( $query [ 'field' ] ) {
2010-12-09 14:29:21 -05:00
case 'slug' :
case 'name' :
2011-04-22 15:09:48 -04:00
$terms = " ' " . implode ( " ',' " , array_map ( 'sanitize_title_for_query' , $query [ 'terms' ] ) ) . " ' " ;
2010-12-09 14:29:21 -05:00
$terms = $wpdb -> get_col ( "
SELECT $wpdb -> term_taxonomy . $resulting_field
FROM $wpdb -> term_taxonomy
INNER JOIN $wpdb -> terms USING ( term_id )
2011-04-22 15:09:48 -04:00
WHERE taxonomy = '{$query[' taxonomy ']}'
AND $wpdb -> terms . { $query [ 'field' ]} IN ( $terms )
2010-12-09 14:29:21 -05:00
" );
break ;
2012-08-20 12:49:21 -04:00
case 'term_taxonomy_id' :
$terms = implode ( ',' , array_map ( 'intval' , $query [ 'terms' ] ) );
$terms = $wpdb -> get_col ( "
SELECT $resulting_field
FROM $wpdb -> term_taxonomy
WHERE term_taxonomy_id IN ( $terms )
" );
break ;
2010-12-09 14:29:21 -05:00
default :
2011-04-22 15:09:48 -04:00
$terms = implode ( ',' , array_map ( 'intval' , $query [ 'terms' ] ) );
2010-12-09 14:29:21 -05:00
$terms = $wpdb -> get_col ( "
SELECT $resulting_field
FROM $wpdb -> term_taxonomy
2011-04-22 15:09:48 -04:00
WHERE taxonomy = '{$query[' taxonomy ']}'
2010-12-09 14:29:21 -05:00
AND term_id IN ( $terms )
" );
}
2011-04-22 15:09:48 -04:00
if ( 'AND' == $query [ 'operator' ] && count ( $terms ) < count ( $query [ 'terms' ] ) ) {
$query = new WP_Error ( 'Inexistent terms' );
return ;
}
$query [ 'terms' ] = $terms ;
$query [ 'field' ] = $resulting_field ;
2010-11-16 20:56:01 -05:00
}
}
2010-11-09 18:30:35 -05:00
2007-09-15 13:35:32 -04:00
/**
2008-06-22 16:23:23 -04:00
* Get all Term data from database by Term ID .
2007-10-15 18:49:31 -04:00
*
2008-06-22 16:23:23 -04:00
* 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
2007-10-21 13:18:24 -04:00
* filters .
2007-09-15 13:35:32 -04:00
*
2008-06-22 16:23:23 -04:00
* $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 .
2007-09-15 13:35:32 -04:00
*
2008-06-22 16:23:23 -04:00
* 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 .
2007-10-21 13:18:24 -04:00
*
2008-06-22 16:23:23 -04:00
* '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 .
2007-10-21 13:18:24 -04:00
*
2008-06-22 16:23:23 -04:00
* '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 .
2007-10-15 18:49:31 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
*
* @ uses $wpdb
2007-12-13 19:25:39 -05:00
* @ 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 .
2007-09-15 13:35:32 -04:00
*
2007-10-15 18:49:31 -04:00
* @ 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
2007-12-13 19:25:39 -05:00
* @ param string $filter Optional , default is raw or no WordPress defined filter will applied .
2007-10-21 13:18:24 -04:00
* @ 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 .
2007-09-15 13:35:32 -04:00
*/
2012-09-10 13:00:11 -04:00
function get_term ( $term , $taxonomy , $output = OBJECT , $filter = 'raw' ) {
2007-09-15 13:35:32 -04:00
global $wpdb ;
2008-08-14 13:00:37 -04:00
if ( empty ( $term ) ) {
$error = new WP_Error ( 'invalid_term' , __ ( 'Empty Term' ));
return $error ;
}
2007-09-15 13:35:32 -04:00
2010-06-11 11:53:41 -04:00
if ( ! taxonomy_exists ( $taxonomy ) ) {
2012-06-01 15:05:30 -04:00
$error = new WP_Error ( 'invalid_taxonomy' , __ ( 'Invalid taxonomy' ));
2008-08-14 13:00:37 -04:00
return $error ;
}
2007-09-15 13:35:32 -04:00
2008-11-17 15:03:31 -05:00
if ( is_object ( $term ) && empty ( $term -> filter ) ) {
2007-09-15 13:35:32 -04:00
wp_cache_add ( $term -> term_id , $term , $taxonomy );
$_term = $term ;
} else {
2008-11-17 15:03:31 -05:00
if ( is_object ( $term ) )
$term = $term -> term_id ;
2011-08-24 06:39:52 -04:00
if ( ! $term = ( int ) $term )
2014-01-29 01:46:12 -05:00
return null ;
2007-09-15 13:35:32 -04:00
if ( ! $_term = wp_cache_get ( $term , $taxonomy ) ) {
2011-08-24 06:39:52 -04:00
$_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 = %d LIMIT 1 " , $taxonomy , $term ) );
2009-11-17 15:51:32 -05:00
if ( ! $_term )
2014-01-29 01:46:12 -05:00
return null ;
2007-09-15 13:35:32 -04:00
wp_cache_add ( $term , $_term , $taxonomy );
}
}
2008-02-05 01:47:27 -05:00
2014-03-28 17:29:13 -04:00
/**
* Filter a term .
*
* @ since 2.3 . 0
*
* @ param int | object $_term Term object or ID .
* @ param string $taxonomy The taxonomy slug .
*/
$_term = apply_filters ( 'get_term' , $_term , $taxonomy );
/**
* Filter a taxonomy .
*
* The dynamic portion of the filter name , $taxonomy , refers
* to the taxonomy slug .
*
* @ since 2.3 . 0
*
* @ param int | object $_term Term object or ID .
* @ param string $taxonomy The taxonomy slug .
*/
$_term = apply_filters ( " get_ $taxonomy " , $_term , $taxonomy );
2007-09-15 13:35:32 -04:00
$_term = sanitize_term ( $_term , $taxonomy , $filter );
if ( $output == OBJECT ) {
return $_term ;
} elseif ( $output == ARRAY_A ) {
2008-11-02 18:52:49 -05:00
$__term = get_object_vars ( $_term );
return $__term ;
2007-09-15 13:35:32 -04:00
} elseif ( $output == ARRAY_N ) {
2008-11-02 18:52:49 -05:00
$__term = array_values ( get_object_vars ( $_term ));
return $__term ;
2007-09-15 13:35:32 -04:00
} else {
return $_term ;
}
}
/**
2008-06-22 16:23:23 -04:00
* Get all Term data from database by Term field and data .
2007-09-15 13:35:32 -04:00
*
2008-06-22 16:23:23 -04:00
* Warning : $value is not escaped for 'name' $field . You must do it yourself , if
* required .
2007-09-15 13:35:32 -04:00
*
2008-06-22 16:23:23 -04:00
* The default $field is 'id' , therefore it is possible to also use null for
* field , but not recommended that you do so .
2007-10-15 18:49:31 -04:00
*
2008-06-22 16:23:23 -04:00
* 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 .
2007-10-15 18:49:31 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
*
* @ uses $wpdb
2007-12-13 19:25:39 -05:00
* @ 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 .
2007-09-15 13:35:32 -04:00
*
2013-09-10 20:02:08 -04:00
* @ param string $field Either 'slug' , 'name' , 'id' ( term_id ), or 'term_taxonomy_id'
2007-10-15 18:49:31 -04:00
* @ param string | int $value Search for this term value
* @ param string $taxonomy Taxonomy Name
* @ param string $output Constant OBJECT , ARRAY_A , or ARRAY_N
2007-12-13 19:25:39 -05:00
* @ param string $filter Optional , default is raw or no WordPress defined filter will applied .
2007-10-21 13:18:24 -04:00
* @ return mixed Term Row from database . Will return false if $taxonomy does not exist or $term was not found .
2007-09-15 13:35:32 -04:00
*/
function get_term_by ( $field , $value , $taxonomy , $output = OBJECT , $filter = 'raw' ) {
global $wpdb ;
2010-06-11 11:53:41 -04:00
if ( ! taxonomy_exists ( $taxonomy ) )
2007-09-15 13:35:32 -04:00
return false ;
if ( 'slug' == $field ) {
$field = 't.slug' ;
2011-01-24 01:26:38 -05:00
$value = sanitize_title ( $value );
2007-09-15 13:35:32 -04:00
if ( empty ( $value ) )
return false ;
} else if ( 'name' == $field ) {
2013-03-01 11:28:40 -05:00
// Assume already escaped
2013-03-03 16:11:40 -05:00
$value = wp_unslash ( $value );
2007-09-15 13:35:32 -04:00
$field = 't.name' ;
2013-09-10 20:02:08 -04:00
} else if ( 'term_taxonomy_id' == $field ) {
$value = ( int ) $value ;
$field = 'tt.term_taxonomy_id' ;
2007-09-15 13:35:32 -04:00
} else {
2011-03-22 16:06:38 -04:00
$term = get_term ( ( int ) $value , $taxonomy , $output , $filter );
if ( is_wp_error ( $term ) )
$term = false ;
return $term ;
2007-09-15 13:35:32 -04:00
}
2007-10-12 23:51:11 -04:00
$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 ) );
2007-09-15 13:35:32 -04:00
if ( ! $term )
return false ;
wp_cache_add ( $term -> term_id , $term , $taxonomy );
2014-03-28 17:29:13 -04:00
/** This filter is documented in wp-includes/taxonomy.php */
$term = apply_filters ( 'get_term' , $term , $taxonomy );
/** This filter is documented in wp-includes/taxonomy.php */
$term = apply_filters ( " get_ $taxonomy " , $term , $taxonomy );
2007-09-15 13:35:32 -04:00
$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 ;
}
}
/**
2009-04-28 15:49:21 -04:00
* Merge all term children into a single array of their IDs .
2007-09-15 13:35:32 -04:00
*
2008-06-22 16:23:23 -04:00
* This recursive function will merge all of the children of $term into the same
2009-04-28 15:49:21 -04:00
* array of term IDs . Only useful for taxonomies which are hierarchical .
2007-09-15 13:35:32 -04:00
*
2007-10-21 13:18:24 -04:00
* Will return an empty array if $term does not exist in $taxonomy .
2008-02-05 01:47:27 -05:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
*
* @ uses $wpdb
* @ uses _get_term_hierarchy ()
* @ uses get_term_children () Used to get the children of both $taxonomy and the parent $term
2007-10-15 18:49:31 -04:00
*
2010-09-07 07:21:11 -04:00
* @ param string $term_id ID of Term to get children
2007-09-15 13:35:32 -04:00
* @ param string $taxonomy Taxonomy Name
2014-03-07 14:16:15 -05:00
* @ return array | WP_Error List of Term IDs . WP_Error returned if $taxonomy does not exist
2007-09-15 13:35:32 -04:00
*/
2009-04-28 15:49:21 -04:00
function get_term_children ( $term_id , $taxonomy ) {
2010-06-11 11:53:41 -04:00
if ( ! taxonomy_exists ( $taxonomy ) )
2012-06-01 15:05:30 -04:00
return new WP_Error ( 'invalid_taxonomy' , __ ( 'Invalid taxonomy' ));
2007-09-15 13:35:32 -04:00
2009-04-28 15:49:21 -04:00
$term_id = intval ( $term_id );
2007-09-15 13:35:32 -04:00
$terms = _get_term_hierarchy ( $taxonomy );
2009-04-28 15:49:21 -04:00
if ( ! isset ( $terms [ $term_id ]) )
2007-09-15 13:35:32 -04:00
return array ();
2009-04-28 15:49:21 -04:00
$children = $terms [ $term_id ];
2007-09-15 13:35:32 -04:00
2009-04-28 15:49:21 -04:00
foreach ( ( array ) $terms [ $term_id ] as $child ) {
2014-03-29 02:08:15 -04:00
if ( $term_id == $child ) {
continue ;
}
2007-09-15 13:35:32 -04:00
if ( isset ( $terms [ $child ]) )
$children = array_merge ( $children , get_term_children ( $child , $taxonomy ));
}
return $children ;
}
/**
2008-06-22 16:23:23 -04:00
* Get sanitized Term field .
2008-02-05 01:47:27 -05:00
*
2008-06-22 16:23:23 -04:00
* Does checks for $term , based on the $taxonomy . The function is for contextual
* reasons and for simplicity of usage . See sanitize_term_field () for more
* information .
2007-09-15 13:35:32 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
*
* @ uses sanitize_term_field () Passes the return value in sanitize_term_field on success .
2007-10-15 18:49:31 -04:00
*
2007-09-15 13:35:32 -04:00
* @ param string $field Term field to fetch
* @ param int $term Term ID
* @ param string $taxonomy Taxonomy Name
2007-12-13 19:25:39 -05:00
* @ param string $context Optional , default is display . Look at sanitize_term_field () for available options .
2007-10-21 13:18:24 -04:00
* @ return mixed Will return an empty string if $term is not an object or if $field is not set in $term .
2007-09-15 13:35:32 -04:00
*/
function get_term_field ( $field , $term , $taxonomy , $context = 'display' ) {
$term = ( int ) $term ;
$term = get_term ( $term , $taxonomy );
if ( is_wp_error ( $term ) )
return $term ;
if ( ! is_object ( $term ) )
return '' ;
if ( ! isset ( $term -> $field ) )
return '' ;
return sanitize_term_field ( $field , $term -> $field , $term -> term_id , $taxonomy , $context );
}
/**
2008-06-22 16:23:23 -04:00
* Sanitizes Term for editing .
2007-09-15 13:35:32 -04:00
*
2008-06-22 16:23:23 -04:00
* Return value is sanitize_term () and usage is for sanitizing the term for
* editing . Function is for contextual and simplicity .
2008-02-05 01:47:27 -05:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
*
* @ uses sanitize_term () Passes the return value on success
2007-10-15 18:49:31 -04:00
*
2007-09-15 13:35:32 -04:00
* @ param int | object $id Term ID or Object
* @ param string $taxonomy Taxonomy Name
2007-10-21 13:18:24 -04:00
* @ return mixed | null | WP_Error Will return empty string if $term is not an object .
2007-09-15 13:35:32 -04:00
*/
function get_term_to_edit ( $id , $taxonomy ) {
$term = get_term ( $id , $taxonomy );
if ( is_wp_error ( $term ) )
return $term ;
if ( ! is_object ( $term ) )
return '' ;
return sanitize_term ( $term , $taxonomy , 'edit' );
}
/**
2008-11-12 19:20:12 -05:00
* Retrieve the terms in a given taxonomy or list of taxonomies .
2007-10-21 13:18:24 -04:00
*
2008-06-22 16:23:23 -04:00
* You can fully inject any customizations to the query before it is sent , as
* well as control the output with a filter .
2007-10-21 13:18:24 -04:00
*
2008-06-22 16:23:23 -04:00
* The 'get_terms' filter will be called when the cache has the term and will
* pass the found term along with the array of $taxonomies and array of $args .
* This filter is also called before the array of terms is passed and will pass
* the array of terms , along with the $taxonomies and $args .
2007-10-21 13:18:24 -04:00
*
2008-06-22 16:23:23 -04:00
* The 'list_terms_exclusions' filter passes the compiled exclusions along with
* the $args .
2007-10-21 13:18:24 -04:00
*
2009-05-24 19:47:49 -04:00
* The 'get_terms_orderby' filter passes the ORDER BY clause for the query
2009-04-21 18:13:44 -04:00
* along with the $args array .
2010-05-26 01:11:46 -04:00
*
2009-04-21 18:13:44 -04:00
* The 'get_terms_fields' filter passes the fields for the SELECT query
* along with the $args array .
*
2008-11-12 19:20:12 -05:00
* The list of arguments that $args can contain , which will overwrite the defaults :
2008-06-22 16:23:23 -04:00
*
2009-05-24 19:47:49 -04:00
* orderby - Default is 'name' . Can be name , count , term_group , slug or nothing
2009-05-10 03:57:07 -04:00
* ( will use term_id ), Passing a custom value other than these will cause it to
* order based on the custom value .
2009-05-24 19:47:49 -04:00
*
2007-10-21 13:18:24 -04:00
* order - Default is ASC . Can use DESC .
*
2008-11-12 19:20:12 -05:00
* hide_empty - Default is true . Will not return empty terms , which means
* terms whose count is 0 according to the given taxonomy .
2008-12-09 13:03:31 -05:00
*
2011-12-13 18:45:31 -05:00
* exclude - Default is an empty array . An array , comma - or space - delimited string
* of term ids to exclude from the return array . If 'include' is non - empty ,
2008-11-12 19:20:12 -05:00
* 'exclude' is ignored .
*
2011-12-13 18:45:31 -05:00
* exclude_tree - Default is an empty array . An array , comma - or space - delimited
2010-01-15 17:11:12 -05:00
* string of term ids to exclude from the return array , along with all of their
2011-12-13 18:45:31 -05:00
* descendant terms according to the primary taxonomy . If 'include' is non - empty ,
2010-01-08 03:44:45 -05:00
* 'exclude_tree' is ignored .
2008-12-30 17:30:36 -05:00
*
2011-12-13 18:45:31 -05:00
* include - Default is an empty array . An array , comma - or space - delimited string
2008-11-12 19:20:12 -05:00
* of term ids to include in the return array .
2008-12-09 13:03:31 -05:00
*
2011-12-13 18:45:31 -05:00
* number - The maximum number of terms to return . Default is to return them all .
2008-12-09 13:03:31 -05:00
*
2008-11-12 19:20:12 -05:00
* offset - The number by which to offset the terms query .
*
2008-12-09 13:03:31 -05:00
* fields - Default is 'all' , which returns an array of term objects .
2008-11-12 19:20:12 -05:00
* If 'fields' is 'ids' or 'names' , returns an array of
* integers or strings , respectively .
*
* slug - Returns terms whose " slug " matches this value . Default is empty string .
2008-12-09 13:03:31 -05:00
*
2008-11-12 19:20:12 -05:00
* hierarchical - Whether to include terms that have non - empty descendants
* ( even if 'hide_empty' is set to true ) .
2008-12-09 13:03:31 -05:00
*
2008-11-12 19:20:12 -05:00
* search - Returned terms ' names will contain the value of ' search ' ,
2011-12-13 18:45:31 -05:00
* case - insensitive . Default is an empty string .
2008-11-12 19:20:12 -05:00
*
2013-09-04 15:41:08 -04:00
* name__like - Returned terms ' names will contain the value of ' name__like ' ,
2008-11-12 19:20:12 -05:00
* case - insensitive . Default is empty string .
*
2013-09-04 15:41:08 -04:00
* description__like - Returned terms ' descriptions will contain the value of
* 'description__like' , case - insensitive . Default is empty string .
*
2008-11-12 19:20:12 -05:00
* The argument 'pad_counts' , if set to true will include the quantity of a term ' s
* children in the quantity of each term ' s " count " object variable .
*
* The 'get' argument , if set to 'all' instead of its default empty string ,
* returns terms regardless of ancestry or whether the terms are empty .
*
2011-12-13 18:45:31 -05:00
* The 'child_of' argument , when used , should be set to the integer of a term ID . Its default
* is 0. If set to a non - zero value , all returned terms will be descendants
* of that term according to the given taxonomy . Hence 'child_of' is set to 0
2008-12-09 13:03:31 -05:00
* if more than one taxonomy is passed in $taxonomies , because multiple taxonomies
2008-11-12 19:20:12 -05:00
* make term ancestry ambiguous .
*
2011-12-13 18:45:31 -05:00
* The 'parent' argument , when used , should be set to the integer of a term ID . Its default is
2008-11-12 19:20:12 -05:00
* the empty string '' , which has a different meaning from the integer 0.
2008-12-09 13:03:31 -05:00
* If set to an integer value , all returned terms will have as an immediate
2008-11-12 19:20:12 -05:00
* ancestor the term whose ID is specified by that integer according to the given taxonomy .
* The 'parent' argument is different from 'child_of' in that a term X is considered a 'parent'
* of term Y only if term X is the father of term Y , not its grandfather or great - grandfather , etc .
2007-09-15 13:35:32 -04:00
*
2011-06-03 11:24:14 -04:00
* The 'cache_domain' argument enables a unique cache key to be produced when this query is stored
2011-06-10 19:01:45 -04:00
* in object cache . For instance , if you are using one of this function ' s filters to modify the
2011-06-03 11:24:14 -04:00
* query ( such as 'terms_clauses' ), setting 'cache_domain' to a unique value will not overwrite
* the cache for similar queries . Default value is 'core' .
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-15 18:49:31 -04:00
*
2007-10-21 13:18:24 -04:00
* @ uses $wpdb
* @ uses wp_parse_args () Merges the defaults with those defined by $args and allows for strings .
2007-09-15 13:35:32 -04:00
*
2010-09-07 07:21:11 -04:00
* @ param string | array $taxonomies Taxonomy name or list of Taxonomy names
2007-10-21 13:18:24 -04:00
* @ param string | array $args The values of what to search for when returning terms
* @ return array | WP_Error List of Term Objects and their children . Will return WP_Error , if any of $taxonomies do not exist .
2007-09-15 13:35:32 -04:00
*/
2012-09-10 13:00:11 -04:00
function get_terms ( $taxonomies , $args = '' ) {
2007-09-15 13:35:32 -04:00
global $wpdb ;
2008-01-10 15:51:07 -05:00
$empty_array = array ();
2007-09-15 13:35:32 -04:00
2012-11-07 04:03:40 -05:00
$single_taxonomy = ! is_array ( $taxonomies ) || 1 === count ( $taxonomies );
if ( ! is_array ( $taxonomies ) )
$taxonomies = array ( $taxonomies );
2007-09-15 13:35:32 -04:00
2010-10-28 15:09:18 -04:00
foreach ( $taxonomies as $taxonomy ) {
2010-06-11 11:53:41 -04:00
if ( ! taxonomy_exists ( $taxonomy ) ) {
2012-06-01 15:05:30 -04:00
$error = new WP_Error ( 'invalid_taxonomy' , __ ( 'Invalid taxonomy' ));
2009-05-06 01:03:59 -04:00
return $error ;
}
2007-09-15 13:35:32 -04:00
}
$defaults = array ( 'orderby' => 'name' , 'order' => 'ASC' ,
2010-01-08 03:44:45 -05:00
'hide_empty' => true , 'exclude' => array (), 'exclude_tree' => array (), 'include' => array (),
2007-09-15 13:35:32 -04:00
'number' => '' , 'fields' => 'all' , 'slug' => '' , 'parent' => '' ,
2013-09-04 15:41:08 -04:00
'hierarchical' => true , 'child_of' => 0 , 'get' => '' , 'name__like' => '' , 'description__like' => '' ,
2011-06-03 11:24:14 -04:00
'pad_counts' => false , 'offset' => '' , 'search' => '' , 'cache_domain' => 'core' );
2007-09-15 13:35:32 -04:00
$args = wp_parse_args ( $args , $defaults );
2007-10-12 23:51:11 -04:00
$args [ 'number' ] = absint ( $args [ 'number' ] );
2008-01-25 14:29:01 -05:00
$args [ 'offset' ] = absint ( $args [ 'offset' ] );
2013-09-12 01:09:09 -04:00
if ( ! $single_taxonomy || ! is_taxonomy_hierarchical ( reset ( $taxonomies ) ) ||
2014-02-06 12:45:12 -05:00
( '' !== $args [ 'parent' ] && 0 !== $args [ 'parent' ] ) ) {
2007-09-15 13:35:32 -04:00
$args [ 'child_of' ] = 0 ;
$args [ 'hierarchical' ] = false ;
$args [ 'pad_counts' ] = false ;
}
if ( 'all' == $args [ 'get' ] ) {
$args [ 'child_of' ] = 0 ;
$args [ 'hide_empty' ] = 0 ;
$args [ 'hierarchical' ] = false ;
$args [ 'pad_counts' ] = false ;
}
2010-10-28 13:55:30 -04:00
2014-03-28 17:29:13 -04:00
/**
* Filter the terms query arguments .
*
* @ since 3.1 . 0
*
* @ param array $args An array of arguments .
* @ param string | array $taxonomies A taxonomy or array of taxonomies .
*/
2010-10-28 15:09:18 -04:00
$args = apply_filters ( 'get_terms_args' , $args , $taxonomies );
2007-09-15 13:35:32 -04:00
extract ( $args , EXTR_SKIP );
if ( $child_of ) {
2013-08-23 17:29:10 -04:00
$hierarchy = _get_term_hierarchy ( reset ( $taxonomies ) );
if ( ! isset ( $hierarchy [ $child_of ] ) )
2008-01-10 15:51:07 -05:00
return $empty_array ;
2007-09-15 13:35:32 -04:00
}
if ( $parent ) {
2013-08-23 17:29:10 -04:00
$hierarchy = _get_term_hierarchy ( reset ( $taxonomies ) );
if ( ! isset ( $hierarchy [ $parent ] ) )
2008-01-10 15:51:07 -05:00
return $empty_array ;
2007-09-15 13:35:32 -04:00
}
2008-04-18 13:42:13 -04:00
// $args can be whatever, only use the args defined in defaults to compute the key
2008-07-01 11:54:58 -04:00
$filter_key = ( has_filter ( 'list_terms_exclusions' ) ) ? serialize ( $GLOBALS [ 'wp_filter' ][ 'list_terms_exclusions' ]) : '' ;
$key = md5 ( serialize ( compact ( array_keys ( $defaults )) ) . serialize ( $taxonomies ) . $filter_key );
2013-02-04 08:48:46 -05:00
$last_changed = wp_cache_get ( 'last_changed' , 'terms' );
if ( ! $last_changed ) {
2014-02-26 17:05:13 -05:00
$last_changed = microtime ();
2013-02-04 08:48:46 -05:00
wp_cache_set ( 'last_changed' , $last_changed , 'terms' );
2008-10-08 18:50:46 -04:00
}
$cache_key = " get_terms: $key : $last_changed " ;
2009-04-30 12:51:45 -04:00
$cache = wp_cache_get ( $cache_key , 'terms' );
if ( false !== $cache ) {
2014-03-28 17:29:13 -04:00
/**
* Filter the given taxonomy ' s terms cache .
*
* @ since 2.3 . 0
*
* @ param array $cache Cached array of terms for the given taxonomy .
* @ param string | array $taxonomies A taxonomy or array of taxonomies .
* @ param array $args An array of arguments to get terms .
*/
$cache = apply_filters ( 'get_terms' , $cache , $taxonomies , $args );
2009-04-30 12:51:45 -04:00
return $cache ;
2007-09-15 13:35:32 -04:00
}
2009-05-22 08:29:32 -04:00
$_orderby = strtolower ( $orderby );
if ( 'count' == $_orderby )
2007-09-15 13:35:32 -04:00
$orderby = 'tt.count' ;
2009-05-22 08:29:32 -04:00
else if ( 'name' == $_orderby )
2007-09-15 13:35:32 -04:00
$orderby = 't.name' ;
2009-05-22 08:29:32 -04:00
else if ( 'slug' == $_orderby )
2007-10-23 12:39:03 -04:00
$orderby = 't.slug' ;
2009-05-22 08:29:32 -04:00
else if ( 'term_group' == $_orderby )
2007-10-23 12:39:03 -04:00
$orderby = 't.term_group' ;
2010-05-11 12:50:25 -04:00
else if ( 'none' == $_orderby )
$orderby = '' ;
2009-05-24 19:47:49 -04:00
elseif ( empty ( $_orderby ) || 'id' == $_orderby )
2007-09-15 13:35:32 -04:00
$orderby = 't.term_id' ;
2011-06-27 11:45:12 -04:00
else
$orderby = 't.name' ;
2009-05-22 08:29:32 -04:00
2014-03-28 17:29:13 -04:00
/**
* Filter the ORDERBY clause of the terms query .
*
* @ since 2.8 . 0
*
* @ param string $orderby ORDERBY clause of the terms query .
* @ param array $args An array of terms query arguments .
* @ param string | array $taxonomies A taxonomy or array of taxonomies .
*/
2013-08-27 17:06:09 -04:00
$orderby = apply_filters ( 'get_terms_orderby' , $orderby , $args , $taxonomies );
2007-09-15 13:35:32 -04:00
2010-05-11 12:50:25 -04:00
if ( ! empty ( $orderby ) )
$orderby = " ORDER BY $orderby " ;
else
$order = '' ;
2011-06-27 11:45:12 -04:00
$order = strtoupper ( $order );
if ( '' !== $order && ! in_array ( $order , array ( 'ASC' , 'DESC' ) ) )
$order = 'ASC' ;
2016-03-30 13:38:15 -04:00
$where = " tt.taxonomy IN (' " . implode ( " ', ' " , array_map ( 'esc_sql' , $taxonomies ) ) . " ') " ;
2007-09-15 13:35:32 -04:00
$inclusions = '' ;
2013-08-29 12:24:09 -04:00
if ( ! empty ( $include ) ) {
2007-09-15 13:35:32 -04:00
$exclude = '' ;
2008-12-30 17:30:36 -05:00
$exclude_tree = '' ;
2013-08-29 14:54:09 -04:00
$inclusions = implode ( ',' , wp_parse_id_list ( $include ) );
2007-09-15 13:35:32 -04:00
}
2013-09-05 13:15:09 -04:00
if ( ! empty ( $inclusions ) ) {
2013-08-29 12:24:09 -04:00
$inclusions = ' AND t.term_id IN ( ' . $inclusions . ' )' ;
2013-09-05 13:15:09 -04:00
$where .= $inclusions ;
}
2007-09-15 13:35:32 -04:00
$exclusions = '' ;
2013-08-23 17:29:10 -04:00
if ( ! empty ( $exclude_tree ) ) {
2013-08-29 12:24:09 -04:00
$exclude_tree = wp_parse_id_list ( $exclude_tree );
2013-10-26 11:04:11 -04:00
$excluded_children = $exclude_tree ;
2013-08-29 12:24:09 -04:00
foreach ( $exclude_tree as $extrunk ) {
$excluded_children = array_merge (
$excluded_children ,
( array ) get_terms ( $taxonomies [ 0 ], array ( 'child_of' => intval ( $extrunk ), 'fields' => 'ids' , 'hide_empty' => 0 ) )
);
2008-12-30 17:30:36 -05:00
}
2013-08-29 12:24:09 -04:00
$exclusions = implode ( ',' , array_map ( 'intval' , $excluded_children ) );
2008-12-30 17:30:36 -05:00
}
2010-01-08 03:44:45 -05:00
2013-08-29 12:24:09 -04:00
if ( ! empty ( $exclude ) ) {
2013-08-29 14:54:09 -04:00
$exterms = wp_parse_id_list ( $exclude );
2013-08-29 12:24:09 -04:00
if ( empty ( $exclusions ) )
$exclusions = implode ( ',' , $exterms );
else
$exclusions .= ', ' . implode ( ',' , $exterms );
2007-09-15 13:35:32 -04:00
}
2013-08-29 12:24:09 -04:00
if ( ! empty ( $exclusions ) )
$exclusions = ' AND t.term_id NOT IN (' . $exclusions . ')' ;
2014-03-28 17:29:13 -04:00
/**
* Filter the terms to exclude from the terms query .
*
* @ since 2.3 . 0
*
* @ param string $exclusions NOT IN clause of the terms query .
* @ param array $args An array of terms query arguments .
* @ param string | array $taxonomies A taxonomy or array of taxonomies .
*/
2013-09-23 14:39:09 -04:00
$exclusions = apply_filters ( 'list_terms_exclusions' , $exclusions , $args , $taxonomies );
2013-09-05 13:15:09 -04:00
if ( ! empty ( $exclusions ) )
$where .= $exclusions ;
2007-09-15 13:35:32 -04:00
if ( ! empty ( $slug ) ) {
$slug = sanitize_title ( $slug );
$where .= " AND t.slug = ' $slug ' " ;
}
2011-05-22 19:22:59 -04:00
if ( ! empty ( $name__like ) ) {
$name__like = like_escape ( $name__like );
2013-09-04 15:41:08 -04:00
$where .= $wpdb -> prepare ( " AND t.name LIKE %s " , '%' . $name__like . '%' );
}
if ( ! empty ( $description__like ) ) {
$description__like = like_escape ( $description__like );
$where .= $wpdb -> prepare ( " AND tt.description LIKE %s " , '%' . $description__like . '%' );
2011-05-22 19:22:59 -04:00
}
2007-09-15 13:35:32 -04:00
2009-05-28 14:06:08 -04:00
if ( '' !== $parent ) {
2007-09-15 13:35:32 -04:00
$parent = ( int ) $parent ;
$where .= " AND tt.parent = ' $parent ' " ;
}
2013-09-21 12:48:10 -04:00
if ( 'count' == $fields )
$hierarchical = false ;
2007-09-15 13:35:32 -04:00
if ( $hide_empty && ! $hierarchical )
$where .= ' AND tt.count > 0' ;
2009-03-17 22:43:45 -04:00
// don't limit the query results when we have to descend the family tree
2013-03-03 21:52:43 -05:00
if ( $number && ! $hierarchical && ! $child_of && '' === $parent ) {
2010-01-24 06:00:27 -05:00
if ( $offset )
2010-10-28 13:55:30 -04:00
$limits = 'LIMIT ' . $offset . ',' . $number ;
2008-02-05 01:47:27 -05:00
else
2010-10-28 13:55:30 -04:00
$limits = 'LIMIT ' . $number ;
2010-01-24 06:00:27 -05:00
} else {
2010-10-28 13:55:30 -04:00
$limits = '' ;
2010-01-24 06:00:27 -05:00
}
2007-09-15 13:35:32 -04:00
2013-08-29 12:50:09 -04:00
if ( ! empty ( $search ) ) {
$search = like_escape ( $search );
$where .= $wpdb -> prepare ( ' AND ((t.name LIKE %s) OR (t.slug LIKE %s))' , '%' . $search . '%' , '%' . $search . '%' );
2008-02-12 04:02:02 -05:00
}
2009-04-21 18:13:44 -04:00
$selects = array ();
2010-02-28 02:37:24 -05:00
switch ( $fields ) {
2010-06-29 20:05:18 -04:00
case 'all' :
2013-08-29 11:19:10 -04:00
$selects = array ( 't.*' , 'tt.*' );
2010-06-29 20:05:18 -04:00
break ;
case 'ids' :
2010-02-28 02:37:24 -05:00
case 'id=>parent' :
2013-08-29 11:19:10 -04:00
$selects = array ( 't.term_id' , 'tt.parent' , 'tt.count' );
2010-06-29 20:05:18 -04:00
break ;
case 'names' :
2013-08-29 11:19:10 -04:00
$selects = array ( 't.term_id' , 'tt.parent' , 'tt.count' , 't.name' );
2010-06-29 20:05:18 -04:00
break ;
case 'count' :
2010-05-11 12:50:25 -04:00
$orderby = '' ;
$order = '' ;
2013-08-29 11:19:10 -04:00
$selects = array ( 'COUNT(*)' );
break ;
case 'id=>name' :
$selects = array ( 't.term_id' , 't.name' );
break ;
case 'id=>slug' :
$selects = array ( 't.term_id' , 't.slug' );
break ;
2010-06-29 20:05:18 -04:00
}
2007-09-15 13:35:32 -04:00
2010-10-28 13:55:30 -04:00
$_fields = $fields ;
2014-03-28 17:29:13 -04:00
/**
* Filter the fields to select in the terms query .
*
* @ since 2.8 . 0
*
* @ param array $selects An array of fields to select for the terms query .
* @ param array $args An array of term query arguments .
* @ param string | array $taxonomies A taxonomy or array of taxonomies .
*/
2013-09-23 14:39:09 -04:00
$fields = implode ( ', ' , apply_filters ( 'get_terms_fields' , $selects , $args , $taxonomies ) );
2010-10-28 13:55:30 -04:00
$join = " INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id " ;
$pieces = array ( 'fields' , 'join' , 'where' , 'orderby' , 'order' , 'limits' );
2014-03-28 17:29:13 -04:00
/**
* Filter the terms query SQL clauses .
*
* @ since 3.1 . 0
*
* @ param array $pieces Terms query SQL clauses .
* @ param string | array $taxonomies A taxonomy or array of taxonomies .
* @ param array $args An array of terms query arguments .
*/
2010-10-28 13:55:30 -04:00
$clauses = apply_filters ( 'terms_clauses' , compact ( $pieces ), $taxonomies , $args );
foreach ( $pieces as $piece )
$$piece = isset ( $clauses [ $piece ] ) ? $clauses [ $piece ] : '' ;
2010-11-17 13:47:34 -05:00
$query = " SELECT $fields FROM $wpdb->terms AS t $join WHERE $where $orderby $order $limits " ;
2010-10-28 13:55:30 -04:00
$fields = $_fields ;
2007-09-15 13:35:32 -04:00
2010-02-28 02:37:24 -05:00
if ( 'count' == $fields ) {
$term_count = $wpdb -> get_var ( $query );
return $term_count ;
}
2009-01-22 17:59:29 -05:00
$terms = $wpdb -> get_results ( $query );
2007-09-15 13:35:32 -04:00
if ( 'all' == $fields ) {
update_term_cache ( $terms );
}
2007-11-02 00:31:44 -04:00
if ( empty ( $terms ) ) {
2012-09-25 01:26:19 -04:00
wp_cache_add ( $cache_key , array (), 'terms' , DAY_IN_SECONDS );
2014-03-28 17:29:13 -04:00
/** This filter is documented in wp-includes/taxonomy.php */
$terms = apply_filters ( 'get_terms' , array (), $taxonomies , $args );
2008-09-21 16:41:25 -04:00
return $terms ;
2007-11-02 00:31:44 -04:00
}
2007-09-15 13:35:32 -04:00
2008-11-12 19:20:12 -05:00
if ( $child_of ) {
2013-08-23 17:29:10 -04:00
$children = _get_term_hierarchy ( reset ( $taxonomies ) );
if ( ! empty ( $children ) )
$terms = _get_term_children ( $child_of , $terms , reset ( $taxonomies ) );
2007-09-15 13:35:32 -04:00
}
// Update term counts to include children.
2008-11-12 19:20:12 -05:00
if ( $pad_counts && 'all' == $fields )
2013-08-23 17:29:10 -04:00
_pad_term_counts ( $terms , reset ( $taxonomies ) );
2007-09-15 13:35:32 -04:00
// Make sure we show empty categories that have children.
2013-08-23 17:29:10 -04:00
if ( $hierarchical && $hide_empty && is_array ( $terms ) ) {
2007-09-15 13:35:32 -04:00
foreach ( $terms as $k => $term ) {
if ( ! $term -> count ) {
2014-03-07 14:29:16 -05:00
$children = get_term_children ( $term -> term_id , reset ( $taxonomies ) );
if ( is_array ( $children ) ) {
foreach ( $children as $child_id ) {
$child = get_term ( $child_id , reset ( $taxonomies ) );
if ( $child -> count ) {
2008-08-06 16:31:54 -04:00
continue 2 ;
2014-03-07 14:29:16 -05:00
}
}
}
2007-09-15 13:35:32 -04:00
// It really is empty
unset ( $terms [ $k ]);
}
}
}
2013-08-29 11:19:10 -04:00
reset ( $terms );
2008-12-09 13:03:31 -05:00
2008-11-12 19:20:12 -05:00
$_terms = array ();
2010-01-15 12:40:37 -05:00
if ( 'id=>parent' == $fields ) {
2013-08-29 11:19:10 -04:00
while ( $term = array_shift ( $terms ) )
2010-01-15 12:40:37 -05:00
$_terms [ $term -> term_id ] = $term -> parent ;
} elseif ( 'ids' == $fields ) {
2013-08-29 11:19:10 -04:00
while ( $term = array_shift ( $terms ) )
2008-11-12 19:20:12 -05:00
$_terms [] = $term -> term_id ;
} elseif ( 'names' == $fields ) {
2013-08-29 11:19:10 -04:00
while ( $term = array_shift ( $terms ) )
2008-11-12 19:20:12 -05:00
$_terms [] = $term -> name ;
2013-08-29 11:19:10 -04:00
} elseif ( 'id=>name' == $fields ) {
while ( $term = array_shift ( $terms ) )
$_terms [ $term -> term_id ] = $term -> name ;
} elseif ( 'id=>slug' == $fields ) {
while ( $term = array_shift ( $terms ) )
$_terms [ $term -> term_id ] = $term -> slug ;
2008-11-12 19:20:12 -05:00
}
2007-09-15 13:35:32 -04:00
2013-08-29 11:19:10 -04:00
if ( ! empty ( $_terms ) )
$terms = $_terms ;
2013-03-03 21:52:43 -05:00
if ( $number && is_array ( $terms ) && count ( $terms ) > $number )
$terms = array_slice ( $terms , $offset , $number );
2009-01-22 17:59:29 -05:00
2012-09-25 01:26:19 -04:00
wp_cache_add ( $cache_key , $terms , 'terms' , DAY_IN_SECONDS );
2007-09-15 13:35:32 -04:00
2014-03-28 17:29:13 -04:00
/** This filter is documented in wp-includes/taxonomy */
2013-08-29 11:19:10 -04:00
$terms = apply_filters ( 'get_terms' , $terms , $taxonomies , $args );
2007-09-15 13:35:32 -04:00
return $terms ;
}
/**
2008-06-22 16:23:23 -04:00
* Check if Term exists .
2007-09-15 13:35:32 -04:00
*
2010-06-11 11:53:41 -04:00
* Formerly is_term (), introduced in 2.3 . 0.
*
* @ since 3.0 . 0
2007-10-21 13:18:24 -04:00
*
* @ uses $wpdb
2007-10-15 18:49:31 -04:00
*
2007-09-15 13:35:32 -04:00
* @ param int | string $term The term to check
* @ param string $taxonomy The taxonomy name to use
2009-04-10 16:58:25 -04:00
* @ param int $parent ID of parent term under which to confine the exists search .
2011-12-16 15:56:14 -05:00
* @ return mixed Returns 0 if the term does not exist . Returns the term ID if no taxonomy is specified
* and the term ID exists . Returns an array of the term ID and the taxonomy if the pairing exists .
2007-09-15 13:35:32 -04:00
*/
2010-06-11 11:53:41 -04:00
function term_exists ( $term , $taxonomy = '' , $parent = 0 ) {
2007-09-15 13:35:32 -04:00
global $wpdb ;
2008-07-24 15:28:40 -04:00
$select = " SELECT term_id FROM $wpdb->terms as t WHERE " ;
$tax_select = " SELECT tt.term_id, tt.term_taxonomy_id FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy as tt ON tt.term_id = t.term_id WHERE " ;
2007-09-15 13:35:32 -04:00
if ( is_int ( $term ) ) {
if ( 0 == $term )
return 0 ;
2008-07-17 12:59:40 -04:00
$where = 't.term_id = %d' ;
2008-07-24 15:28:40 -04:00
if ( ! empty ( $taxonomy ) )
return $wpdb -> get_row ( $wpdb -> prepare ( $tax_select . $where . " AND tt.taxonomy = %s " , $term , $taxonomy ), ARRAY_A );
else
return $wpdb -> get_var ( $wpdb -> prepare ( $select . $where , $term ) );
}
2013-03-03 16:11:40 -05:00
$term = trim ( wp_unslash ( $term ) );
2009-05-24 19:47:49 -04:00
2008-07-24 15:28:40 -04:00
if ( '' === $slug = sanitize_title ( $term ) )
return 0 ;
$where = 't.slug = %s' ;
$else_where = 't.name = %s' ;
2009-04-10 16:58:25 -04:00
$where_fields = array ( $slug );
$else_where_fields = array ( $term );
2008-07-24 15:28:40 -04:00
if ( ! empty ( $taxonomy ) ) {
2009-04-10 16:58:25 -04:00
$parent = ( int ) $parent ;
if ( $parent > 0 ) {
$where_fields [] = $parent ;
$else_where_fields [] = $parent ;
$where .= ' AND tt.parent = %d' ;
$else_where .= ' AND tt.parent = %d' ;
}
$where_fields [] = $taxonomy ;
$else_where_fields [] = $taxonomy ;
if ( $result = $wpdb -> get_row ( $wpdb -> prepare ( " SELECT tt.term_id, tt.term_taxonomy_id FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy as tt ON tt.term_id = t.term_id WHERE $where AND tt.taxonomy = %s " , $where_fields ), ARRAY_A ) )
2008-07-24 15:28:40 -04:00
return $result ;
2008-08-09 01:36:14 -04:00
2009-04-10 16:58:25 -04:00
return $wpdb -> get_row ( $wpdb -> prepare ( " SELECT tt.term_id, tt.term_taxonomy_id FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy as tt ON tt.term_id = t.term_id WHERE $else_where AND tt.taxonomy = %s " , $else_where_fields ), ARRAY_A );
2007-09-15 13:35:32 -04:00
}
2009-04-10 16:58:25 -04:00
if ( $result = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT term_id FROM $wpdb->terms as t WHERE $where " , $where_fields ) ) )
2008-07-24 15:28:40 -04:00
return $result ;
2007-09-15 13:35:32 -04:00
2009-04-10 16:58:25 -04:00
return $wpdb -> get_var ( $wpdb -> prepare ( " SELECT term_id FROM $wpdb->terms as t WHERE $else_where " , $else_where_fields ) );
2007-09-15 13:35:32 -04:00
}
2012-01-04 17:44:19 -05:00
/**
* Check if a term is an ancestor of another term .
*
* You can use either an id or the term object for both parameters .
*
* @ since 3.4 . 0
*
* @ param int | object $term1 ID or object to check if this is the parent term .
* @ param int | object $term2 The child term .
* @ param string $taxonomy Taxonomy name that $term1 and $term2 belong to .
* @ return bool Whether $term2 is child of $term1
*/
function term_is_ancestor_of ( $term1 , $term2 , $taxonomy ) {
if ( ! isset ( $term1 -> term_id ) )
$term1 = get_term ( $term1 , $taxonomy );
if ( ! isset ( $term2 -> parent ) )
$term2 = get_term ( $term2 , $taxonomy );
if ( empty ( $term1 -> term_id ) || empty ( $term2 -> parent ) )
return false ;
if ( $term2 -> parent == $term1 -> term_id )
return true ;
return term_is_ancestor_of ( $term1 , get_term ( $term2 -> parent , $taxonomy ), $taxonomy );
}
2007-09-15 13:35:32 -04:00
/**
2008-06-22 16:23:23 -04:00
* Sanitize Term all fields .
2007-09-15 13:35:32 -04:00
*
2011-09-05 15:08:15 -04:00
* Relies on sanitize_term_field () to sanitize the term . The difference is that
2008-06-22 16:23:23 -04:00
* this function will sanitize < strong > all </ strong > fields . The context is based
* on sanitize_term_field () .
2007-09-15 13:35:32 -04:00
*
* The $term is expected to be either an array or an object .
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
*
* @ uses sanitize_term_field Used to sanitize all fields in a term
2007-10-15 18:49:31 -04:00
*
2007-09-15 13:35:32 -04:00
* @ param array | object $term The term to check
* @ param string $taxonomy The taxonomy name to use
2007-10-21 13:18:24 -04:00
* @ param string $context Default is 'display' .
2007-09-15 13:35:32 -04:00
* @ return array | object Term with all fields sanitized
*/
function sanitize_term ( $term , $taxonomy , $context = 'display' ) {
2007-11-07 01:20:08 -05:00
2013-11-04 20:19:11 -05:00
$fields = array ( 'term_id' , 'name' , 'description' , 'slug' , 'count' , 'parent' , 'term_group' , 'term_taxonomy_id' , 'object_id' );
2007-09-15 13:35:32 -04:00
2013-11-04 20:19:11 -05:00
$do_object = is_object ( $term );
2007-09-15 13:35:32 -04:00
2008-11-10 13:54:18 -05:00
$term_id = $do_object ? $term -> term_id : ( isset ( $term [ 'term_id' ]) ? $term [ 'term_id' ] : 0 );
2008-08-06 16:31:54 -04:00
foreach ( ( array ) $fields as $field ) {
2008-11-10 13:54:18 -05:00
if ( $do_object ) {
if ( isset ( $term -> $field ) )
$term -> $field = sanitize_term_field ( $field , $term -> $field , $term_id , $taxonomy , $context );
} else {
if ( isset ( $term [ $field ]) )
$term [ $field ] = sanitize_term_field ( $field , $term [ $field ], $term_id , $taxonomy , $context );
}
2007-09-15 13:35:32 -04:00
}
2008-11-17 15:03:31 -05:00
if ( $do_object )
$term -> filter = $context ;
else
$term [ 'filter' ] = $context ;
2007-09-15 13:35:32 -04:00
return $term ;
}
/**
2008-06-22 16:23:23 -04:00
* Cleanse the field value in the term based on the context .
2007-12-13 19:25:39 -05:00
*
2008-06-22 16:23:23 -04:00
* Passing a term field value through the function should be assumed to have
* cleansed the value for whatever context the term field is going to be used .
2007-12-13 19:25:39 -05:00
*
2008-06-22 16:23:23 -04:00
* If no context or an unsupported context is given , then default filters will
* be applied .
2007-09-15 13:35:32 -04:00
*
2008-06-22 16:23:23 -04:00
* There are enough filters for each context to support a custom filtering
* without creating your own filter function . Simply create a function that
* hooks into the filter you need .
2007-09-15 13:35:32 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
*
* @ uses $wpdb
2007-10-15 18:49:31 -04:00
*
2007-09-15 13:35:32 -04:00
* @ param string $field Term field to sanitize
* @ param string $value Search for this term value
* @ param int $term_id Term ID
* @ param string $taxonomy Taxonomy Name
* @ param string $context Either edit , db , display , attribute , or js .
* @ return mixed sanitized field
*/
function sanitize_term_field ( $field , $value , $term_id , $taxonomy , $context ) {
2013-11-04 20:19:11 -05:00
$int_fields = array ( 'parent' , 'term_id' , 'count' , 'term_group' , 'term_taxonomy_id' , 'object_id' );
2013-11-06 18:41:09 -05:00
if ( in_array ( $field , $int_fields ) ) {
$value = ( int ) $value ;
if ( $value < 0 )
$value = 0 ;
}
2007-09-15 13:35:32 -04:00
2007-11-03 15:06:43 -04:00
if ( 'raw' == $context )
return $value ;
2007-09-15 13:35:32 -04:00
if ( 'edit' == $context ) {
2014-03-28 17:29:13 -04:00
/**
* Filter a term field to edit before it is sanitized .
*
* The dynamic portion of the filter name , $field , refers to the term field .
*
* @ since 2.3 . 0
*
* @ param mixed $value Value of the term field .
* @ param int $term_id Term ID .
* @ param string $taxonomy Taxonomy slug .
*/
$value = apply_filters ( " edit_term_ { $field } " , $value , $term_id , $taxonomy );
/**
* Filter the taxonomy field to edit before it is sanitized .
*
* The dynamic portions of the filter name , $taxonomy , and $field , refer
* to the taxonomy slug and taxonomy field , respectively .
*
* @ since 2.3 . 0
*
* @ param mixed $value Value of the taxonomy field to edit .
* @ param int $term_id Term ID .
*/
$value = apply_filters ( " edit_ { $taxonomy } _ { $field } " , $value , $term_id );
2007-09-15 13:35:32 -04:00
if ( 'description' == $field )
2010-12-25 17:45:09 -05:00
$value = esc_html ( $value ); // textarea_escaped
2007-09-15 13:35:32 -04:00
else
2009-05-05 15:43:53 -04:00
$value = esc_attr ( $value );
2007-09-15 13:35:32 -04:00
} else if ( 'db' == $context ) {
2014-03-28 17:29:13 -04:00
/**
* Filter a term field value before it is sanitized .
*
* The dynamic portion of the filter name , $field , refers to the term field .
*
* @ since 2.3 . 0
*
* @ param mixed $value Value of the term field .
* @ param string $taxonomy Taxonomy slug .
*/
$value = apply_filters ( " pre_term_ { $field } " , $value , $taxonomy );
/**
* Filter a taxonomy field before it is sanitized .
*
* The dynamic portions of the filter name , $taxonomy , and $field , refer
* to the taxonomy slug and field name , respectively .
*
* @ since 2.3 . 0
*
* @ param mixed $value Value of the taxonomy field .
*/
$value = apply_filters ( " pre_ { $taxonomy } _ { $field } " , $value );
2007-09-22 14:01:08 -04:00
// Back compat filters
2014-03-28 17:29:13 -04:00
if ( 'slug' == $field ) {
/**
* Filter the category nicename before it is sanitized .
*
* Use the pre_ { $taxonomy } _ { $field } hook instead .
*
* @ since 2.0 . 3
*
* @ param string $value The category nicename .
*/
$value = apply_filters ( 'pre_category_nicename' , $value );
}
2008-02-05 01:47:27 -05:00
2007-09-15 13:35:32 -04:00
} else if ( 'rss' == $context ) {
2014-03-28 17:29:13 -04:00
/**
* Filter the term field for use in RSS .
*
* The dynamic portion of the filter name , $field , refers to the term field .
*
* @ since 2.3 . 0
*
* @ param mixed $value Value of the term field .
* @ param string $taxonomy Taxonomy slug .
*/
$value = apply_filters ( " term_ { $field } _rss " , $value , $taxonomy );
/**
* Filter the taxonomy field for use in RSS .
*
* The dynamic portions of the hook name , $taxonomy , and $field , refer
* to the taxonomy slug and field name , respectively .
*
* @ since 2.3 . 0
*
* @ param mixed $value Value of the taxonomy field .
*/
$value = apply_filters ( " { $taxonomy } _ { $field } _rss " , $value );
2007-09-15 13:35:32 -04:00
} else {
// Use display filters by default.
2014-03-28 17:29:13 -04:00
/**
* Filter the term field sanitized for display .
*
* The dynamic portion of the filter name , $field , refers to the term field name .
*
* @ since 2.3 . 0
*
* @ param mixed $value Value of the term field .
* @ param int $term_id Term ID .
* @ param string $taxonomy Taxonomy slug .
* @ param string $context Context to retrieve the term field value .
*/
$value = apply_filters ( " term_ { $field } " , $value , $term_id , $taxonomy , $context );
/**
* Filter the taxonomy field sanitized for display .
*
* The dynamic portions of the filter name , $taxonomy , and $field , refer
* to the taxonomy slug and taxonomy field , respectively .
*
* @ since 2.3 . 0
*
* @ param mixed $value Value of the taxonomy field .
* @ param int $term_id Term ID .
* @ param string $context Context to retrieve the taxonomy field value .
*/
$value = apply_filters ( " { $taxonomy } _ { $field } " , $value , $term_id , $context );
2007-09-15 13:35:32 -04:00
}
if ( 'attribute' == $context )
2009-05-05 15:43:53 -04:00
$value = esc_attr ( $value );
2007-09-15 13:35:32 -04:00
else if ( 'js' == $context )
2009-05-09 03:27:22 -04:00
$value = esc_js ( $value );
2007-09-15 13:35:32 -04:00
return $value ;
}
/**
2008-06-22 16:23:23 -04:00
* Count how many terms are in Taxonomy .
2007-09-15 13:35:32 -04:00
*
2010-02-28 02:37:24 -05:00
* Default $args is 'hide_empty' which can be 'hide_empty=true' or array ( 'hide_empty' => true ) .
2007-09-15 13:35:32 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
*
2010-02-28 02:37:24 -05:00
* @ uses get_terms ()
2007-10-21 13:18:24 -04:00
* @ uses wp_parse_args () Turns strings into arrays and merges defaults into an array .
2007-10-15 18:49:31 -04:00
*
2007-09-15 13:35:32 -04:00
* @ param string $taxonomy Taxonomy name
2010-02-28 02:37:24 -05:00
* @ param array | string $args Overwrite defaults . See get_terms ()
2012-09-14 12:11:30 -04:00
* @ return int | WP_Error How many terms are in $taxonomy . WP_Error if $taxonomy does not exist .
2007-09-15 13:35:32 -04:00
*/
function wp_count_terms ( $taxonomy , $args = array () ) {
2010-02-28 02:37:24 -05:00
$defaults = array ( 'hide_empty' => false );
2007-09-15 13:35:32 -04:00
$args = wp_parse_args ( $args , $defaults );
2010-02-28 02:37:24 -05:00
// backwards compatibility
if ( isset ( $args [ 'ignore_empty' ]) ) {
$args [ 'hide_empty' ] = $args [ 'ignore_empty' ];
unset ( $args [ 'ignore_empty' ]);
}
$args [ 'fields' ] = 'count' ;
2007-09-15 13:35:32 -04:00
2010-02-28 02:37:24 -05:00
return get_terms ( $taxonomy , $args );
2007-09-15 13:35:32 -04:00
}
/**
2010-11-18 13:46:41 -05:00
* Will unlink the object from the taxonomy or taxonomies .
2007-09-15 13:35:32 -04:00
*
2010-12-13 16:21:50 -05:00
* Will remove all relationships between the object and any terms in
* a particular taxonomy or taxonomies . Does not remove the term or
2010-11-18 13:46:41 -05:00
* taxonomy itself .
2007-09-15 13:35:32 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2013-02-08 13:45:34 -05:00
* @ uses wp_remove_object_terms ()
2007-10-15 18:49:31 -04:00
*
2007-10-21 13:18:24 -04:00
* @ param int $object_id The term Object Id that refers to the term
2010-09-07 07:21:11 -04:00
* @ param string | array $taxonomies List of Taxonomy Names or single Taxonomy name .
2007-09-15 13:35:32 -04:00
*/
function wp_delete_object_term_relationships ( $object_id , $taxonomies ) {
$object_id = ( int ) $object_id ;
if ( ! is_array ( $taxonomies ) )
$taxonomies = array ( $taxonomies );
2008-08-06 16:31:54 -04:00
foreach ( ( array ) $taxonomies as $taxonomy ) {
2013-02-08 13:45:34 -05:00
$term_ids = wp_get_object_terms ( $object_id , $taxonomy , array ( 'fields' => 'ids' ) );
$term_ids = array_map ( 'intval' , $term_ids );
wp_remove_object_terms ( $object_id , $term_ids , $taxonomy );
2007-09-15 13:35:32 -04:00
}
}
/**
2008-06-22 16:23:23 -04:00
* Removes a term from the database .
2007-10-15 18:49:31 -04:00
*
2008-06-22 16:23:23 -04:00
* If the term is a parent of other terms , then the children will be updated to
* that term ' s parent .
2007-12-13 19:25:39 -05:00
*
* The $args 'default' will only override the terms found , if there is only one
* term found . Any other and the found terms are used .
2009-04-20 14:18:39 -04:00
*
2009-03-18 17:06:49 -04:00
* The $args 'force_default' will force the term supplied as default to be
* assigned even if the object was not going to be termless
2014-02-25 12:14:14 -05:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-12-13 19:25:39 -05:00
*
2007-10-21 13:18:24 -04:00
* @ uses $wpdb
2007-10-15 18:49:31 -04:00
*
* @ param int $term Term ID
* @ param string $taxonomy Taxonomy Name
2007-12-13 19:25:39 -05:00
* @ param array | string $args Optional . Change 'default' term id and override found term ids .
* @ return bool | WP_Error Returns false if not term ; true if completes delete action .
2007-09-15 13:35:32 -04:00
*/
function wp_delete_term ( $term , $taxonomy , $args = array () ) {
global $wpdb ;
$term = ( int ) $term ;
2010-06-11 11:53:41 -04:00
if ( ! $ids = term_exists ( $term , $taxonomy ) )
2007-09-15 13:35:32 -04:00
return false ;
2007-10-28 17:33:03 -04:00
if ( is_wp_error ( $ids ) )
return $ids ;
2007-09-15 13:35:32 -04:00
$tt_id = $ids [ 'term_taxonomy_id' ];
$defaults = array ();
2010-10-19 03:48:22 -04:00
2010-10-03 03:29:44 -04:00
if ( 'category' == $taxonomy ) {
$defaults [ 'default' ] = get_option ( 'default_category' );
if ( $defaults [ 'default' ] == $term )
return 0 ; // Don't delete the default category
}
2010-10-19 03:48:22 -04:00
2007-09-15 13:35:32 -04:00
$args = wp_parse_args ( $args , $defaults );
extract ( $args , EXTR_SKIP );
2010-10-03 03:29:44 -04:00
if ( isset ( $default ) ) {
2007-09-15 13:35:32 -04:00
$default = ( int ) $default ;
2010-06-11 11:53:41 -04:00
if ( ! term_exists ( $default , $taxonomy ) )
2007-09-15 13:35:32 -04:00
unset ( $default );
}
// Update children to point to new parent
if ( is_taxonomy_hierarchical ( $taxonomy ) ) {
$term_obj = get_term ( $term , $taxonomy );
2007-09-18 12:32:22 -04:00
if ( is_wp_error ( $term_obj ) )
return $term_obj ;
2007-09-15 13:35:32 -04:00
$parent = $term_obj -> parent ;
2009-09-17 10:03:57 -04:00
$edit_tt_ids = $wpdb -> get_col ( " SELECT `term_taxonomy_id` FROM $wpdb->term_taxonomy WHERE `parent` = " . ( int ) $term_obj -> term_id );
2014-03-28 17:29:13 -04:00
/**
* Fires immediately before a term to delete ' s children are reassigned a parent .
*
* @ since 2.9 . 0
*
* @ param array $edit_tt_ids An array of term taxonomy IDs for the given term .
*/
2009-09-17 10:03:57 -04:00
do_action ( 'edit_term_taxonomies' , $edit_tt_ids );
2007-10-25 03:15:02 -04:00
$wpdb -> update ( $wpdb -> term_taxonomy , compact ( 'parent' ), array ( 'parent' => $term_obj -> term_id ) + compact ( 'taxonomy' ) );
2014-03-28 17:29:13 -04:00
/**
* Fires immediately after a term to delete ' s children are reassigned a parent .
*
* @ since 2.9 . 0
*
* @ param array $edit_tt_ids An array of term taxonomy IDs for the given term .
*/
2009-09-17 10:03:57 -04:00
do_action ( 'edited_term_taxonomies' , $edit_tt_ids );
2007-09-15 13:35:32 -04:00
}
2007-10-12 23:51:11 -04:00
$objects = $wpdb -> get_col ( $wpdb -> prepare ( " SELECT object_id FROM $wpdb->term_relationships WHERE term_taxonomy_id = %d " , $tt_id ) );
2007-09-15 13:35:32 -04:00
foreach ( ( array ) $objects as $object ) {
2009-05-25 14:18:06 -04:00
$terms = wp_get_object_terms ( $object , $taxonomy , array ( 'fields' => 'ids' , 'orderby' => 'none' ));
2009-03-18 17:06:49 -04:00
if ( 1 == count ( $terms ) && isset ( $default ) ) {
2007-09-15 13:35:32 -04:00
$terms = array ( $default );
2009-03-18 17:06:49 -04:00
} else {
2007-09-15 13:35:32 -04:00
$terms = array_diff ( $terms , array ( $term ));
2009-03-18 17:06:49 -04:00
if ( isset ( $default ) && isset ( $force_default ) && $force_default )
$terms = array_merge ( $terms , array ( $default ));
}
2007-09-15 13:35:32 -04:00
$terms = array_map ( 'intval' , $terms );
wp_set_object_terms ( $object , $terms , $taxonomy );
}
2010-12-02 12:10:02 -05:00
// Clean the relationship caches for all object types using this term
$tax_object = get_taxonomy ( $taxonomy );
foreach ( $tax_object -> object_type as $object_type )
2010-12-13 16:21:50 -05:00
clean_object_term_cache ( $objects , $object_type );
2012-09-21 09:27:56 -04:00
// Get the object before deletion so we can pass to actions below
$deleted_term = get_term ( $term , $taxonomy );
2014-03-28 17:29:13 -04:00
/**
* Fires immediately before a term taxonomy ID is deleted .
*
* @ since 2.9 . 0
*
* @ param int $tt_id Term taxonomy ID .
*/
2009-09-17 10:03:57 -04:00
do_action ( 'delete_term_taxonomy' , $tt_id );
2012-03-24 11:24:31 -04:00
$wpdb -> delete ( $wpdb -> term_taxonomy , array ( 'term_taxonomy_id' => $tt_id ) );
2014-03-28 17:29:13 -04:00
/**
* Fires immediately after a term taxonomy ID is deleted .
*
* @ since 2.9 . 0
*
* @ param int $tt_id Term taxonomy ID .
*/
2009-09-17 10:03:57 -04:00
do_action ( 'deleted_term_taxonomy' , $tt_id );
2007-09-15 13:35:32 -04:00
// Delete the term if no taxonomies use it.
2007-10-12 23:51:11 -04:00
if ( ! $wpdb -> get_var ( $wpdb -> prepare ( " SELECT COUNT(*) FROM $wpdb->term_taxonomy WHERE term_id = %d " , $term ) ) )
2012-03-24 11:24:31 -04:00
$wpdb -> delete ( $wpdb -> terms , array ( 'term_id' => $term ) );
2007-09-15 13:35:32 -04:00
clean_term_cache ( $term , $taxonomy );
2014-03-28 17:29:13 -04:00
/**
* Fires after a term is deleted from the database and the cache is cleaned .
*
* @ since 2.5 . 0
*
* @ param int $term Term ID .
* @ param int $tt_id Term taxonomy ID .
* @ param string $taxonomy Taxonomy slug .
* @ param mixed $deleted_term Copy of the already - deleted term , in the form specified
* by the parent function . WP_Error otherwise .
*/
2012-09-21 09:27:56 -04:00
do_action ( 'delete_term' , $term , $tt_id , $taxonomy , $deleted_term );
2014-03-28 17:29:13 -04:00
/**
* Fires after a term in a specific taxonomy is deleted .
*
* The dynamic portion of the hook name , $taxonomy , refers to the specific
* taxonomy the term belonged to .
*
* @ since 2.3 . 0
*
* @ param int $term Term ID .
* @ param int $tt_id Term taxonomy ID .
* @ param mixed $deleted_term Copy of the already - deleted term , in the form specified
* by the parent function . WP_Error otherwise .
*/
2012-09-21 09:27:56 -04:00
do_action ( " delete_ $taxonomy " , $term , $tt_id , $deleted_term );
2007-09-15 13:35:32 -04:00
return true ;
}
2010-12-16 17:46:13 -05:00
/**
2010-10-04 12:28:01 -04:00
* Deletes one existing category .
*
* @ since 2.0 . 0
* @ uses wp_delete_term ()
*
* @ param int $cat_ID
2011-09-05 15:08:15 -04:00
* @ return mixed Returns true if completes delete action ; false if term doesn ' t exist ;
2010-10-04 12:28:01 -04:00
* Zero on attempted deletion of default Category ; WP_Error object is also a possibility .
*/
function wp_delete_category ( $cat_ID ) {
return wp_delete_term ( $cat_ID , 'category' );
}
2007-09-15 13:35:32 -04:00
/**
2008-06-22 16:23:23 -04:00
* Retrieves the terms associated with the given object ( s ), in the supplied taxonomies .
2007-12-13 19:25:39 -05:00
*
2008-06-22 16:23:23 -04:00
* The following information has to do the $args parameter and for what can be
* contained in the string or array of that parameter , if it exists .
2007-12-13 19:25:39 -05:00
*
2008-06-22 16:23:23 -04:00
* The first argument is called , 'orderby' and has the default value of 'name' .
* The other value that is supported is 'count' .
2007-12-13 19:25:39 -05:00
*
2008-06-22 16:23:23 -04:00
* The second argument is called , 'order' and has the default value of 'ASC' .
* The only other value that will be acceptable is 'DESC' .
2007-12-13 19:25:39 -05:00
*
2008-06-22 16:23:23 -04:00
* The final argument supported is called , 'fields' and has the default value of
* 'all' . There are multiple other options that can be used instead . Supported
* values are as follows : 'all' , 'ids' , 'names' , and finally
* 'all_with_object_id' .
2007-10-15 18:49:31 -04:00
*
2008-06-22 16:23:23 -04:00
* The fields argument also decides what will be returned . If 'all' or
2011-09-05 15:08:15 -04:00
* 'all_with_object_id' is chosen or the default kept intact , then all matching
2008-06-22 16:23:23 -04:00
* terms objects will be returned . If either 'ids' or 'names' is used , then an
* array of all matching term ids or term names will be returned respectively .
2007-10-15 18:49:31 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
* @ uses $wpdb
2007-10-15 18:49:31 -04:00
*
2010-09-07 07:21:11 -04:00
* @ param int | array $object_ids The ID ( s ) of the object ( s ) to retrieve .
2007-09-15 13:35:32 -04:00
* @ param string | array $taxonomies The taxonomies to retrieve terms from .
2007-10-15 18:49:31 -04:00
* @ param array | string $args Change what is returned
2012-02-21 15:20:50 -05:00
* @ return array | WP_Error The requested term data or empty array if no terms found . WP_Error if any of the $taxonomies don ' t exist .
2007-09-15 13:35:32 -04:00
*/
function wp_get_object_terms ( $object_ids , $taxonomies , $args = array ()) {
global $wpdb ;
2012-02-21 15:20:50 -05:00
if ( empty ( $object_ids ) || empty ( $taxonomies ) )
return array ();
2007-09-15 13:35:32 -04:00
if ( ! is_array ( $taxonomies ) )
$taxonomies = array ( $taxonomies );
2014-02-17 16:56:12 -05:00
foreach ( $taxonomies as $taxonomy ) {
2010-06-11 11:53:41 -04:00
if ( ! taxonomy_exists ( $taxonomy ) )
2012-06-01 15:05:30 -04:00
return new WP_Error ( 'invalid_taxonomy' , __ ( 'Invalid taxonomy' ));
2007-09-15 13:35:32 -04:00
}
if ( ! is_array ( $object_ids ) )
$object_ids = array ( $object_ids );
$object_ids = array_map ( 'intval' , $object_ids );
$defaults = array ( 'orderby' => 'name' , 'order' => 'ASC' , 'fields' => 'all' );
$args = wp_parse_args ( $args , $defaults );
2008-03-26 02:37:19 -04:00
$terms = array ();
if ( count ( $taxonomies ) > 1 ) {
foreach ( $taxonomies as $index => $taxonomy ) {
$t = get_taxonomy ( $taxonomy );
2008-05-19 14:47:33 -04:00
if ( isset ( $t -> args ) && is_array ( $t -> args ) && $args != array_merge ( $args , $t -> args ) ) {
2008-03-26 02:37:19 -04:00
unset ( $taxonomies [ $index ]);
$terms = array_merge ( $terms , wp_get_object_terms ( $object_ids , $taxonomy , array_merge ( $args , $t -> args )));
}
}
} else {
$t = get_taxonomy ( $taxonomies [ 0 ]);
2008-05-19 14:47:33 -04:00
if ( isset ( $t -> args ) && is_array ( $t -> args ) )
2008-03-26 02:37:19 -04:00
$args = array_merge ( $args , $t -> args );
}
2007-09-15 13:35:32 -04:00
extract ( $args , EXTR_SKIP );
if ( 'count' == $orderby )
$orderby = 'tt.count' ;
else if ( 'name' == $orderby )
$orderby = 't.name' ;
2008-02-14 00:40:19 -05:00
else if ( 'slug' == $orderby )
$orderby = 't.slug' ;
else if ( 'term_group' == $orderby )
$orderby = 't.term_group' ;
2008-02-14 12:17:57 -05:00
else if ( 'term_order' == $orderby )
$orderby = 'tr.term_order' ;
2009-05-25 14:18:06 -04:00
else if ( 'none' == $orderby ) {
$orderby = '' ;
$order = '' ;
} else {
2009-05-27 13:09:19 -04:00
$orderby = 't.term_id' ;
2009-05-25 14:18:06 -04:00
}
2009-05-27 13:09:19 -04:00
// tt_ids queries can only be none or tr.term_taxonomy_id
if ( ( 'tt_ids' == $fields ) && ! empty ( $orderby ) )
$orderby = 'tr.term_taxonomy_id' ;
2009-05-25 14:18:06 -04:00
if ( ! empty ( $orderby ) )
$orderby = " ORDER BY $orderby " ;
2007-09-15 13:35:32 -04:00
2012-09-04 21:23:53 -04:00
$order = strtoupper ( $order );
if ( '' !== $order && ! in_array ( $order , array ( 'ASC' , 'DESC' ) ) )
$order = 'ASC' ;
2016-03-30 13:38:15 -04:00
$taxonomies = " ' " . implode ( " ', ' " , array_map ( 'esc_sql' , $taxonomies ) ) . " ' " ;
2007-09-15 13:35:32 -04:00
$object_ids = implode ( ', ' , $object_ids );
2008-02-22 12:43:56 -05:00
$select_this = '' ;
2007-09-15 13:35:32 -04:00
if ( 'all' == $fields )
$select_this = 't.*, tt.*' ;
else if ( 'ids' == $fields )
$select_this = 't.term_id' ;
2008-02-05 01:47:27 -05:00
else if ( 'names' == $fields )
2007-09-15 22:36:23 -04:00
$select_this = 't.name' ;
2011-08-25 14:49:46 -04:00
else if ( 'slugs' == $fields )
$select_this = 't.slug' ;
2007-09-15 13:35:32 -04:00
else if ( 'all_with_object_id' == $fields )
$select_this = 't.*, tt.*, tr.object_id' ;
2009-05-25 14:18:06 -04:00
$query = " SELECT $select_this FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON tt.term_id = t.term_id INNER JOIN $wpdb->term_relationships AS tr ON tr.term_taxonomy_id = tt.term_taxonomy_id WHERE tt.taxonomy IN ( $taxonomies ) AND tr.object_id IN ( $object_ids ) $orderby $order " ;
2007-09-15 13:35:32 -04:00
if ( 'all' == $fields || 'all_with_object_id' == $fields ) {
2013-11-04 20:19:11 -05:00
$_terms = $wpdb -> get_results ( $query );
2013-12-01 19:00:10 -05:00
foreach ( $_terms as $key => $term ) {
$_terms [ $key ] = sanitize_term ( $term , $taxonomy , 'raw' );
}
2013-11-04 20:19:11 -05:00
$terms = array_merge ( $terms , $_terms );
update_term_cache ( $terms );
2011-08-25 14:49:46 -04:00
} else if ( 'ids' == $fields || 'names' == $fields || 'slugs' == $fields ) {
2013-11-04 20:19:11 -05:00
$_terms = $wpdb -> get_col ( $query );
$_field = ( 'ids' == $fields ) ? 'term_id' : 'name' ;
2013-12-01 19:00:10 -05:00
foreach ( $_terms as $key => $term ) {
$_terms [ $key ] = sanitize_term_field ( $_field , $term , $term , $taxonomy , 'raw' );
}
2013-11-04 20:19:11 -05:00
$terms = array_merge ( $terms , $_terms );
2007-09-15 13:35:32 -04:00
} else if ( 'tt_ids' == $fields ) {
2009-05-25 14:18:06 -04:00
$terms = $wpdb -> get_col ( " SELECT tr.term_taxonomy_id FROM $wpdb->term_relationships AS tr INNER JOIN $wpdb->term_taxonomy AS tt ON tr.term_taxonomy_id = tt.term_taxonomy_id WHERE tr.object_id IN ( $object_ids ) AND tt.taxonomy IN ( $taxonomies ) $orderby $order " );
2013-12-01 19:00:10 -05:00
foreach ( $terms as $key => $tt_id ) {
$terms [ $key ] = sanitize_term_field ( 'term_taxonomy_id' , $tt_id , 0 , $taxonomy , 'raw' ); // 0 should be the term id, however is not needed when using raw context.
}
2007-09-15 13:35:32 -04:00
}
if ( ! $terms )
2009-05-10 05:25:43 -04:00
$terms = array ();
2007-09-15 13:35:32 -04:00
2014-03-28 17:29:13 -04:00
/**
* Filter the terms for a given object or objects .
*
* @ since 2.8 . 0
*
* @ param array $terms An array of terms for the given object or objects .
* @ param array | int $object_ids Object ID or array of IDs .
* @ param array | string $taxonomies A taxonomy or array of taxonomies .
* @ param array $args An array of arguments for retrieving terms for
* the given object ( s ) .
*/
return apply_filters ( 'wp_get_object_terms' , $terms , $object_ids , $taxonomies , $args );
2007-09-15 13:35:32 -04:00
}
/**
2013-09-18 21:57:10 -04:00
* Add a new term to the database .
2007-09-15 13:35:32 -04:00
*
2013-09-18 21:57:10 -04:00
* A non - existent term is inserted in the following sequence :
* 1. The term is added to the term table , then related to the taxonomy .
* 2. If everything is correct , several actions are fired .
* 3. The 'term_id_filter' is evaluated .
* 4. The term cache is cleaned .
* 5. Several more actions are fired .
* 6. An array is returned containing the term_id and term_taxonomy_id .
2007-12-13 19:25:39 -05:00
*
2013-09-19 12:09:10 -04:00
* If the 'slug' argument is not empty , then it is checked to see if the term
* is invalid . If it is not a valid , existing term , it is added and the term_id
* is given .
*
* If the taxonomy is hierarchical , and the 'parent' argument is not empty ,
* the term is inserted and the term_id will be given .
2013-09-18 21:57:10 -04:00
* Error handling :
2013-09-19 12:09:10 -04:00
* If $taxonomy does not exist or $term is empty ,
2013-09-18 21:57:10 -04:00
* a WP_Error object will be returned .
2007-12-13 19:25:39 -05:00
*
2013-09-19 12:09:10 -04:00
* If the term already exists on the same hierarchical level ,
* or the term slug and name are not unique , a WP_Error object will be returned .
2007-09-15 13:35:32 -04:00
*
2013-09-18 21:57:10 -04:00
* @ global wpdb $wpdb The WordPress database object .
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-15 18:49:31 -04:00
*
2013-09-18 21:57:10 -04:00
* @ param string $term The term to add or update .
* @ param string $taxonomy The taxonomy to which to add the term
* @ param array | string $args {
* Arguments to change values of the inserted term .
*
* @ type string 'alias_of' Slug of the term to make this term an alias of .
* Default empty string . Accepts a term slug .
* @ type string 'description' The term description .
* Default empty string .
* @ type int 'parent' The id of the parent term .
* Default 0.
* @ type string 'slug' The term slug to use .
* Default empty string .
* }
* @ return array | WP_Error An array containing the term_id and term_taxonomy_id , WP_Error otherwise .
2007-09-15 13:35:32 -04:00
*/
function wp_insert_term ( $term , $taxonomy , $args = array () ) {
global $wpdb ;
2010-06-11 11:53:41 -04:00
if ( ! taxonomy_exists ( $taxonomy ) )
2007-09-15 13:35:32 -04:00
return new WP_Error ( 'invalid_taxonomy' , __ ( 'Invalid taxonomy' ));
2014-03-28 17:29:13 -04:00
/**
* Filter a term before it is sanitized and inserted into the database .
*
* @ since 3.0 . 0
*
* @ param string $term The term to add or update .
* @ param string $taxonomy Taxonomy slug .
*/
2010-02-26 02:40:35 -05:00
$term = apply_filters ( 'pre_insert_term' , $term , $taxonomy );
if ( is_wp_error ( $term ) )
return $term ;
2007-09-15 13:35:32 -04:00
if ( is_int ( $term ) && 0 == $term )
return new WP_Error ( 'invalid_term_id' , __ ( 'Invalid term ID' ));
2008-07-21 17:53:32 -04:00
if ( '' == trim ( $term ) )
return new WP_Error ( 'empty_term_name' , __ ( 'A name is required for this term' ));
2007-09-15 13:35:32 -04:00
$defaults = array ( 'alias_of' => '' , 'description' => '' , 'parent' => 0 , 'slug' => '' );
$args = wp_parse_args ( $args , $defaults );
$args [ 'name' ] = $term ;
2007-09-22 14:01:08 -04:00
$args [ 'taxonomy' ] = $taxonomy ;
2007-09-15 13:35:32 -04:00
$args = sanitize_term ( $args , $taxonomy , 'db' );
extract ( $args , EXTR_SKIP );
2013-03-01 11:28:40 -05:00
// expected_slashed ($name)
2013-03-03 16:11:40 -05:00
$name = wp_unslash ( $name );
$description = wp_unslash ( $description );
2013-03-01 11:28:40 -05:00
2013-12-02 18:06:11 -05:00
$slug_provided = ! empty ( $slug );
if ( ! $slug_provided ) {
2010-05-24 11:56:50 -04:00
$slug = sanitize_title ( $name );
2013-12-02 18:06:11 -05:00
}
2007-09-15 13:35:32 -04:00
$term_group = 0 ;
if ( $alias_of ) {
2007-10-23 12:36:08 -04:00
$alias = $wpdb -> get_row ( $wpdb -> prepare ( " SELECT term_id, term_group FROM $wpdb->terms WHERE slug = %s " , $alias_of ) );
2007-09-15 13:35:32 -04:00
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.
2007-10-23 12:43:15 -04:00
$term_group = $wpdb -> get_var ( " SELECT MAX(term_group) FROM $wpdb->terms " ) + 1 ;
2014-03-28 17:29:13 -04:00
/**
* Fires immediately before the given terms are edited .
*
* @ since 2.9 . 0
*
* @ param int $term_id Term ID .
* @ param string $taxonomy Taxonomy slug .
*/
2013-07-28 18:15:03 -04:00
do_action ( 'edit_terms' , $alias -> term_id , $taxonomy );
2009-03-05 23:27:51 -05:00
$wpdb -> update ( $wpdb -> terms , compact ( 'term_group' ), array ( 'term_id' => $alias -> term_id ) );
2014-03-28 17:29:13 -04:00
/**
* Fires immediately after the given terms are edited .
*
* @ since 2.9 . 0
*
* @ param int $term_id Term ID
* @ param string $taxonomy Taxonomy slug .
*/
2013-07-28 18:15:03 -04:00
do_action ( 'edited_terms' , $alias -> term_id , $taxonomy );
2007-09-15 13:35:32 -04:00
}
}
2010-06-11 11:53:41 -04:00
if ( $term_id = term_exists ( $slug ) ) {
2010-04-25 03:35:16 -04:00
$existing_term = $wpdb -> get_row ( $wpdb -> prepare ( " SELECT name FROM $wpdb->terms WHERE term_id = %d " , $term_id ), ARRAY_A );
2010-05-21 12:03:35 -04:00
// We've got an existing term in the same taxonomy, which matches the name of the new term:
2010-07-14 10:12:23 -04:00
if ( is_taxonomy_hierarchical ( $taxonomy ) && $existing_term [ 'name' ] == $name && $exists = term_exists ( ( int ) $term_id , $taxonomy ) ) {
2010-05-21 12:03:35 -04:00
// Hierarchical, and it matches an existing term, Do not allow same "name" in the same level.
2010-04-25 03:35:16 -04:00
$siblings = get_terms ( $taxonomy , array ( 'fields' => 'names' , 'get' => 'all' , 'parent' => ( int ) $parent ) );
if ( in_array ( $name , $siblings ) ) {
2013-12-02 18:06:11 -05:00
if ( $slug_provided ) {
return new WP_Error ( 'term_exists' , __ ( 'A term with the name and slug provided already exists with this parent.' ), $exists [ 'term_id' ] );
} else {
return new WP_Error ( 'term_exists' , __ ( 'A term with the name provided already exists with this parent.' ), $exists [ 'term_id' ] );
}
2010-04-25 03:35:16 -04:00
} else {
$slug = wp_unique_term_slug ( $slug , ( object ) $args );
if ( false === $wpdb -> insert ( $wpdb -> terms , compact ( 'name' , 'slug' , 'term_group' ) ) )
return new WP_Error ( 'db_insert_error' , __ ( 'Could not insert term into the database' ), $wpdb -> last_error );
$term_id = ( int ) $wpdb -> insert_id ;
}
} elseif ( $existing_term [ 'name' ] != $name ) {
2010-05-21 12:03:35 -04:00
// We've got an existing term, with a different name, Create the new term.
2010-04-25 03:35:16 -04:00
$slug = wp_unique_term_slug ( $slug , ( object ) $args );
if ( false === $wpdb -> insert ( $wpdb -> terms , compact ( 'name' , 'slug' , 'term_group' ) ) )
return new WP_Error ( 'db_insert_error' , __ ( 'Could not insert term into the database' ), $wpdb -> last_error );
$term_id = ( int ) $wpdb -> insert_id ;
2010-07-14 10:12:23 -04:00
} elseif ( $exists = term_exists ( ( int ) $term_id , $taxonomy ) ) {
2010-05-21 14:03:53 -04:00
// Same name, same slug.
2013-12-02 18:06:11 -05:00
return new WP_Error ( 'term_exists' , __ ( 'A term with the name and slug provided already exists.' ), $exists [ 'term_id' ] );
2010-04-25 03:35:16 -04:00
}
} else {
// This term does not exist at all in the database, Create it.
2010-01-11 17:23:58 -05:00
$slug = wp_unique_term_slug ( $slug , ( object ) $args );
2010-04-01 21:26:44 -04:00
if ( false === $wpdb -> insert ( $wpdb -> terms , compact ( 'name' , 'slug' , 'term_group' ) ) )
return new WP_Error ( 'db_insert_error' , __ ( 'Could not insert term into the database' ), $wpdb -> last_error );
$term_id = ( int ) $wpdb -> insert_id ;
2007-09-15 13:35:32 -04:00
}
2010-04-25 03:35:16 -04:00
// Seems unreachable, However, Is used in the case that a term name is provided, which sanitizes to an empty string.
2010-05-03 16:26:11 -04:00
if ( empty ( $slug ) ) {
2007-09-15 13:35:32 -04:00
$slug = sanitize_title ( $slug , $term_id );
2014-03-28 17:29:13 -04:00
/** This action is documented in wp-includes/taxonomy.php */
2013-07-28 18:15:03 -04:00
do_action ( 'edit_terms' , $term_id , $taxonomy );
2007-10-12 23:51:11 -04:00
$wpdb -> update ( $wpdb -> terms , compact ( 'slug' ), compact ( 'term_id' ) );
2014-03-28 17:29:13 -04:00
/** This action is documented in wp-includes/taxonomy.php */
2013-07-28 18:15:03 -04:00
do_action ( 'edited_terms' , $term_id , $taxonomy );
2007-09-15 13:35:32 -04:00
}
2007-10-12 23:51:11 -04:00
$tt_id = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT tt.term_taxonomy_id FROM $wpdb->term_taxonomy AS tt INNER JOIN $wpdb->terms AS t ON tt.term_id = t.term_id WHERE tt.taxonomy = %s AND t.term_id = %d " , $taxonomy , $term_id ) );
2007-09-15 13:35:32 -04:00
if ( ! empty ( $tt_id ) )
return array ( 'term_id' => $term_id , 'term_taxonomy_id' => $tt_id );
2007-10-12 23:51:11 -04:00
$wpdb -> insert ( $wpdb -> term_taxonomy , compact ( 'term_id' , 'taxonomy' , 'description' , 'parent' ) + array ( 'count' => 0 ) );
2007-09-15 13:35:32 -04:00
$tt_id = ( int ) $wpdb -> insert_id ;
2014-03-28 17:29:13 -04:00
/**
* Fires immediately after a new term is created , before the term cache is cleaned .
*
* @ since 2.3 . 0
*
* @ param int $term_id Term ID .
* @ param int $tt_id Term taxonomy ID .
* @ param string $taxonomy Taxonomy slug .
*/
do_action ( " create_term " , $term_id , $tt_id , $taxonomy );
2007-09-15 13:35:32 -04:00
2014-03-28 17:29:13 -04:00
/**
* Fires after a new term is created for a specific taxonomy .
*
* The dynamic portion of the hook name , $taxonomy , refers
* to the slug of the taxonomy the term was created for .
*
* @ since 2.3 . 0
*
* @ param int $term_id Term ID .
* @ param int $tt_id Term taxonomy ID .
*/
do_action ( " create_ $taxonomy " , $term_id , $tt_id );
/**
* Filter the term ID after a new term is created .
*
* @ since 2.3 . 0
*
* @ param int $term_id Term ID .
* @ param int $tt_id Taxonomy term ID .
*/
$term_id = apply_filters ( 'term_id_filter' , $term_id , $tt_id );
2007-09-15 13:35:32 -04:00
clean_term_cache ( $term_id , $taxonomy );
2014-03-28 17:29:13 -04:00
/**
* Fires after a new term is created , and after the term cache has been cleaned .
*
* @ since 2.3 . 0
*/
do_action ( " created_term " , $term_id , $tt_id , $taxonomy );
/**
* Fires after a new term in a specific taxonomy is created , and after the term
* cache has been cleaned .
*
* @ since 2.3 . 0
*
* @ param int $term_id Term ID .
* @ param int $tt_id Term taxonomy ID .
*/
do_action ( " created_ $taxonomy " , $term_id , $tt_id );
2007-09-15 13:35:32 -04:00
return array ( 'term_id' => $term_id , 'term_taxonomy_id' => $tt_id );
}
/**
2008-06-22 16:23:23 -04:00
* Create Term and Taxonomy Relationships .
2008-02-05 01:47:27 -05:00
*
2008-06-22 16:23:23 -04:00
* 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 slug ) .
2007-12-13 19:25:39 -05:00
*
2008-06-22 16:23:23 -04:00
* A relationship means that the term is grouped in or belongs to the taxonomy .
* A term has no meaning until it is given context by defining which taxonomy it
* exists under .
2007-09-15 13:35:32 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2013-02-08 13:45:34 -05:00
* @ uses wp_remove_object_terms ()
2007-10-15 18:49:31 -04:00
*
2007-09-15 13:35:32 -04:00
* @ param int $object_id The object to relate to .
2010-09-07 07:21:11 -04:00
* @ param array | int | string $terms The slug or id of the term , will replace all existing
2009-04-16 18:19:01 -04:00
* related terms in this taxonomy .
2007-09-15 13:35:32 -04:00
* @ param array | string $taxonomy The context in which to relate the term to the object .
* @ param bool $append If false will delete difference of terms .
2007-10-21 13:18:24 -04:00
* @ return array | WP_Error Affected Term IDs
2007-09-15 13:35:32 -04:00
*/
function wp_set_object_terms ( $object_id , $terms , $taxonomy , $append = false ) {
global $wpdb ;
$object_id = ( int ) $object_id ;
2010-06-11 11:53:41 -04:00
if ( ! taxonomy_exists ( $taxonomy ) )
2012-06-01 15:05:30 -04:00
return new WP_Error ( 'invalid_taxonomy' , __ ( 'Invalid taxonomy' ));
2007-09-15 13:35:32 -04:00
if ( ! is_array ( $terms ) )
$terms = array ( $terms );
if ( ! $append )
2009-05-25 14:18:06 -04:00
$old_tt_ids = wp_get_object_terms ( $object_id , $taxonomy , array ( 'fields' => 'tt_ids' , 'orderby' => 'none' ));
2010-02-22 21:37:19 -05:00
else
$old_tt_ids = array ();
2007-09-15 13:35:32 -04:00
$tt_ids = array ();
$term_ids = array ();
2011-10-18 17:01:55 -04:00
$new_tt_ids = array ();
2007-09-15 13:35:32 -04:00
2008-08-06 16:31:54 -04:00
foreach ( ( array ) $terms as $term ) {
2007-12-19 18:25:11 -05:00
if ( ! strlen ( trim ( $term )) )
continue ;
2008-02-05 01:47:27 -05:00
2010-06-11 11:53:41 -04:00
if ( ! $term_info = term_exists ( $term , $taxonomy ) ) {
2010-04-13 10:32:30 -04:00
// Skip if a non-existent term ID is passed.
if ( is_int ( $term ) )
continue ;
2008-10-25 18:56:02 -04:00
$term_info = wp_insert_term ( $term , $taxonomy );
2010-04-13 10:32:30 -04:00
}
2008-10-25 18:56:02 -04:00
if ( is_wp_error ( $term_info ) )
return $term_info ;
$term_ids [] = $term_info [ 'term_id' ];
$tt_id = $term_info [ 'term_taxonomy_id' ];
$tt_ids [] = $tt_id ;
2007-09-15 13:35:32 -04:00
2008-10-25 18:56:02 -04:00
if ( $wpdb -> get_var ( $wpdb -> prepare ( " SELECT term_taxonomy_id FROM $wpdb->term_relationships WHERE object_id = %d AND term_taxonomy_id = %d " , $object_id , $tt_id ) ) )
2007-09-15 13:35:32 -04:00
continue ;
2014-03-28 17:29:13 -04:00
/**
* Fires immediately before an object - term relationship is added .
*
* @ since 2.9 . 0
*
* @ param int $object_id Object ID .
* @ param int $tt_id Term taxonomy ID .
*/
2009-09-17 10:03:57 -04:00
do_action ( 'add_term_relationship' , $object_id , $tt_id );
2008-10-25 18:56:02 -04:00
$wpdb -> insert ( $wpdb -> term_relationships , array ( 'object_id' => $object_id , 'term_taxonomy_id' => $tt_id ) );
2014-03-28 17:29:13 -04:00
/**
* Fires immediately after an object - term relationship is added .
*
* @ since 2.9 . 0
*
* @ param int $object_id Object ID .
* @ param int $tt_id Term taxonomy ID .
*/
2009-09-17 10:03:57 -04:00
do_action ( 'added_term_relationship' , $object_id , $tt_id );
2011-10-18 17:01:55 -04:00
$new_tt_ids [] = $tt_id ;
2007-09-15 13:35:32 -04:00
}
2011-10-18 17:01:55 -04:00
if ( $new_tt_ids )
wp_update_term_count ( $new_tt_ids , $taxonomy );
2007-09-15 13:35:32 -04:00
if ( ! $append ) {
2013-02-08 13:45:34 -05:00
$delete_tt_ids = array_diff ( $old_tt_ids , $tt_ids );
2013-05-20 08:10:58 -04:00
2013-02-08 13:45:34 -05:00
if ( $delete_tt_ids ) {
$in_delete_tt_ids = " ' " . implode ( " ', ' " , $delete_tt_ids ) . " ' " ;
$delete_term_ids = $wpdb -> get_col ( $wpdb -> prepare ( " SELECT tt.term_id FROM $wpdb->term_taxonomy AS tt WHERE tt.taxonomy = %s AND tt.term_taxonomy_id IN ( $in_delete_tt_ids ) " , $taxonomy ) );
$delete_term_ids = array_map ( 'intval' , $delete_term_ids );
2013-05-20 08:10:58 -04:00
2013-02-08 13:45:34 -05:00
$remove = wp_remove_object_terms ( $object_id , $delete_term_ids , $taxonomy );
if ( is_wp_error ( $remove ) ) {
return $remove ;
}
2007-09-15 13:35:32 -04:00
}
}
2008-02-14 12:17:57 -05:00
$t = get_taxonomy ( $taxonomy );
2008-02-22 12:43:56 -05:00
if ( ! $append && isset ( $t -> sort ) && $t -> sort ) {
2008-02-14 12:17:57 -05:00
$values = array ();
$term_order = 0 ;
2009-12-23 10:31:02 -05:00
$final_tt_ids = wp_get_object_terms ( $object_id , $taxonomy , array ( 'fields' => 'tt_ids' ));
2008-05-15 21:43:35 -04:00
foreach ( $tt_ids as $tt_id )
if ( in_array ( $tt_id , $final_tt_ids ) )
$values [] = $wpdb -> prepare ( " (%d, %d, %d) " , $object_id , $tt_id , ++ $term_order );
2008-02-14 12:17:57 -05:00
if ( $values )
2012-09-05 13:57:53 -04:00
if ( false === $wpdb -> query ( " INSERT INTO $wpdb->term_relationships (object_id, term_taxonomy_id, term_order) VALUES " . join ( ',' , $values ) . " ON DUPLICATE KEY UPDATE term_order = VALUES(term_order) " ) )
return new WP_Error ( 'db_insert_error' , __ ( 'Could not insert term relationship into the database' ), $wpdb -> last_error );
2008-02-14 12:17:57 -05:00
}
2012-11-27 14:42:38 -05:00
wp_cache_delete ( $object_id , $taxonomy . '_relationships' );
2014-03-28 17:29:13 -04:00
/**
* Fires after an object ' s terms have been set .
*
* @ since 2.8 . 0
*
* @ param int $object_id Object ID .
* @ param array $terms An array of object terms .
* @ param array $tt_ids An array of term taxonomy IDs .
* @ param string $taxonomy Taxonomy slug .
* @ param bool $append Whether to append new terms to the old terms .
* @ param array $old_tt_ids Old array of term taxonomy IDs .
*/
do_action ( 'set_object_terms' , $object_id , $terms , $tt_ids , $taxonomy , $append , $old_tt_ids );
2007-09-15 13:35:32 -04:00
return $tt_ids ;
}
2013-02-08 13:45:34 -05:00
/**
* Add term ( s ) associated with a given object .
*
2013-12-24 13:57:12 -05:00
* @ since 3.6 . 0
2013-02-08 13:45:34 -05:00
* @ uses wp_set_object_terms ()
*
* @ param int $object_id The ID of the object to which the terms will be added .
* @ param array | int | string $terms The slug ( s ) or ID ( s ) of the term ( s ) to add .
* @ param array | string $taxonomy Taxonomy name .
* @ return array | WP_Error Affected Term IDs
*/
function wp_add_object_terms ( $object_id , $terms , $taxonomy ) {
return wp_set_object_terms ( $object_id , $terms , $taxonomy , true );
}
/**
* Remove term ( s ) associated with a given object .
*
2013-12-24 13:57:12 -05:00
* @ since 3.6 . 0
2013-02-08 13:45:34 -05:00
* @ uses $wpdb
*
* @ param int $object_id The ID of the object from which the terms will be removed .
* @ param array | int | string $terms The slug ( s ) or ID ( s ) of the term ( s ) to remove .
* @ param array | string $taxonomy Taxonomy name .
* @ return bool | WP_Error True on success , false or WP_Error on failure .
*/
function wp_remove_object_terms ( $object_id , $terms , $taxonomy ) {
global $wpdb ;
$object_id = ( int ) $object_id ;
if ( ! taxonomy_exists ( $taxonomy ) ) {
return new WP_Error ( 'invalid_taxonomy' , __ ( 'Invalid Taxonomy' ) );
}
if ( ! is_array ( $terms ) ) {
$terms = array ( $terms );
}
$tt_ids = array ();
2013-05-20 08:10:58 -04:00
2013-02-08 13:45:34 -05:00
foreach ( ( array ) $terms as $term ) {
if ( ! strlen ( trim ( $term ) ) ) {
continue ;
}
2013-05-20 08:10:58 -04:00
2013-02-08 13:45:34 -05:00
if ( ! $term_info = term_exists ( $term , $taxonomy ) ) {
// Skip if a non-existent term ID is passed.
if ( is_int ( $term ) ) {
continue ;
}
}
2013-05-20 08:10:58 -04:00
2013-02-08 13:45:34 -05:00
if ( is_wp_error ( $term_info ) ) {
return $term_info ;
}
2013-05-20 08:10:58 -04:00
2013-02-08 13:45:34 -05:00
$tt_ids [] = $term_info [ 'term_taxonomy_id' ];
}
2013-05-20 08:10:58 -04:00
2013-02-08 13:45:34 -05:00
if ( $tt_ids ) {
$in_tt_ids = " ' " . implode ( " ', ' " , $tt_ids ) . " ' " ;
2014-03-28 17:29:13 -04:00
/**
* Fires immediately before an object - term relationship is deleted .
*
* @ since 2.9 . 0
*
* @ param int $object_id Object ID .
* @ param array $tt_ids An array of term taxonomy IDs .
*/
2013-02-08 13:45:34 -05:00
do_action ( 'delete_term_relationships' , $object_id , $tt_ids );
2013-03-01 11:22:07 -05:00
$deleted = $wpdb -> query ( $wpdb -> prepare ( " DELETE FROM $wpdb->term_relationships WHERE object_id = %d AND term_taxonomy_id IN ( $in_tt_ids ) " , $object_id ) );
2014-03-28 17:29:13 -04:00
/**
* Fires immediately after an object - term relationship is deleted .
*
* @ since 2.9 . 0
*
* @ param int $object_id Object ID .
* @ param array $tt_ids An array of term taxonomy IDs .
*/
2013-02-08 13:45:34 -05:00
do_action ( 'deleted_term_relationships' , $object_id , $tt_ids );
wp_update_term_count ( $tt_ids , $taxonomy );
2013-05-20 08:10:58 -04:00
2013-03-01 11:22:07 -05:00
return ( bool ) $deleted ;
2013-02-08 13:45:34 -05:00
}
return false ;
}
2007-10-15 18:49:31 -04:00
/**
2008-06-22 16:23:23 -04:00
* Will make slug unique , if it isn ' t already .
2008-02-05 01:47:27 -05:00
*
2008-06-22 16:23:23 -04:00
* The $slug has to be unique global to every taxonomy , meaning that one
* taxonomy term can ' t have a matching slug with another taxonomy term . Each
* slug has to be globally unique for every taxonomy .
2007-10-15 18:49:31 -04:00
*
2008-06-22 16:23:23 -04:00
* The way this works is that if the taxonomy that the term belongs to is
2010-01-22 14:30:05 -05:00
* hierarchical and has a parent , it will append that parent to the $slug .
2007-10-15 18:49:31 -04:00
*
2008-06-22 16:23:23 -04:00
* If that still doesn ' t return an unique slug , then it try to append a number
2011-09-05 15:08:15 -04:00
* until it finds a number that is truly unique .
2008-02-05 01:47:27 -05:00
*
2007-10-21 13:18:24 -04:00
* The only purpose for $term is for appending a parent , if one exists .
2007-10-15 18:49:31 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
* @ uses $wpdb
2007-10-15 18:49:31 -04:00
*
* @ param string $slug The string that will be tried for a unique slug
* @ param object $term The term object that the $slug will belong too
* @ return string Will return a true unique slug .
*/
2007-09-22 14:01:08 -04:00
function wp_unique_term_slug ( $slug , $term ) {
global $wpdb ;
2010-06-11 11:53:41 -04:00
if ( ! term_exists ( $slug ) )
2010-03-27 03:56:54 -04:00
return $slug ;
2007-09-22 14:01:08 -04:00
// If the taxonomy supports hierarchy and the term has a parent, make the slug unique
// by incorporating parent slugs.
if ( is_taxonomy_hierarchical ( $term -> taxonomy ) && ! empty ( $term -> parent ) ) {
$the_parent = $term -> parent ;
while ( ! empty ( $the_parent ) ) {
$parent_term = get_term ( $the_parent , $term -> taxonomy );
if ( is_wp_error ( $parent_term ) || empty ( $parent_term ) )
break ;
2010-04-25 11:25:00 -04:00
$slug .= '-' . $parent_term -> slug ;
2010-06-11 11:53:41 -04:00
if ( ! term_exists ( $slug ) )
2010-04-25 11:25:00 -04:00
return $slug ;
2007-09-22 14:01:08 -04:00
if ( empty ( $parent_term -> parent ) )
break ;
$the_parent = $parent_term -> parent ;
}
}
// If we didn't get a unique slug, try appending a number to make it unique.
2013-08-23 17:05:09 -04:00
if ( ! empty ( $term -> term_id ) )
$query = $wpdb -> prepare ( " SELECT slug FROM $wpdb->terms WHERE slug = %s AND term_id != %d " , $slug , $term -> term_id );
2007-11-09 13:34:41 -05:00
else
2007-12-06 14:49:33 -05:00
$query = $wpdb -> prepare ( " SELECT slug FROM $wpdb->terms WHERE slug = %s " , $slug );
2007-11-09 13:34:41 -05:00
if ( $wpdb -> get_var ( $query ) ) {
2007-09-22 14:01:08 -04:00
$num = 2 ;
do {
$alt_slug = $slug . " - $num " ;
$num ++ ;
2007-10-12 23:51:11 -04:00
$slug_check = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT slug FROM $wpdb->terms WHERE slug = %s " , $alt_slug ) );
2007-09-22 14:01:08 -04:00
} while ( $slug_check );
$slug = $alt_slug ;
}
return $slug ;
}
2007-10-15 18:49:31 -04:00
/**
2008-06-22 16:23:23 -04:00
* Update term based on arguments provided .
2007-12-13 19:25:39 -05:00
*
2008-06-22 16:23:23 -04:00
* The $args will indiscriminately override all values with the same field name .
* Care must be taken to not override important information need to update or
* update will fail ( or perhaps create a new term , neither would be acceptable ) .
2007-12-13 19:25:39 -05:00
*
2008-06-22 16:23:23 -04:00
* Defaults will set 'alias_of' , 'description' , 'parent' , and 'slug' if not
* defined in $args already .
2007-12-13 19:25:39 -05:00
*
2008-06-22 16:23:23 -04:00
* 'alias_of' will create a term group , if it doesn ' t already exist , and update
* it for the $term .
2007-12-13 19:25:39 -05:00
*
2008-06-22 16:23:23 -04:00
* If the 'slug' argument in $args is missing , then the 'name' in $args will be
* used . It should also be noted that if you set 'slug' and it isn ' t unique then
* a WP_Error will be passed back . If you don ' t pass any slug , then a unique one
* will be created for you .
2007-10-21 13:18:24 -04:00
*
2008-06-22 16:23:23 -04:00
* For what can be overrode in $args , check the term scheme can contain and stay
* away from the term keys .
2007-10-15 18:49:31 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-12-13 19:25:39 -05:00
*
2007-10-21 13:18:24 -04:00
* @ uses $wpdb
2007-10-15 18:49:31 -04:00
*
2009-04-23 04:05:36 -04:00
* @ param int $term_id The ID of the term
2007-10-15 18:49:31 -04:00
* @ param string $taxonomy The context in which to relate the term to the object .
2007-12-13 19:25:39 -05:00
* @ param array | string $args Overwrite term field values
* @ return array | WP_Error Returns Term ID and Taxonomy Term ID
2007-10-15 18:49:31 -04:00
*/
2009-04-23 04:05:36 -04:00
function wp_update_term ( $term_id , $taxonomy , $args = array () ) {
2007-09-15 13:35:32 -04:00
global $wpdb ;
2010-06-11 11:53:41 -04:00
if ( ! taxonomy_exists ( $taxonomy ) )
2007-09-15 13:35:32 -04:00
return new WP_Error ( 'invalid_taxonomy' , __ ( 'Invalid taxonomy' ));
2009-04-23 04:05:36 -04:00
$term_id = ( int ) $term_id ;
2007-09-15 13:35:32 -04:00
// First, get all of the original args
$term = get_term ( $term_id , $taxonomy , ARRAY_A );
2009-03-17 12:42:21 -04:00
if ( is_wp_error ( $term ) )
return $term ;
2013-03-01 11:28:40 -05:00
// Escape data pulled from DB.
2013-03-03 16:11:40 -05:00
$term = wp_slash ( $term );
2013-03-01 11:28:40 -05:00
2007-09-15 13:35:32 -04:00
// Merge old and new args with new args overwriting old ones.
$args = array_merge ( $term , $args );
$defaults = array ( 'alias_of' => '' , 'description' => '' , 'parent' => 0 , 'slug' => '' );
$args = wp_parse_args ( $args , $defaults );
$args = sanitize_term ( $args , $taxonomy , 'db' );
extract ( $args , EXTR_SKIP );
2013-03-01 11:28:40 -05:00
// expected_slashed ($name)
2013-03-03 16:11:40 -05:00
$name = wp_unslash ( $name );
$description = wp_unslash ( $description );
2013-03-01 11:28:40 -05:00
2008-07-21 17:53:32 -04:00
if ( '' == trim ( $name ) )
return new WP_Error ( 'empty_term_name' , __ ( 'A name is required for this term' ));
2007-09-22 14:01:08 -04:00
$empty_slug = false ;
if ( empty ( $slug ) ) {
$empty_slug = true ;
2007-09-15 13:35:32 -04:00
$slug = sanitize_title ( $name );
2007-09-22 14:01:08 -04:00
}
2007-09-15 13:35:32 -04:00
if ( $alias_of ) {
2007-10-23 12:36:08 -04:00
$alias = $wpdb -> get_row ( $wpdb -> prepare ( " SELECT term_id, term_group FROM $wpdb->terms WHERE slug = %s " , $alias_of ) );
2007-09-15 13:35:32 -04:00
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.
2007-10-23 12:43:15 -04:00
$term_group = $wpdb -> get_var ( " SELECT MAX(term_group) FROM $wpdb->terms " ) + 1 ;
2014-03-28 17:29:13 -04:00
/** This action is documented in wp-includes/taxonomy.php */
2013-07-28 18:15:03 -04:00
do_action ( 'edit_terms' , $alias -> term_id , $taxonomy );
2007-10-12 23:51:11 -04:00
$wpdb -> update ( $wpdb -> terms , compact ( 'term_group' ), array ( 'term_id' => $alias -> term_id ) );
2014-03-28 17:29:13 -04:00
/** This action is documented in wp-includes/taxonomy.php */
2013-07-28 18:15:03 -04:00
do_action ( 'edited_terms' , $alias -> term_id , $taxonomy );
2007-09-15 13:35:32 -04:00
}
}
2014-03-28 17:29:13 -04:00
/**
* Filter the term parent .
*
* Hook to this filter to see if it will cause a hierarchy loop .
*
* @ since 3.1 . 0
*
* @ param int $parent ID of the parent term .
* @ param int $term_id Term ID .
* @ param string $taxonomy Taxonomy slug .
* @ param array $args Compacted array of update arguments for the given term .
* @ param array $args An array of update arguments for the given term .
*/
2010-10-14 11:09:04 -04:00
$parent = apply_filters ( 'wp_update_term_parent' , $parent , $term_id , $taxonomy , compact ( array_keys ( $args ) ), $args );
2007-09-22 14:01:08 -04:00
// Check for duplicate slug
2007-10-12 23:51:11 -04:00
$id = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT term_id FROM $wpdb->terms WHERE slug = %s " , $slug ) );
2007-09-22 14:01:08 -04:00
if ( $id && ( $id != $term_id ) ) {
2007-11-09 13:34:41 -05:00
// If an empty slug was passed or the parent changed, reset the slug to something unique.
2007-09-22 14:01:08 -04:00
// Otherwise, bail.
2010-02-07 01:51:05 -05:00
if ( $empty_slug || ( $parent != $term [ 'parent' ]) )
2007-09-22 14:01:08 -04:00
$slug = wp_unique_term_slug ( $slug , ( object ) $args );
else
2009-05-05 00:28:05 -04:00
return new WP_Error ( 'duplicate_term_slug' , sprintf ( __ ( 'The slug “%s” is already in use by another term' ), $slug ));
2007-09-22 14:01:08 -04:00
}
2014-03-28 17:29:13 -04:00
/** This action is documented in wp-includes/taxonomy.php */
2013-07-28 18:15:03 -04:00
do_action ( 'edit_terms' , $term_id , $taxonomy );
2007-10-12 23:51:11 -04:00
$wpdb -> update ( $wpdb -> terms , compact ( 'name' , 'slug' , 'term_group' ), compact ( 'term_id' ) );
2007-09-15 13:35:32 -04:00
if ( empty ( $slug ) ) {
$slug = sanitize_title ( $name , $term_id );
2007-10-12 23:51:11 -04:00
$wpdb -> update ( $wpdb -> terms , compact ( 'slug' ), compact ( 'term_id' ) );
2007-09-15 13:35:32 -04:00
}
2014-03-28 17:29:13 -04:00
/** This action is documented in wp-includes/taxonomy.php */
2013-07-28 18:15:03 -04:00
do_action ( 'edited_terms' , $term_id , $taxonomy );
2007-09-15 13:35:32 -04:00
2007-10-12 23:51:11 -04:00
$tt_id = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT tt.term_taxonomy_id FROM $wpdb->term_taxonomy AS tt INNER JOIN $wpdb->terms AS t ON tt.term_id = t.term_id WHERE tt.taxonomy = %s AND t.term_id = %d " , $taxonomy , $term_id ) );
2014-03-28 17:29:13 -04:00
/**
* Fires immediate before a term - taxonomy relationship is updated .
*
* @ since 2.9 . 0
*
* @ param int $tt_id Term taxonomy ID .
* @ param string $taxonomy Taxonomy slug .
*/
2010-03-09 05:48:18 -05:00
do_action ( 'edit_term_taxonomy' , $tt_id , $taxonomy );
2007-10-15 16:07:29 -04:00
$wpdb -> update ( $wpdb -> term_taxonomy , compact ( 'term_id' , 'taxonomy' , 'description' , 'parent' ), array ( 'term_taxonomy_id' => $tt_id ) );
2014-03-28 17:29:13 -04:00
/**
* Fires immediately after a term - taxonomy relationship is updated .
*
* @ since 2.9 . 0
*
* @ param int $tt_id Term taxonomy ID .
* @ param string $taxonomy Taxonomy slug .
*/
2010-03-09 05:53:02 -05:00
do_action ( 'edited_term_taxonomy' , $tt_id , $taxonomy );
2009-09-24 13:19:13 -04:00
2014-02-11 11:50:13 -05:00
// Clean the relationship caches for all object types using this term
$objects = $wpdb -> get_col ( $wpdb -> prepare ( " SELECT object_id FROM $wpdb->term_relationships WHERE term_taxonomy_id = %d " , $tt_id ) );
$tax_object = get_taxonomy ( $taxonomy );
2014-03-28 17:29:13 -04:00
foreach ( $tax_object -> object_type as $object_type ) {
2014-02-11 11:50:13 -05:00
clean_object_term_cache ( $objects , $object_type );
2014-03-28 17:29:13 -04:00
}
2014-02-11 11:50:13 -05:00
2014-03-28 17:29:13 -04:00
/**
* Fires after a term has been updated , but before the term cache has been cleaned .
*
* @ since 2.3 . 0
*
* @ param int $term_id Term ID .
* @ param int $tt_id Term taxonomy ID .
* @ param string $taxonomy Taxonomy slug .
*/
do_action ( " edit_term " , $term_id , $tt_id , $taxonomy );
2007-09-15 13:35:32 -04:00
2014-03-28 17:29:13 -04:00
/**
* Fires after a term in a specific taxonomy has been updated , but before the term
* cache has been cleaned .
*
* The dynamic portion of the hook name , $taxonomy , refers to the taxonomy slug .
*
* @ since 2.3 . 0
*
* @ param int $term_id Term ID .
* @ param int $tt_id Term taxonomy ID .
*/
do_action ( " edit_ $taxonomy " , $term_id , $tt_id );
/** This filter is documented in wp-includes/taxonomy.php */
$term_id = apply_filters ( 'term_id_filter' , $term_id , $tt_id );
2007-09-15 13:35:32 -04:00
clean_term_cache ( $term_id , $taxonomy );
2014-03-28 17:29:13 -04:00
/**
* Fires after a term has been updated , and the term cache has been cleaned .
*
* @ since 2.3 . 0
*
* @ param int $term_id Term ID .
* @ param int $tt_id Term taxonomy ID .
* @ param string $taxonomy Taxonomy slug .
*/
do_action ( " edited_term " , $term_id , $tt_id , $taxonomy );
/**
* Fires after a term for a specific taxonomy has been updated , and the term
* cache has been cleaned .
*
* The dynamic portion of the hook name , $taxonomy , refers to the taxonomy slug .
*
* @ since 2.3 . 0
*
* @ param int $term_id Term ID .
* @ param int $tt_id Term taxonomy ID .
*/
do_action ( " edited_ $taxonomy " , $term_id , $tt_id );
2007-09-15 13:35:32 -04:00
return array ( 'term_id' => $term_id , 'term_taxonomy_id' => $tt_id );
}
2008-06-22 16:23:23 -04:00
/**
* Enable or disable term counting .
*
2008-08-30 17:23:43 -04:00
* @ since 2.5 . 0
2008-06-22 16:23:23 -04:00
*
2008-08-30 17:23:43 -04:00
* @ param bool $defer Optional . Enable if true , disable if false .
* @ return bool Whether term counting is enabled or disabled .
2008-06-22 16:23:23 -04:00
*/
2008-08-30 17:23:43 -04:00
function wp_defer_term_counting ( $defer = null ) {
2007-12-12 00:14:00 -05:00
static $_defer = false ;
2008-02-05 01:47:27 -05:00
2007-12-12 00:14:00 -05:00
if ( is_bool ( $defer ) ) {
$_defer = $defer ;
// flush any deferred counts
if ( ! $defer )
2008-08-30 17:23:43 -04:00
wp_update_term_count ( null , null , true );
2007-12-12 00:14:00 -05:00
}
2008-02-05 01:47:27 -05:00
2007-12-12 00:14:00 -05:00
return $_defer ;
}
2007-10-15 18:49:31 -04:00
/**
2008-06-22 16:23:23 -04:00
* Updates the amount of terms in taxonomy .
2008-02-05 01:47:27 -05:00
*
2011-09-05 15:08:15 -04:00
* If there is a taxonomy callback applied , then it will be called for updating
2008-06-22 16:23:23 -04:00
* the count .
2007-10-15 18:49:31 -04:00
*
2008-06-22 16:23:23 -04:00
* The default action is to count what the amount of terms have the relationship
* of term ID . Once that is done , then update the database .
2007-10-15 18:49:31 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
* @ uses $wpdb
2007-10-15 18:49:31 -04:00
*
2008-10-29 02:54:53 -04:00
* @ param int | array $terms The term_taxonomy_id of the terms
2007-10-15 18:49:31 -04:00
* @ param string $taxonomy The context of the term .
* @ return bool If no terms will return false , and if successful will return true .
*/
2007-12-12 00:14:00 -05:00
function wp_update_term_count ( $terms , $taxonomy , $do_deferred = false ) {
static $_deferred = array ();
if ( $do_deferred ) {
2008-08-06 16:31:54 -04:00
foreach ( ( array ) array_keys ( $_deferred ) as $tax ) {
2007-12-12 00:14:00 -05:00
wp_update_term_count_now ( $_deferred [ $tax ], $tax );
unset ( $_deferred [ $tax ] );
}
}
2007-09-15 13:35:32 -04:00
if ( empty ( $terms ) )
return false ;
if ( ! is_array ( $terms ) )
$terms = array ( $terms );
2007-12-12 00:14:00 -05:00
if ( wp_defer_term_counting () ) {
if ( ! isset ( $_deferred [ $taxonomy ]) )
$_deferred [ $taxonomy ] = array ();
$_deferred [ $taxonomy ] = array_unique ( array_merge ( $_deferred [ $taxonomy ], $terms ) );
return true ;
}
2008-02-05 01:47:27 -05:00
2007-12-12 00:14:00 -05:00
return wp_update_term_count_now ( $terms , $taxonomy );
}
2008-06-22 16:23:23 -04:00
/**
* Perform term count update immediately .
*
2008-08-30 17:23:43 -04:00
* @ since 2.5 . 0
2008-06-22 16:23:23 -04:00
*
2008-10-29 02:54:53 -04:00
* @ param array $terms The term_taxonomy_id of terms to update .
2008-06-22 16:23:23 -04:00
* @ param string $taxonomy The context of the term .
* @ return bool Always true when complete .
*/
2007-12-12 00:14:00 -05:00
function wp_update_term_count_now ( $terms , $taxonomy ) {
global $wpdb ;
2007-09-15 13:35:32 -04:00
$terms = array_map ( 'intval' , $terms );
$taxonomy = get_taxonomy ( $taxonomy );
if ( ! empty ( $taxonomy -> update_count_callback ) ) {
2010-03-09 05:48:18 -05:00
call_user_func ( $taxonomy -> update_count_callback , $terms , $taxonomy );
2007-09-15 13:35:32 -04:00
} else {
2011-10-21 17:38:14 -04:00
$object_types = ( array ) $taxonomy -> object_type ;
foreach ( $object_types as & $object_type ) {
if ( 0 === strpos ( $object_type , 'attachment:' ) )
list ( $object_type ) = explode ( ':' , $object_type );
}
if ( $object_types == array_filter ( $object_types , 'post_type_exists' ) ) {
// Only post types are attached to this taxonomy
_update_post_term_count ( $terms , $taxonomy );
} else {
// Default count updater
_update_generic_term_count ( $terms , $taxonomy );
}
2007-09-15 13:35:32 -04:00
}
2010-01-27 14:42:23 -05:00
clean_term_cache ( $terms , '' , false );
2007-09-15 13:35:32 -04:00
return true ;
}
//
// Cache
//
2007-10-15 18:49:31 -04:00
/**
2008-06-22 16:23:23 -04:00
* Removes the taxonomy relationship to terms from the cache .
2007-10-21 13:18:24 -04:00
*
2008-06-22 16:23:23 -04:00
* Will remove the entire taxonomy relationship containing term $object_id . The
* term IDs have to exist within the taxonomy $object_type for the deletion to
* take place .
2007-10-15 18:49:31 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
*
* @ see get_object_taxonomies () for more on $object_type
2007-10-15 18:49:31 -04:00
*
2007-12-13 19:25:39 -05:00
* @ param int | array $object_ids Single or list of term object ID ( s )
2008-03-24 18:43:20 -04:00
* @ param array | string $object_type The taxonomy object type
2007-10-15 18:49:31 -04:00
*/
2007-09-15 13:35:32 -04:00
function clean_object_term_cache ( $object_ids , $object_type ) {
if ( ! is_array ( $object_ids ) )
$object_ids = array ( $object_ids );
2012-09-22 11:21:30 -04:00
$taxonomies = get_object_taxonomies ( $object_type );
2014-02-05 20:41:12 -05:00
foreach ( $object_ids as $id ) {
foreach ( $taxonomies as $taxonomy ) {
2007-10-24 13:07:04 -04:00
wp_cache_delete ( $id , " { $taxonomy } _relationships " );
2014-02-05 20:41:12 -05:00
}
}
2007-10-14 00:55:33 -04:00
2014-03-28 17:29:13 -04:00
/**
* Fires after the object term cache has been cleaned .
*
* @ since 2.5 . 0
*
* @ param array $object_ids An array of object IDs .
* @ param string $objet_type Object type .
*/
do_action ( 'clean_object_term_cache' , $object_ids , $object_type );
2007-09-15 13:35:32 -04:00
}
2007-10-15 18:49:31 -04:00
/**
2008-06-22 16:23:23 -04:00
* Will remove all of the term ids from the cache .
2007-10-15 18:49:31 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
* @ uses $wpdb
2007-10-15 18:49:31 -04:00
*
2007-12-13 19:25:39 -05:00
* @ param int | array $ids Single or list of Term IDs
2007-10-15 18:49:31 -04:00
* @ param string $taxonomy Can be empty and will assume tt_ids , else will use for context .
2010-01-27 14:42:23 -05:00
* @ param bool $clean_taxonomy Whether to clean taxonomy wide caches ( true ), or just individual term object caches ( false ) . Default is true .
2007-10-15 18:49:31 -04:00
*/
2010-01-27 14:42:23 -05:00
function clean_term_cache ( $ids , $taxonomy = '' , $clean_taxonomy = true ) {
2007-09-15 13:35:32 -04:00
global $wpdb ;
if ( ! is_array ( $ids ) )
$ids = array ( $ids );
$taxonomies = array ();
// If no taxonomy, assume tt_ids.
if ( empty ( $taxonomy ) ) {
2009-12-23 09:37:21 -05:00
$tt_ids = array_map ( 'intval' , $ids );
$tt_ids = implode ( ', ' , $tt_ids );
2007-09-15 13:35:32 -04:00
$terms = $wpdb -> get_results ( " SELECT term_id, taxonomy FROM $wpdb->term_taxonomy WHERE term_taxonomy_id IN ( $tt_ids ) " );
2009-12-23 09:37:21 -05:00
$ids = array ();
2007-09-15 13:35:32 -04:00
foreach ( ( array ) $terms as $term ) {
$taxonomies [] = $term -> taxonomy ;
2009-12-23 09:37:21 -05:00
$ids [] = $term -> term_id ;
2007-09-15 13:35:32 -04:00
wp_cache_delete ( $term -> term_id , $term -> taxonomy );
}
$taxonomies = array_unique ( $taxonomies );
} else {
$taxonomies = array ( $taxonomy );
2009-12-23 09:37:21 -05:00
foreach ( $taxonomies as $taxonomy ) {
foreach ( $ids as $id ) {
wp_cache_delete ( $id , $taxonomy );
}
}
2007-09-15 13:35:32 -04:00
}
foreach ( $taxonomies as $taxonomy ) {
2010-01-27 14:42:23 -05:00
if ( $clean_taxonomy ) {
wp_cache_delete ( 'all_ids' , $taxonomy );
wp_cache_delete ( 'get' , $taxonomy );
delete_option ( " { $taxonomy } _children " );
// Regenerate {$taxonomy}_children
_get_term_hierarchy ( $taxonomy );
}
2014-03-28 17:29:13 -04:00
/**
* Fires once after each taxonomy ' s term cache has been cleaned .
*
* @ since 2.5 . 0
*
* @ param array $ids An array of term IDs .
* @ param string $taxonomy Taxonomy slug .
*/
do_action ( 'clean_term_cache' , $ids , $taxonomy );
2007-09-15 13:35:32 -04:00
}
2014-02-26 17:05:13 -05:00
wp_cache_set ( 'last_changed' , microtime (), 'terms' );
2007-09-15 13:35:32 -04:00
}
2007-10-21 13:18:24 -04:00
/**
2008-06-22 16:23:23 -04:00
* Retrieves the taxonomy relationship to the term object id .
2007-10-21 13:18:24 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
*
2007-12-13 19:25:39 -05:00
* @ uses wp_cache_get () Retrieves taxonomy relationship from cache
*
* @ param int | array $id Term object ID
* @ param string $taxonomy Taxonomy Name
2007-10-21 13:18:24 -04:00
* @ return bool | array Empty array if $terms found , but not $taxonomy . False if nothing is in cache for $taxonomy and $id .
*/
2012-09-10 13:00:11 -04:00
function get_object_term_cache ( $id , $taxonomy ) {
2008-01-10 15:51:07 -05:00
$cache = wp_cache_get ( $id , " { $taxonomy } _relationships " );
return $cache ;
2007-09-15 13:35:32 -04:00
}
2007-10-21 13:18:24 -04:00
/**
2008-06-22 16:23:23 -04:00
* Updates the cache for Term ID ( s ) .
2007-12-13 19:25:39 -05:00
*
* Will only update the cache for terms not already cached .
*
2008-06-22 16:23:23 -04:00
* The $object_ids expects that the ids be separated by commas , if it is a
* string .
2007-10-21 13:18:24 -04:00
*
2008-06-22 16:23:23 -04:00
* It should be noted that update_object_term_cache () is very time extensive . It
* is advised that the function is not called very often or at least not for a
* lot of terms that exist in a lot of taxonomies . The amount of time increases
* for each term and it also increases for each taxonomy the term belongs to .
2007-10-21 13:18:24 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-12-13 19:25:39 -05:00
* @ uses wp_get_object_terms () Used to get terms from the database to update
2007-10-21 13:18:24 -04:00
*
2007-12-13 19:25:39 -05:00
* @ param string | array $object_ids Single or list of term object ID ( s )
2008-03-24 18:43:20 -04:00
* @ param array | string $object_type The taxonomy object type
2008-02-05 01:47:27 -05:00
* @ return null | bool Null value is given with empty $object_ids . False if
2007-10-21 13:18:24 -04:00
*/
2007-09-15 13:35:32 -04:00
function update_object_term_cache ( $object_ids , $object_type ) {
if ( empty ( $object_ids ) )
return ;
if ( ! is_array ( $object_ids ) )
$object_ids = explode ( ',' , $object_ids );
2007-10-13 14:23:59 -04:00
$object_ids = array_map ( 'intval' , $object_ids );
2007-09-15 13:35:32 -04:00
2007-10-23 16:33:50 -04:00
$taxonomies = get_object_taxonomies ( $object_type );
2007-10-13 14:23:59 -04:00
$ids = array ();
foreach ( ( array ) $object_ids as $id ) {
2007-10-23 16:33:50 -04:00
foreach ( $taxonomies as $taxonomy ) {
if ( false === wp_cache_get ( $id , " { $taxonomy } _relationships " ) ) {
$ids [] = $id ;
break ;
}
}
2007-10-13 14:23:59 -04:00
}
2007-09-15 13:35:32 -04:00
2007-10-13 14:23:59 -04:00
if ( empty ( $ids ) )
return false ;
2007-09-15 13:35:32 -04:00
2009-12-23 10:31:02 -05:00
$terms = wp_get_object_terms ( $ids , $taxonomies , array ( 'fields' => 'all_with_object_id' ));
2007-09-15 13:35:32 -04:00
2007-10-13 14:23:59 -04:00
$object_terms = array ();
foreach ( ( array ) $terms as $term )
$object_terms [ $term -> object_id ][ $term -> taxonomy ][ $term -> term_id ] = $term ;
2007-09-15 13:35:32 -04:00
2007-10-13 14:23:59 -04:00
foreach ( $ids as $id ) {
2012-01-11 16:26:18 -05:00
foreach ( $taxonomies as $taxonomy ) {
2007-10-23 16:33:50 -04:00
if ( ! isset ( $object_terms [ $id ][ $taxonomy ]) ) {
if ( ! isset ( $object_terms [ $id ]) )
$object_terms [ $id ] = array ();
$object_terms [ $id ][ $taxonomy ] = array ();
}
}
2007-09-15 13:35:32 -04:00
}
2007-10-13 14:23:59 -04:00
2007-10-23 16:33:50 -04:00
foreach ( $object_terms as $id => $value ) {
foreach ( $value as $taxonomy => $terms ) {
2012-01-11 16:26:18 -05:00
wp_cache_add ( $id , $terms , " { $taxonomy } _relationships " );
2007-10-23 16:33:50 -04:00
}
}
2007-09-15 13:35:32 -04:00
}
2007-10-21 13:18:24 -04:00
/**
2008-06-22 16:23:23 -04:00
* Updates Terms to Taxonomy in cache .
2007-10-21 13:18:24 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
*
* @ param array $terms List of Term objects to change
* @ param string $taxonomy Optional . Update Term to this taxonomy in cache
*/
2007-09-15 13:35:32 -04:00
function update_term_cache ( $terms , $taxonomy = '' ) {
2008-08-06 16:31:54 -04:00
foreach ( ( array ) $terms as $term ) {
2007-09-15 13:35:32 -04:00
$term_taxonomy = $taxonomy ;
if ( empty ( $term_taxonomy ) )
$term_taxonomy = $term -> taxonomy ;
wp_cache_add ( $term -> term_id , $term , $term_taxonomy );
}
}
//
// Private
//
2007-10-21 13:18:24 -04:00
/**
2009-04-28 15:49:21 -04:00
* Retrieves children of taxonomy as Term IDs .
2007-10-21 13:18:24 -04:00
*
* @ access private
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
*
2008-06-22 16:23:23 -04:00
* @ uses update_option () Stores all of the children in " $taxonomy_children "
* option . That is the name of the taxonomy , immediately followed by '_children' .
2007-12-13 19:25:39 -05:00
*
* @ param string $taxonomy Taxonomy Name
2010-04-01 10:37:38 -04:00
* @ return array Empty if $taxonomy isn ' t hierarchical or returns children as Term IDs .
2007-10-21 13:18:24 -04:00
*/
2007-09-15 13:35:32 -04:00
function _get_term_hierarchy ( $taxonomy ) {
if ( ! is_taxonomy_hierarchical ( $taxonomy ) )
return array ();
2014-02-11 11:50:13 -05:00
$children = get_option ( " { $taxonomy } _children " );
2010-01-27 14:42:23 -05:00
2007-09-15 13:35:32 -04:00
if ( is_array ( $children ) )
return $children ;
$children = array ();
2010-01-15 12:40:37 -05:00
$terms = get_terms ( $taxonomy , array ( 'get' => 'all' , 'orderby' => 'id' , 'fields' => 'id=>parent' ));
foreach ( $terms as $term_id => $parent ) {
if ( $parent > 0 )
$children [ $parent ][] = $term_id ;
2007-09-15 13:35:32 -04:00
}
2010-01-27 14:42:23 -05:00
update_option ( " { $taxonomy } _children " , $children );
2007-09-15 13:35:32 -04:00
return $children ;
}
2007-10-15 18:49:31 -04:00
/**
2008-11-12 19:20:12 -05:00
* Get the subset of $terms that are descendants of $term_id .
2008-02-05 01:47:27 -05:00
*
2008-11-12 19:20:12 -05:00
* If $terms is an array of objects , then _get_term_children returns an array of objects .
* If $terms is an array of IDs , then _get_term_children returns an array of IDs .
2007-10-15 18:49:31 -04:00
*
2007-10-21 13:18:24 -04:00
* @ access private
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-15 18:49:31 -04:00
*
2008-11-12 19:20:12 -05:00
* @ param int $term_id The ancestor term : all returned terms should be descendants of $term_id .
* @ param array $terms The set of terms --- either an array of term objects or term IDs --- from which those that are descendants of $term_id will be chosen .
* @ param string $taxonomy The taxonomy which determines the hierarchy of the terms .
2008-12-09 13:03:31 -05:00
* @ return array The subset of $terms that are descendants of $term_id .
2007-10-15 18:49:31 -04:00
*/
2012-09-10 13:00:11 -04:00
function _get_term_children ( $term_id , $terms , $taxonomy ) {
2008-01-10 15:51:07 -05:00
$empty_array = array ();
2007-09-15 13:35:32 -04:00
if ( empty ( $terms ) )
2008-01-10 15:51:07 -05:00
return $empty_array ;
2007-09-15 13:35:32 -04:00
$term_list = array ();
$has_children = _get_term_hierarchy ( $taxonomy );
if ( ( 0 != $term_id ) && ! isset ( $has_children [ $term_id ]) )
2008-01-10 15:51:07 -05:00
return $empty_array ;
2007-09-15 13:35:32 -04:00
2008-08-06 16:31:54 -04:00
foreach ( ( array ) $terms as $term ) {
2007-09-15 13:35:32 -04:00
$use_id = false ;
if ( ! is_object ( $term ) ) {
$term = get_term ( $term , $taxonomy );
2007-09-18 12:32:22 -04:00
if ( is_wp_error ( $term ) )
return $term ;
2007-09-15 13:35:32 -04:00
$use_id = true ;
}
2014-02-06 12:45:12 -05:00
if ( $term -> term_id == $term_id ) {
2007-09-15 13:35:32 -04:00
continue ;
2014-02-06 12:45:12 -05:00
}
2007-09-15 13:35:32 -04:00
if ( $term -> parent == $term_id ) {
if ( $use_id )
$term_list [] = $term -> term_id ;
else
$term_list [] = $term ;
if ( ! isset ( $has_children [ $term -> term_id ]) )
continue ;
if ( $children = _get_term_children ( $term -> term_id , $terms , $taxonomy ) )
$term_list = array_merge ( $term_list , $children );
}
}
return $term_list ;
}
2007-10-15 18:49:31 -04:00
/**
2008-06-22 16:23:23 -04:00
* Add count of children to parent count .
2008-02-05 01:47:27 -05:00
*
2008-06-22 16:23:23 -04:00
* Recalculates term counts by including items from child terms . Assumes all
* relevant children are already in the $terms argument .
2007-10-15 18:49:31 -04:00
*
2007-10-21 13:18:24 -04:00
* @ access private
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
* @ uses $wpdb
2007-10-15 18:49:31 -04:00
*
* @ param array $terms List of Term IDs
* @ param string $taxonomy Term Context
2007-10-21 13:18:24 -04:00
* @ return null Will break from function if conditions are not met .
2007-10-15 18:49:31 -04:00
*/
2007-09-15 13:35:32 -04:00
function _pad_term_counts ( & $terms , $taxonomy ) {
2007-09-22 20:35:59 -04:00
global $wpdb ;
2010-06-02 11:00:09 -04:00
2009-05-11 01:01:12 -04:00
// This function only works for hierarchical taxonomies like post categories.
if ( ! is_taxonomy_hierarchical ( $taxonomy ) )
2007-09-22 20:35:59 -04:00
return ;
2007-09-15 13:35:32 -04:00
$term_hier = _get_term_hierarchy ( $taxonomy );
if ( empty ( $term_hier ) )
return ;
2007-09-22 20:35:59 -04:00
$term_items = array ();
2008-08-06 16:31:54 -04:00
foreach ( ( array ) $terms as $key => $term ) {
2007-09-22 20:35:59 -04:00
$terms_by_id [ $term -> term_id ] = & $terms [ $key ];
$term_ids [ $term -> term_taxonomy_id ] = $term -> term_id ;
}
// Get the object and term ids and stick them in a lookup table
2010-06-02 10:55:33 -04:00
$tax_obj = get_taxonomy ( $taxonomy );
$object_types = esc_sql ( $tax_obj -> object_type );
2010-06-02 16:04:07 -04:00
$results = $wpdb -> get_results ( " SELECT object_id, term_taxonomy_id FROM $wpdb->term_relationships INNER JOIN $wpdb->posts ON object_id = ID WHERE term_taxonomy_id IN ( " . implode ( ',' , array_keys ( $term_ids )) . " ) AND post_type IN (' " . implode ( " ', ' " , $object_types ) . " ') AND post_status = 'publish' " );
2007-09-22 20:35:59 -04:00
foreach ( $results as $row ) {
$id = $term_ids [ $row -> term_taxonomy_id ];
2008-11-10 18:03:34 -05:00
$term_items [ $id ][ $row -> object_id ] = isset ( $term_items [ $id ][ $row -> object_id ]) ? ++ $term_items [ $id ][ $row -> object_id ] : 1 ;
2007-09-22 20:35:59 -04:00
}
2008-12-09 13:03:31 -05:00
2007-09-22 20:35:59 -04:00
// Touch every ancestor's lookup row for each post in each term
foreach ( $term_ids as $term_id ) {
$child = $term_id ;
2011-10-28 15:52:14 -04:00
while ( ! empty ( $terms_by_id [ $child ] ) && $parent = $terms_by_id [ $child ] -> parent ) {
if ( ! empty ( $term_items [ $term_id ] ) )
2008-11-10 18:03:34 -05:00
foreach ( $term_items [ $term_id ] as $item_id => $touches ) {
$term_items [ $parent ][ $item_id ] = isset ( $term_items [ $parent ][ $item_id ]) ? ++ $term_items [ $parent ][ $item_id ] : 1 ;
}
2007-09-22 20:35:59 -04:00
$child = $parent ;
2007-09-15 13:35:32 -04:00
}
}
2007-09-22 20:35:59 -04:00
2008-02-05 01:47:27 -05:00
// Transfer the touched cells
2007-09-22 20:35:59 -04:00
foreach ( ( array ) $term_items as $id => $items )
if ( isset ( $terms_by_id [ $id ]) )
$terms_by_id [ $id ] -> count = count ( $items );
2007-09-15 13:35:32 -04:00
}
//
// Default callbacks
//
2007-10-15 18:49:31 -04:00
/**
2010-03-09 05:48:18 -05:00
* Will update term count based on object types of the current taxonomy .
2008-02-05 01:47:27 -05:00
*
2008-06-22 16:23:23 -04:00
* Private function for the default callback for post_tag and category
* taxonomies .
2007-10-15 18:49:31 -04:00
*
2007-10-21 13:18:24 -04:00
* @ access private
2008-08-30 17:23:43 -04:00
* @ since 2.3 . 0
2007-10-21 13:18:24 -04:00
* @ uses $wpdb
2007-10-15 18:49:31 -04:00
*
2008-10-29 02:54:53 -04:00
* @ param array $terms List of Term taxonomy IDs
2010-03-09 05:48:18 -05:00
* @ param object $taxonomy Current taxonomy object of terms
2007-10-15 18:49:31 -04:00
*/
2010-03-09 05:48:18 -05:00
function _update_post_term_count ( $terms , $taxonomy ) {
2007-09-15 13:35:32 -04:00
global $wpdb ;
2011-10-21 17:38:14 -04:00
$object_types = ( array ) $taxonomy -> object_type ;
2011-10-24 15:13:23 -04:00
2011-10-10 16:52:44 -04:00
foreach ( $object_types as & $object_type )
list ( $object_type ) = explode ( ':' , $object_type );
2011-10-21 17:38:14 -04:00
2011-10-10 16:52:44 -04:00
$object_types = array_unique ( $object_types );
2011-10-21 17:38:14 -04:00
if ( false !== ( $check_attachments = array_search ( 'attachment' , $object_types ) ) ) {
unset ( $object_types [ $check_attachments ] );
$check_attachments = true ;
}
if ( $object_types )
$object_types = esc_sql ( array_filter ( $object_types , 'post_type_exists' ) );
2010-03-09 05:48:18 -05:00
2008-08-06 16:31:54 -04:00
foreach ( ( array ) $terms as $term ) {
2011-10-21 17:38:14 -04:00
$count = 0 ;
2011-10-10 16:52:44 -04:00
2011-10-20 17:41:54 -04:00
// Attachments can be 'inherit' status, we need to base count off the parent's status if so
2011-10-21 17:38:14 -04:00
if ( $check_attachments )
$count += ( int ) $wpdb -> get_var ( $wpdb -> prepare ( " SELECT COUNT(*) FROM $wpdb->term_relationships , $wpdb->posts p1 WHERE p1.ID = $wpdb->term_relationships .object_id AND ( post_status = 'publish' OR ( post_status = 'inherit' AND post_parent > 0 AND ( SELECT post_status FROM $wpdb->posts WHERE ID = p1.post_parent ) = 'publish' ) ) AND post_type = 'attachment' AND term_taxonomy_id = %d " , $term ) );
2011-10-10 16:52:44 -04:00
2011-10-21 17:38:14 -04:00
if ( $object_types )
$count += ( int ) $wpdb -> get_var ( $wpdb -> prepare ( " SELECT COUNT(*) FROM $wpdb->term_relationships , $wpdb->posts WHERE $wpdb->posts .ID = $wpdb->term_relationships .object_id AND post_status = 'publish' AND post_type IN (' " . implode ( " ', ' " , $object_types ) . " ') AND term_taxonomy_id = %d " , $term ) );
2014-03-28 17:29:13 -04:00
/** This action is documented in wp-includes/taxonomy.php */
2010-03-09 05:48:18 -05:00
do_action ( 'edit_term_taxonomy' , $term , $taxonomy );
2007-10-13 14:23:59 -04:00
$wpdb -> update ( $wpdb -> term_taxonomy , compact ( 'count' ), array ( 'term_taxonomy_id' => $term ) );
2014-03-28 17:29:13 -04:00
/** This action is documented in wp-includes/taxonomy.php */
2010-03-09 05:48:18 -05:00
do_action ( 'edited_term_taxonomy' , $term , $taxonomy );
2007-09-15 13:35:32 -04:00
}
}
2011-10-21 17:38:14 -04:00
/**
* Will update term count based on number of objects .
*
* Default callback for the link_category taxonomy .
*
* @ since 3.3 . 0
* @ uses $wpdb
*
* @ param array $terms List of Term taxonomy IDs
* @ param object $taxonomy Current taxonomy object of terms
*/
function _update_generic_term_count ( $terms , $taxonomy ) {
global $wpdb ;
foreach ( ( array ) $terms as $term ) {
$count = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT COUNT(*) FROM $wpdb->term_relationships WHERE term_taxonomy_id = %d " , $term ) );
2014-03-28 17:29:13 -04:00
/** This action is documented in wp-includes/taxonomy.php */
2011-10-21 17:38:14 -04:00
do_action ( 'edit_term_taxonomy' , $term , $taxonomy );
$wpdb -> update ( $wpdb -> term_taxonomy , compact ( 'count' ), array ( 'term_taxonomy_id' => $term ) );
2014-03-28 17:29:13 -04:00
/** This action is documented in wp-includes/taxonomy.php */
2011-10-21 17:38:14 -04:00
do_action ( 'edited_term_taxonomy' , $term , $taxonomy );
}
}
2008-06-22 16:23:23 -04:00
2008-03-26 02:37:19 -04:00
/**
2008-06-22 16:23:23 -04:00
* Generates a permalink for a taxonomy term archive .
*
2008-08-30 17:23:43 -04:00
* @ since 2.5 . 0
2008-03-26 02:37:19 -04:00
*
2009-05-14 00:09:01 -04:00
* @ param object | int | string $term
2010-09-07 00:29:00 -04:00
* @ param string $taxonomy ( optional if $term is object )
2011-02-10 16:48:40 -05:00
* @ return string | WP_Error HTML link to taxonomy term archive on success , WP_Error if term does not exist .
2008-03-26 02:37:19 -04:00
*/
2010-09-07 00:29:00 -04:00
function get_term_link ( $term , $taxonomy = '' ) {
2008-03-26 02:37:19 -04:00
global $wp_rewrite ;
2009-05-14 00:09:01 -04:00
if ( ! is_object ( $term ) ) {
if ( is_int ( $term ) ) {
2012-10-04 14:21:47 -04:00
$term = get_term ( $term , $taxonomy );
2009-05-14 00:09:01 -04:00
} else {
2012-10-04 14:21:47 -04:00
$term = get_term_by ( 'slug' , $term , $taxonomy );
2009-05-14 00:09:01 -04:00
}
}
2010-02-16 04:08:26 -05:00
if ( ! is_object ( $term ) )
$term = new WP_Error ( 'invalid_term' , __ ( 'Empty Term' ));
2009-05-14 00:09:01 -04:00
if ( is_wp_error ( $term ) )
2011-02-10 16:48:40 -05:00
return $term ;
2008-03-26 02:37:19 -04:00
2010-09-07 00:29:00 -04:00
$taxonomy = $term -> taxonomy ;
2009-05-11 00:45:39 -04:00
$termlink = $wp_rewrite -> get_extra_permastruct ( $taxonomy );
2008-03-26 02:37:19 -04:00
$slug = $term -> slug ;
2010-10-04 06:37:25 -04:00
$t = get_taxonomy ( $taxonomy );
2008-03-26 02:37:19 -04:00
if ( empty ( $termlink ) ) {
2011-03-02 12:29:11 -05:00
if ( 'category' == $taxonomy )
$termlink = '?cat=' . $term -> term_id ;
elseif ( $t -> query_var )
2010-01-04 12:23:29 -05:00
$termlink = " ? $t->query_var = $slug " ;
2008-03-26 02:37:19 -04:00
else
2010-01-04 12:23:29 -05:00
$termlink = " ?taxonomy= $taxonomy &term= $slug " ;
$termlink = home_url ( $termlink );
2008-03-26 02:37:19 -04:00
} else {
2010-10-17 00:36:26 -04:00
if ( $t -> rewrite [ 'hierarchical' ] ) {
2010-10-04 06:37:25 -04:00
$hierarchical_slugs = array ();
$ancestors = get_ancestors ( $term -> term_id , $taxonomy );
foreach ( ( array ) $ancestors as $ancestor ) {
$ancestor_term = get_term ( $ancestor , $taxonomy );
$hierarchical_slugs [] = $ancestor_term -> slug ;
}
$hierarchical_slugs = array_reverse ( $hierarchical_slugs );
$hierarchical_slugs [] = $slug ;
$termlink = str_replace ( " % $taxonomy % " , implode ( '/' , $hierarchical_slugs ), $termlink );
} else {
$termlink = str_replace ( " % $taxonomy % " , $slug , $termlink );
}
2010-01-04 12:23:29 -05:00
$termlink = home_url ( user_trailingslashit ( $termlink , 'category' ) );
2008-03-26 02:37:19 -04:00
}
2010-10-17 01:41:22 -04:00
// Back Compat filters.
2014-03-28 17:29:13 -04:00
if ( 'post_tag' == $taxonomy ) {
/**
* Filter the tag link .
*
* @ since 2.3 . 0
* @ deprecated 2.5 . 0 Use 'term_link' instead .
*
* @ param string $termlink Tag link URL .
* @ param int $term_id Term ID .
*/
2010-10-17 01:41:22 -04:00
$termlink = apply_filters ( 'tag_link' , $termlink , $term -> term_id );
2014-03-28 17:29:13 -04:00
} elseif ( 'category' == $taxonomy ) {
/**
* Filter the category link .
*
* @ since 1.5 . 0
* @ deprecated 2.5 . 0 Use 'term_link' instead .
*
* @ param string $termlink Category link URL .
* @ param int $term_id Term ID .
*/
2010-10-17 01:41:22 -04:00
$termlink = apply_filters ( 'category_link' , $termlink , $term -> term_id );
2014-03-28 17:29:13 -04:00
}
2010-10-17 01:41:22 -04:00
2014-03-28 17:29:13 -04:00
/**
* Filter the term link .
*
* @ since 2.5 . 0
*
* @ param string $termlink Term link URL .
* @ param object $term Term object .
* @ param string $taxonomy Taxonomy slug .
*/
return apply_filters ( 'term_link' , $termlink , $term , $taxonomy );
2008-03-26 02:37:19 -04:00
}
2008-06-22 16:23:23 -04:00
/**
* Display the taxonomies of a post with available options .
*
* This function can be used within the loop to display the taxonomies for a
* post without specifying the Post ID . You can also use it outside the Loop to
* display the taxonomies for a specific post .
*
* The available defaults are :
* 'post' : default is 0. The post ID to get taxonomies of .
* 'before' : default is empty string . Display before taxonomies list .
* 'sep' : default is empty string . Separate every taxonomy with value in this .
* 'after' : default is empty string . Display this after the taxonomies list .
2010-12-01 15:16:24 -05:00
* 'template' : The template to use for displaying the taxonomy terms .
2008-06-22 16:23:23 -04:00
*
2008-08-30 17:23:43 -04:00
* @ since 2.5 . 0
2008-06-22 16:23:23 -04:00
* @ uses get_the_taxonomies ()
*
* @ param array $args Override the defaults .
*/
2008-03-26 02:37:19 -04:00
function the_taxonomies ( $args = array ()) {
$defaults = array (
'post' => 0 ,
'before' => '' ,
'sep' => ' ' ,
'after' => '' ,
2010-12-01 15:16:24 -05:00
'template' => '%s: %l.'
2008-03-26 02:37:19 -04:00
);
$r = wp_parse_args ( $args , $defaults );
extract ( $r , EXTR_SKIP );
2010-12-17 11:33:16 -05:00
echo $before . join ( $sep , get_the_taxonomies ( $post , $r )) . $after ;
2008-03-26 02:37:19 -04:00
}
2008-06-22 16:23:23 -04:00
/**
* Retrieve all taxonomies associated with a post .
*
* This function can be used within the loop . It will also return an array of
* the taxonomies with links to the taxonomy and name .
*
2008-08-30 17:23:43 -04:00
* @ since 2.5 . 0
2008-06-22 16:23:23 -04:00
*
2014-03-08 14:32:16 -05:00
* @ param int | WP_Post $post Optional . Post ID or post object .
2010-12-17 11:33:16 -05:00
* @ param array $args Override the defaults .
2008-06-22 16:23:23 -04:00
* @ return array
*/
2010-12-17 11:33:16 -05:00
function get_the_taxonomies ( $post = 0 , $args = array () ) {
2012-08-23 16:01:10 -04:00
$post = get_post ( $post );
2008-03-26 02:37:19 -04:00
2010-12-17 11:33:16 -05:00
$args = wp_parse_args ( $args , array (
'template' => '%s: %l.' ,
2011-01-05 23:11:14 -05:00
) );
2010-12-17 11:33:16 -05:00
extract ( $args , EXTR_SKIP );
2008-03-26 02:37:19 -04:00
$taxonomies = array ();
if ( ! $post )
return $taxonomies ;
foreach ( get_object_taxonomies ( $post ) as $taxonomy ) {
$t = ( array ) get_taxonomy ( $taxonomy );
if ( empty ( $t [ 'label' ]) )
$t [ 'label' ] = $taxonomy ;
if ( empty ( $t [ 'args' ]) )
$t [ 'args' ] = array ();
if ( empty ( $t [ 'template' ]) )
2008-03-26 14:26:22 -04:00
$t [ 'template' ] = $template ;
2008-03-26 02:37:19 -04:00
$terms = get_object_term_cache ( $post -> ID , $taxonomy );
2012-11-07 15:00:51 -05:00
if ( false === $terms )
2008-03-26 02:37:19 -04:00
$terms = wp_get_object_terms ( $post -> ID , $taxonomy , $t [ 'args' ]);
$links = array ();
foreach ( $terms as $term )
2010-09-07 00:29:00 -04:00
$links [] = " <a href=' " . esc_attr ( get_term_link ( $term ) ) . " '> $term->name </a> " ;
2008-03-26 02:37:19 -04:00
if ( $links )
$taxonomies [ $taxonomy ] = wp_sprintf ( $t [ 'template' ], $t [ 'label' ], $links , $terms );
}
return $taxonomies ;
}
2008-06-22 16:23:23 -04:00
/**
* Retrieve all taxonomies of a post with just the names .
*
2008-08-30 17:23:43 -04:00
* @ since 2.5 . 0
2008-06-22 16:23:23 -04:00
* @ uses get_object_taxonomies ()
*
2014-03-08 14:32:16 -05:00
* @ param int | WP_Post $post Optional . Post ID or post object .
2008-06-22 16:23:23 -04:00
* @ return array
*/
2008-03-26 02:37:19 -04:00
function get_post_taxonomies ( $post = 0 ) {
2012-08-23 16:01:10 -04:00
$post = get_post ( $post );
2008-03-26 02:37:19 -04:00
return get_object_taxonomies ( $post );
}
2008-12-09 18:31:11 -05:00
/**
* Determine if the given object is associated with any of the given terms .
*
* The given terms are checked against the object 's terms' term_ids , names and slugs .
* Terms given as integers will only be checked against the object 's terms' term_ids .
* If no terms are given , determines if object is associated with any terms in the given taxonomy .
*
* @ since 2.7 . 0
* @ uses get_object_term_cache ()
* @ uses wp_get_object_terms ()
*
2010-09-07 07:21:11 -04:00
* @ param int $object_id ID of the object ( post ID , link ID , ... )
* @ param string $taxonomy Single taxonomy name
2011-12-13 18:45:31 -05:00
* @ param int | string | array $terms Optional . Term term_id , name , slug or array of said
2008-12-09 18:31:11 -05:00
* @ return bool | WP_Error . WP_Error on input error .
*/
function is_object_in_term ( $object_id , $taxonomy , $terms = null ) {
if ( ! $object_id = ( int ) $object_id )
return new WP_Error ( 'invalid_object' , __ ( 'Invalid object ID' ) );
$object_terms = get_object_term_cache ( $object_id , $taxonomy );
2012-11-08 19:16:30 -05:00
if ( false === $object_terms )
2008-12-09 18:31:11 -05:00
$object_terms = wp_get_object_terms ( $object_id , $taxonomy );
if ( is_wp_error ( $object_terms ) )
return $object_terms ;
if ( empty ( $object_terms ) )
return false ;
if ( empty ( $terms ) )
return ( ! empty ( $object_terms ) );
$terms = ( array ) $terms ;
if ( $ints = array_filter ( $terms , 'is_int' ) )
$strs = array_diff ( $terms , $ints );
else
$strs =& $terms ;
foreach ( $object_terms as $object_term ) {
if ( $ints && in_array ( $object_term -> term_id , $ints ) ) return true ; // If int, check against term_id
if ( $strs ) {
if ( in_array ( $object_term -> term_id , $strs ) ) return true ;
if ( in_array ( $object_term -> name , $strs ) ) return true ;
if ( in_array ( $object_term -> slug , $strs ) ) return true ;
}
}
return false ;
}
2010-01-04 11:58:43 -05:00
/**
* Determine if the given object type is associated with the given taxonomy .
*
2010-03-26 15:13:36 -04:00
* @ since 3.0 . 0
2010-01-04 11:58:43 -05:00
* @ uses get_object_taxonomies ()
*
* @ param string $object_type Object type string
2010-09-07 07:21:11 -04:00
* @ param string $taxonomy Single taxonomy name
2010-01-04 11:58:43 -05:00
* @ return bool True if object is associated with the taxonomy , otherwise false .
*/
function is_object_in_taxonomy ( $object_type , $taxonomy ) {
$taxonomies = get_object_taxonomies ( $object_type );
if ( empty ( $taxonomies ) )
return false ;
if ( in_array ( $taxonomy , $taxonomies ) )
return true ;
return false ;
}
2010-10-19 03:48:22 -04:00
2010-09-18 15:20:16 -04:00
/**
* Get an array of ancestor IDs for a given object .
*
* @ param int $object_id The ID of the object
* @ param string $object_type The type of object for which we ' ll be retrieving ancestors .
* @ return array of ancestors from lowest to highest in the hierarchy .
*/
function get_ancestors ( $object_id = 0 , $object_type = '' ) {
$object_id = ( int ) $object_id ;
2010-10-19 03:48:22 -04:00
2010-09-18 15:20:16 -04:00
$ancestors = array ();
if ( empty ( $object_id ) ) {
2014-03-28 17:29:13 -04:00
/** This filter is documented in wp-includes/taxonomy.php */
return apply_filters ( 'get_ancestors' , $ancestors , $object_id , $object_type );
2010-09-18 15:20:16 -04:00
}
2010-10-21 15:55:28 -04:00
2010-09-18 15:20:16 -04:00
if ( is_taxonomy_hierarchical ( $object_type ) ) {
$term = get_term ( $object_id , $object_type );
while ( ! is_wp_error ( $term ) && ! empty ( $term -> parent ) && ! in_array ( $term -> parent , $ancestors ) ) {
$ancestors [] = ( int ) $term -> parent ;
$term = get_term ( $term -> parent , $object_type );
}
2012-08-20 15:47:52 -04:00
} elseif ( post_type_exists ( $object_type ) ) {
$ancestors = get_post_ancestors ( $object_id );
2010-09-18 15:20:16 -04:00
}
2014-03-28 17:29:13 -04:00
/**
* Filter a given object ' s ancestors .
*
* @ since 3.1 . 0
*
* @ param array $ancestors An array of object ancestors .
* @ param int $object_id Object ID .
* @ param string $object_type Type of object .
*/
return apply_filters ( 'get_ancestors' , $ancestors , $object_id , $object_type );
2010-09-18 15:20:16 -04:00
}
2010-10-02 22:58:59 -04:00
2010-10-14 11:09:04 -04:00
/**
* Returns the term 's parent' s term_ID
*
2010-10-19 03:38:42 -04:00
* @ since 3.1 . 0
2010-10-14 11:09:04 -04:00
*
* @ param int $term_id
* @ param string $taxonomy
*
* @ return int | bool false on error
*/
function wp_get_term_taxonomy_parent_id ( $term_id , $taxonomy ) {
$term = get_term ( $term_id , $taxonomy );
if ( ! $term || is_wp_error ( $term ) )
return false ;
return ( int ) $term -> parent ;
}
/**
* Checks the given subset of the term hierarchy for hierarchy loops .
* Prevents loops from forming and breaks those that it finds .
*
* Attached to the wp_update_term_parent filter .
*
2010-10-19 03:38:42 -04:00
* @ since 3.1 . 0
2010-10-14 11:09:04 -04:00
* @ uses wp_find_hierarchy_loop ()
*
* @ param int $parent term_id of the parent for the term we ' re checking .
* @ param int $term_id The term we ' re checking .
* @ param string $taxonomy The taxonomy of the term we ' re checking .
*
* @ return int The new parent for the term .
*/
function wp_check_term_hierarchy_for_loops ( $parent , $term_id , $taxonomy ) {
// Nothing fancy here - bail
if ( ! $parent )
return 0 ;
// Can't be its own parent
if ( $parent == $term_id )
return 0 ;
// Now look for larger loops
if ( ! $loop = wp_find_hierarchy_loop ( 'wp_get_term_taxonomy_parent_id' , $term_id , $parent , array ( $taxonomy ) ) )
return $parent ; // No loop
// Setting $parent to the given value causes a loop
if ( isset ( $loop [ $term_id ] ) )
return 0 ;
2011-12-13 18:45:31 -05:00
// There's a loop, but it doesn't contain $term_id. Break the loop.
2010-10-14 11:09:04 -04:00
foreach ( array_keys ( $loop ) as $loop_member )
wp_update_term ( $loop_member , $taxonomy , array ( 'parent' => 0 ) );
return $parent ;
2016-03-30 13:38:15 -04:00
}