mirror of
https://github.com/WordPress/WordPress.git
synced 2024-11-16 15:46:04 +01:00
7da41242f9
The codex says that taxonomy names "should only contain lowercase letters and the underscore character", but that's not enforced. It's too late to enforce it, since some plugins haven't been following it and the official phpdoc doesn't mention this restriction. Merge of [37133] to the 4.3 branch. Built from https://develop.svn.wordpress.org/branches/4.3@37136 git-svn-id: http://core.svn.wordpress.org/branches/4.3@37103 1a063a9b-81f0-0310-95a4-ce76da25c4cd
4972 lines
163 KiB
PHP
4972 lines
163 KiB
PHP
<?php
|
|
/**
|
|
* Taxonomy API
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @package WordPress
|
|
* @subpackage Taxonomy
|
|
*/
|
|
|
|
//
|
|
// Taxonomy Registration
|
|
//
|
|
|
|
/**
|
|
* Creates the initial taxonomies.
|
|
*
|
|
* This function fires twice: in wp-settings.php before plugins are loaded (for
|
|
* backwards compatibility reasons), and again on the {@see 'init'} action. We must
|
|
* avoid registering rewrite rules before the {@see 'init'} action.
|
|
*
|
|
* @since 2.8.0
|
|
*
|
|
* @global WP_Rewrite $wp_rewrite The WordPress rewrite class.
|
|
*/
|
|
function create_initial_taxonomies() {
|
|
global $wp_rewrite;
|
|
|
|
if ( ! did_action( 'init' ) ) {
|
|
$rewrite = array( 'category' => false, 'post_tag' => false, 'post_format' => false );
|
|
} else {
|
|
|
|
/**
|
|
* Filter the post formats rewrite base.
|
|
*
|
|
* @since 3.1.0
|
|
*
|
|
* @param string $context Context of the rewrite base. Default 'type'.
|
|
*/
|
|
$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',
|
|
'with_front' => ! get_option('category_base') || $wp_rewrite->using_index_permalinks(),
|
|
'ep_mask' => EP_CATEGORIES,
|
|
),
|
|
'post_tag' => array(
|
|
'hierarchical' => false,
|
|
'slug' => get_option('tag_base') ? get_option('tag_base') : 'tag',
|
|
'with_front' => ! get_option('tag_base') || $wp_rewrite->using_index_permalinks(),
|
|
'ep_mask' => EP_TAGS,
|
|
),
|
|
'post_format' => $post_format_base ? array( 'slug' => $post_format_base ) : false,
|
|
);
|
|
}
|
|
|
|
register_taxonomy( 'category', 'post', array(
|
|
'hierarchical' => true,
|
|
'query_var' => 'category_name',
|
|
'rewrite' => $rewrite['category'],
|
|
'public' => true,
|
|
'show_ui' => true,
|
|
'show_admin_column' => true,
|
|
'_builtin' => true,
|
|
) );
|
|
|
|
register_taxonomy( 'post_tag', 'post', array(
|
|
'hierarchical' => false,
|
|
'query_var' => 'tag',
|
|
'rewrite' => $rewrite['post_tag'],
|
|
'public' => true,
|
|
'show_ui' => true,
|
|
'show_admin_column' => true,
|
|
'_builtin' => true,
|
|
) );
|
|
|
|
register_taxonomy( 'nav_menu', 'nav_menu_item', array(
|
|
'public' => false,
|
|
'hierarchical' => false,
|
|
'labels' => array(
|
|
'name' => __( 'Navigation Menus' ),
|
|
'singular_name' => __( 'Navigation Menu' ),
|
|
),
|
|
'query_var' => false,
|
|
'rewrite' => false,
|
|
'show_ui' => false,
|
|
'_builtin' => true,
|
|
'show_in_nav_menus' => false,
|
|
) );
|
|
|
|
register_taxonomy( 'link_category', 'link', array(
|
|
'hierarchical' => false,
|
|
'labels' => array(
|
|
'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,
|
|
),
|
|
'capabilities' => array(
|
|
'manage_terms' => 'manage_links',
|
|
'edit_terms' => 'manage_links',
|
|
'delete_terms' => 'manage_links',
|
|
'assign_terms' => 'manage_links',
|
|
),
|
|
'query_var' => false,
|
|
'rewrite' => false,
|
|
'public' => false,
|
|
'show_ui' => false,
|
|
'_builtin' => true,
|
|
) );
|
|
|
|
register_taxonomy( 'post_format', 'post', array(
|
|
'public' => true,
|
|
'hierarchical' => false,
|
|
'labels' => array(
|
|
'name' => _x( 'Format', 'post format' ),
|
|
'singular_name' => _x( 'Format', 'post format' ),
|
|
),
|
|
'query_var' => true,
|
|
'rewrite' => $rewrite['post_format'],
|
|
'show_ui' => false,
|
|
'_builtin' => true,
|
|
'show_in_nav_menus' => current_theme_supports( 'post-formats' ),
|
|
) );
|
|
}
|
|
|
|
/**
|
|
* Retrieves a list of registered taxonomy names or objects.
|
|
*
|
|
* @since 3.0.0
|
|
*
|
|
* @global array $wp_taxonomies The registered taxonomies.
|
|
*
|
|
* @param array $args Optional. An array of `key => value` arguments to match against the taxonomy objects.
|
|
* Default empty array.
|
|
* @param string $output Optional. The type of output to return in the array. Accepts either taxonomy 'names'
|
|
* or 'objects'. Default 'names'.
|
|
* @param string $operator Optional. The logical operation to perform. Accepts 'and' or 'or'. 'or' means only
|
|
* one element from the array needs to match; 'and' means all elements must match.
|
|
* Default 'and'.
|
|
* @return array A list of taxonomy names or objects.
|
|
*/
|
|
function get_taxonomies( $args = array(), $output = 'names', $operator = 'and' ) {
|
|
global $wp_taxonomies;
|
|
|
|
$field = ('names' == $output) ? 'name' : false;
|
|
|
|
return wp_filter_object_list($wp_taxonomies, $args, $operator, $field);
|
|
}
|
|
|
|
/**
|
|
* Return all of the taxonomy names that are of $object_type.
|
|
*
|
|
* It appears that this function can be used to find all of the names inside of
|
|
* $wp_taxonomies global variable.
|
|
*
|
|
* `<?php $taxonomies = get_object_taxonomies('post'); ?>` Should
|
|
* result in `Array( 'category', 'post_tag' )`
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @global array $wp_taxonomies The registered taxonomies.
|
|
*
|
|
* @param array|string|WP_Post $object Name of the type of taxonomy object, or an object (row from posts)
|
|
* @param string $output Optional. The type of output to return in the array. Accepts either
|
|
* taxonomy 'names' or 'objects'. Default 'names'.
|
|
* @return array The names of all taxonomy of $object_type.
|
|
*/
|
|
function get_object_taxonomies( $object, $output = 'names' ) {
|
|
global $wp_taxonomies;
|
|
|
|
if ( is_object($object) ) {
|
|
if ( $object->post_type == 'attachment' )
|
|
return get_attachment_taxonomies($object);
|
|
$object = $object->post_type;
|
|
}
|
|
|
|
$object = (array) $object;
|
|
|
|
$taxonomies = array();
|
|
foreach ( (array) $wp_taxonomies as $tax_name => $tax_obj ) {
|
|
if ( array_intersect($object, (array) $tax_obj->object_type) ) {
|
|
if ( 'names' == $output )
|
|
$taxonomies[] = $tax_name;
|
|
else
|
|
$taxonomies[ $tax_name ] = $tax_obj;
|
|
}
|
|
}
|
|
|
|
return $taxonomies;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the taxonomy object of $taxonomy.
|
|
*
|
|
* The get_taxonomy function will first check that the parameter string given
|
|
* is a taxonomy object and if it is, it will return it.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @global array $wp_taxonomies The registered taxonomies.
|
|
*
|
|
* @param string $taxonomy Name of taxonomy object to return.
|
|
* @return object|false The Taxonomy Object or false if $taxonomy doesn't exist.
|
|
*/
|
|
function get_taxonomy( $taxonomy ) {
|
|
global $wp_taxonomies;
|
|
|
|
if ( ! taxonomy_exists( $taxonomy ) )
|
|
return false;
|
|
|
|
return $wp_taxonomies[$taxonomy];
|
|
}
|
|
|
|
/**
|
|
* Checks that the taxonomy name exists.
|
|
*
|
|
* Formerly is_taxonomy(), introduced in 2.3.0.
|
|
*
|
|
* @since 3.0.0
|
|
*
|
|
* @global array $wp_taxonomies The registered taxonomies.
|
|
*
|
|
* @param string $taxonomy Name of taxonomy object.
|
|
* @return bool Whether the taxonomy exists.
|
|
*/
|
|
function taxonomy_exists( $taxonomy ) {
|
|
global $wp_taxonomies;
|
|
|
|
return isset( $wp_taxonomies[$taxonomy] );
|
|
}
|
|
|
|
/**
|
|
* Whether the taxonomy object is hierarchical.
|
|
*
|
|
* Checks to make sure that the taxonomy is an object first. Then Gets the
|
|
* object, and finally returns the hierarchical value in the object.
|
|
*
|
|
* A false return value might also mean that the taxonomy does not exist.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @param string $taxonomy Name of taxonomy object.
|
|
* @return bool Whether the taxonomy is hierarchical.
|
|
*/
|
|
function is_taxonomy_hierarchical($taxonomy) {
|
|
if ( ! taxonomy_exists($taxonomy) )
|
|
return false;
|
|
|
|
$taxonomy = get_taxonomy($taxonomy);
|
|
return $taxonomy->hierarchical;
|
|
}
|
|
|
|
/**
|
|
* Create or modify a taxonomy object. Do not use before init.
|
|
*
|
|
* A simple function for creating or modifying a taxonomy object based on the
|
|
* parameters given. The function will accept an array (third optional
|
|
* parameter), along with strings for the taxonomy name and another string for
|
|
* the object type.
|
|
*
|
|
* Nothing is returned, so expect error maybe or use taxonomy_exists() to check
|
|
* whether taxonomy exists.
|
|
*
|
|
* Optional $args contents:
|
|
*
|
|
* - 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.
|
|
* - show_in_menu - Whether 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.
|
|
* - 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.
|
|
* - show_in_quick_edit - Whether to show the taxonomy in the quick/bulk edit panel.
|
|
* * It not set, the default is inherited from show_ui.
|
|
* - show_admin_column - Whether to display a column for the taxonomy on its post type listing screens.
|
|
* * Defaults to false.
|
|
* - 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.
|
|
* - 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!
|
|
*
|
|
* @todo Document $args as a hash notation.
|
|
*
|
|
* @since 2.3.0
|
|
* @since 4.2.0 Introduced `show_in_quick_edit` argument.
|
|
*
|
|
* @global array $wp_taxonomies Registered taxonomies.
|
|
* @global WP $wp WP instance.
|
|
*
|
|
* @param string $taxonomy Taxonomy key, must not exceed 32 characters.
|
|
* @param array|string $object_type Name of the object type for the taxonomy object.
|
|
* @param array|string $args See optional args description above.
|
|
* @return WP_Error|void WP_Error, if errors.
|
|
*/
|
|
function register_taxonomy( $taxonomy, $object_type, $args = array() ) {
|
|
global $wp_taxonomies, $wp;
|
|
|
|
if ( ! is_array( $wp_taxonomies ) )
|
|
$wp_taxonomies = array();
|
|
|
|
$defaults = array(
|
|
'labels' => array(),
|
|
'description' => '',
|
|
'public' => true,
|
|
'hierarchical' => false,
|
|
'show_ui' => null,
|
|
'show_in_menu' => null,
|
|
'show_in_nav_menus' => null,
|
|
'show_tagcloud' => null,
|
|
'show_in_quick_edit' => null,
|
|
'show_admin_column' => false,
|
|
'meta_box_cb' => null,
|
|
'capabilities' => array(),
|
|
'rewrite' => true,
|
|
'query_var' => $taxonomy,
|
|
'update_count_callback' => '',
|
|
'_builtin' => false,
|
|
);
|
|
$args = wp_parse_args( $args, $defaults );
|
|
|
|
if ( empty( $taxonomy ) || strlen( $taxonomy ) > 32 ) {
|
|
_doing_it_wrong( __FUNCTION__, __( 'Taxonomy names must be between 1 and 32 characters in length.' ), '4.2' );
|
|
return new WP_Error( 'taxonomy_length_invalid', __( 'Taxonomy names must be between 1 and 32 characters in length.' ) );
|
|
}
|
|
|
|
if ( false !== $args['query_var'] && ! empty( $wp ) ) {
|
|
if ( true === $args['query_var'] )
|
|
$args['query_var'] = $taxonomy;
|
|
else
|
|
$args['query_var'] = sanitize_title_with_dashes( $args['query_var'] );
|
|
$wp->add_query_var( $args['query_var'] );
|
|
}
|
|
|
|
if ( false !== $args['rewrite'] && ( is_admin() || '' != get_option( 'permalink_structure' ) ) ) {
|
|
$args['rewrite'] = wp_parse_args( $args['rewrite'], array(
|
|
'with_front' => true,
|
|
'hierarchical' => false,
|
|
'ep_mask' => EP_NONE,
|
|
) );
|
|
|
|
if ( empty( $args['rewrite']['slug'] ) )
|
|
$args['rewrite']['slug'] = sanitize_title_with_dashes( $taxonomy );
|
|
|
|
if ( $args['hierarchical'] && $args['rewrite']['hierarchical'] )
|
|
$tag = '(.+?)';
|
|
else
|
|
$tag = '([^/]+)';
|
|
|
|
add_rewrite_tag( "%$taxonomy%", $tag, $args['query_var'] ? "{$args['query_var']}=" : "taxonomy=$taxonomy&term=" );
|
|
add_permastruct( $taxonomy, "{$args['rewrite']['slug']}/%$taxonomy%", $args['rewrite'] );
|
|
}
|
|
|
|
// If not set, default to the setting for public.
|
|
if ( null === $args['show_ui'] )
|
|
$args['show_ui'] = $args['public'];
|
|
|
|
// 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'];
|
|
|
|
// If not set, default to the setting for public.
|
|
if ( null === $args['show_in_nav_menus'] )
|
|
$args['show_in_nav_menus'] = $args['public'];
|
|
|
|
// If not set, default to the setting for show_ui.
|
|
if ( null === $args['show_tagcloud'] )
|
|
$args['show_tagcloud'] = $args['show_ui'];
|
|
|
|
// If not set, default to the setting for show_ui.
|
|
if ( null === $args['show_in_quick_edit'] ) {
|
|
$args['show_in_quick_edit'] = $args['show_ui'];
|
|
}
|
|
|
|
$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'] );
|
|
|
|
$args['name'] = $taxonomy;
|
|
$args['object_type'] = array_unique( (array) $object_type );
|
|
|
|
$args['labels'] = get_taxonomy_labels( (object) $args );
|
|
$args['label'] = $args['labels']->name;
|
|
|
|
// 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';
|
|
}
|
|
|
|
$wp_taxonomies[ $taxonomy ] = (object) $args;
|
|
|
|
// register callback handling for metabox
|
|
add_filter( 'wp_ajax_add-' . $taxonomy, '_wp_ajax_add_hierarchical_term' );
|
|
|
|
/**
|
|
* 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 $args Array of taxonomy registration arguments.
|
|
*/
|
|
do_action( 'registered_taxonomy', $taxonomy, $object_type, $args );
|
|
}
|
|
|
|
/**
|
|
* Builds an object with all taxonomy labels out of a taxonomy object
|
|
*
|
|
* Accepted keys of the label array in the taxonomy object:
|
|
*
|
|
* - 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
|
|
* - search_items - Default is Search Tags/Search Categories
|
|
* - popular_items - This string isn't used on hierarchical taxonomies. Default is Popular Tags
|
|
* - 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 `parent_item`, but with colon `:` in the end
|
|
* - edit_item - Default is Edit Tag/Edit Category
|
|
* - view_item - Default is View Tag/View Category
|
|
* - 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
|
|
* - 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.
|
|
* - not_found - Default is "No tags found"/"No categories found", used in the meta box and taxonomy list table.
|
|
* - no_terms - Default is "No tags"/"No categories", used in the posts and media list tables.
|
|
*
|
|
* Above, the first default value is for non-hierarchical taxonomies (like tags) and the second one is for hierarchical taxonomies (like categories).
|
|
*
|
|
* @todo Better documentation for the labels array.
|
|
*
|
|
* @since 3.0.0
|
|
* @since 4.3.0 Added the `no_terms` label.
|
|
*
|
|
* @param object $tax Taxonomy object.
|
|
* @return object object with all the labels as member variables.
|
|
*/
|
|
function get_taxonomy_labels( $tax ) {
|
|
$tax->labels = (array) $tax->labels;
|
|
|
|
if ( isset( $tax->helps ) && empty( $tax->labels['separate_items_with_commas'] ) )
|
|
$tax->labels['separate_items_with_commas'] = $tax->helps;
|
|
|
|
if ( isset( $tax->no_tagcloud ) && empty( $tax->labels['not_found'] ) )
|
|
$tax->labels['not_found'] = $tax->no_tagcloud;
|
|
|
|
$nohier_vs_hier_defaults = array(
|
|
'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' ) ),
|
|
'search_items' => array( __( 'Search Tags' ), __( 'Search Categories' ) ),
|
|
'popular_items' => array( __( 'Popular Tags' ), null ),
|
|
'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' ) ),
|
|
'view_item' => array( __( 'View Tag' ), __( 'View Category' ) ),
|
|
'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' ) ),
|
|
'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 ),
|
|
'not_found' => array( __( 'No tags found.' ), __( 'No categories found.' ) ),
|
|
'no_terms' => array( __( 'No tags' ), __( 'No categories' ) ),
|
|
);
|
|
$nohier_vs_hier_defaults['menu_name'] = $nohier_vs_hier_defaults['name'];
|
|
|
|
return _get_custom_object_labels( $tax, $nohier_vs_hier_defaults );
|
|
}
|
|
|
|
/**
|
|
* Add an already registered taxonomy to an object type.
|
|
*
|
|
* @since 3.0.0
|
|
*
|
|
* @global array $wp_taxonomies The registered taxonomies.
|
|
*
|
|
* @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 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;
|
|
|
|
if ( ! in_array( $object_type, $wp_taxonomies[$taxonomy]->object_type ) )
|
|
$wp_taxonomies[$taxonomy]->object_type[] = $object_type;
|
|
|
|
// Filter out empties.
|
|
$wp_taxonomies[ $taxonomy ]->object_type = array_filter( $wp_taxonomies[ $taxonomy ]->object_type );
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Remove an already registered taxonomy from an object type.
|
|
*
|
|
* @since 3.7.0
|
|
*
|
|
* @global array $wp_taxonomies The registered taxonomies.
|
|
*
|
|
* @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;
|
|
}
|
|
|
|
//
|
|
// Term API
|
|
//
|
|
|
|
/**
|
|
* Retrieve object_ids of valid taxonomy and term.
|
|
*
|
|
* The strings of $taxonomies must exist before this function will continue. On
|
|
* failure of finding a valid taxonomy, it will return an WP_Error class, kind
|
|
* of like Exceptions in PHP 5, except you can't catch them. Even so, you can
|
|
* still test for the WP_Error class and get the error message.
|
|
*
|
|
* The $terms aren't checked the same as $taxonomies, but still need to exist
|
|
* for $object_ids to be returned.
|
|
*
|
|
* It is possible to change the order that object_ids is returned by either
|
|
* using PHP sort family functions or using the database by using $args with
|
|
* either ASC or DESC array. The value should be in the key named 'order'.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @global wpdb $wpdb WordPress database abstraction object.
|
|
*
|
|
* @param int|array $term_ids Term id or array of term ids of terms that will be used.
|
|
* @param string|array $taxonomies String of taxonomy name or Array of string values of taxonomy names.
|
|
* @param array|string $args Change the order of the object_ids, either ASC or DESC.
|
|
* @return WP_Error|array If the taxonomy does not exist, then WP_Error will be returned. On success.
|
|
* the array can be empty meaning that there are no $object_ids found or it will return the $object_ids found.
|
|
*/
|
|
function get_objects_in_term( $term_ids, $taxonomies, $args = array() ) {
|
|
global $wpdb;
|
|
|
|
if ( ! is_array( $term_ids ) ) {
|
|
$term_ids = array( $term_ids );
|
|
}
|
|
if ( ! is_array( $taxonomies ) ) {
|
|
$taxonomies = array( $taxonomies );
|
|
}
|
|
foreach ( (array) $taxonomies as $taxonomy ) {
|
|
if ( ! taxonomy_exists( $taxonomy ) ) {
|
|
return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy' ) );
|
|
}
|
|
}
|
|
|
|
$defaults = array( 'order' => 'ASC' );
|
|
$args = wp_parse_args( $args, $defaults );
|
|
|
|
$order = ( 'desc' == strtolower( $args['order'] ) ) ? 'DESC' : 'ASC';
|
|
|
|
$term_ids = array_map('intval', $term_ids );
|
|
|
|
$taxonomies = "'" . implode( "', '", array_map( 'esc_sql', $taxonomies ) ) . "'";
|
|
$term_ids = "'" . implode( "', '", $term_ids ) . "'";
|
|
|
|
$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");
|
|
|
|
if ( ! $object_ids ){
|
|
return array();
|
|
}
|
|
return $object_ids;
|
|
}
|
|
|
|
/**
|
|
* Given a taxonomy query, generates SQL to be appended to a main query.
|
|
*
|
|
* @since 3.1.0
|
|
*
|
|
* @see WP_Tax_Query
|
|
*
|
|
* @param array $tax_query A compact tax query
|
|
* @param string $primary_table
|
|
* @param string $primary_id_column
|
|
* @return array
|
|
*/
|
|
function get_tax_sql( $tax_query, $primary_table, $primary_id_column ) {
|
|
$tax_query_obj = new WP_Tax_Query( $tax_query );
|
|
return $tax_query_obj->get_sql( $primary_table, $primary_id_column );
|
|
}
|
|
|
|
/**
|
|
* Class for generating SQL clauses that filter a primary query according to object taxonomy terms.
|
|
*
|
|
* `WP_Tax_Query` is a helper that allows primary query classes, such as WP_Query, to filter
|
|
* their results by object metadata, by generating `JOIN` and `WHERE` subclauses to be attached
|
|
* to the primary SQL query string.
|
|
*
|
|
* @since 3.1.0
|
|
*/
|
|
class WP_Tax_Query {
|
|
|
|
/**
|
|
* Array of taxonomy queries.
|
|
*
|
|
* See {@see WP_Tax_Query::__construct()} for information on tax query arguments.
|
|
*
|
|
* @since 3.1.0
|
|
* @access public
|
|
* @var array
|
|
*/
|
|
public $queries = array();
|
|
|
|
/**
|
|
* The relation between the queries. Can be one of 'AND' or 'OR'.
|
|
*
|
|
* @since 3.1.0
|
|
* @access public
|
|
* @var string
|
|
*/
|
|
public $relation;
|
|
|
|
/**
|
|
* Standard response when the query should not return any rows.
|
|
*
|
|
* @since 3.2.0
|
|
*
|
|
* @static
|
|
* @access private
|
|
* @var string
|
|
*/
|
|
private static $no_results = array( 'join' => array( '' ), 'where' => array( '0 = 1' ) );
|
|
|
|
/**
|
|
* A flat list of table aliases used in the JOIN clauses.
|
|
*
|
|
* @since 4.1.0
|
|
* @access protected
|
|
* @var array
|
|
*/
|
|
protected $table_aliases = array();
|
|
|
|
/**
|
|
* Terms and taxonomies fetched by this query.
|
|
*
|
|
* We store this data in a flat array because they are referenced in a
|
|
* number of places by WP_Query.
|
|
*
|
|
* @since 4.1.0
|
|
* @access public
|
|
* @var array
|
|
*/
|
|
public $queried_terms = array();
|
|
|
|
/**
|
|
* Database table that where the metadata's objects are stored (eg $wpdb->users).
|
|
*
|
|
* @since 4.1.0
|
|
* @access public
|
|
* @var string
|
|
*/
|
|
public $primary_table;
|
|
|
|
/**
|
|
* Column in 'primary_table' that represents the ID of the object.
|
|
*
|
|
* @since 4.1.0
|
|
* @access public
|
|
* @var string
|
|
*/
|
|
public $primary_id_column;
|
|
|
|
/**
|
|
* Constructor.
|
|
*
|
|
* @since 3.1.0
|
|
* @since 4.1.0 Added support for `$operator` 'NOT EXISTS' and 'EXISTS' values.
|
|
* @access public
|
|
*
|
|
* @param array $tax_query {
|
|
* Array of taxonomy query clauses.
|
|
*
|
|
* @type string $relation Optional. The MySQL keyword used to join
|
|
* the clauses of the query. Accepts 'AND', or 'OR'. Default 'AND'.
|
|
* @type array {
|
|
* Optional. An array of first-order clause parameters, or another fully-formed tax query.
|
|
*
|
|
* @type string $taxonomy Taxonomy being queried. Optional when field=term_taxonomy_id.
|
|
* @type string|int|array $terms Term or terms to filter by.
|
|
* @type string $field Field to match $terms against. Accepts 'term_id', 'slug',
|
|
* 'name', or 'term_taxonomy_id'. Default: 'term_id'.
|
|
* @type string $operator MySQL operator to be used with $terms in the WHERE clause.
|
|
* Accepts 'AND', 'IN', 'NOT IN', 'EXISTS', 'NOT EXISTS'.
|
|
* Default: 'IN'.
|
|
* @type bool $include_children Optional. Whether to include child terms.
|
|
* Requires a $taxonomy. Default: true.
|
|
* }
|
|
* }
|
|
*/
|
|
public function __construct( $tax_query ) {
|
|
if ( isset( $tax_query['relation'] ) ) {
|
|
$this->relation = $this->sanitize_relation( $tax_query['relation'] );
|
|
} else {
|
|
$this->relation = 'AND';
|
|
}
|
|
|
|
$this->queries = $this->sanitize_query( $tax_query );
|
|
}
|
|
|
|
/**
|
|
* Ensure the 'tax_query' argument passed to the class constructor is well-formed.
|
|
*
|
|
* Ensures that each query-level clause has a 'relation' key, and that
|
|
* each first-order clause contains all the necessary keys from `$defaults`.
|
|
*
|
|
* @since 4.1.0
|
|
* @access public
|
|
*
|
|
* @param array $queries Array of queries clauses.
|
|
* @return array Sanitized array of query clauses.
|
|
*/
|
|
public function sanitize_query( $queries ) {
|
|
$cleaned_query = array();
|
|
|
|
$defaults = array(
|
|
'taxonomy' => '',
|
|
'terms' => array(),
|
|
'field' => 'term_id',
|
|
'operator' => 'IN',
|
|
'include_children' => true,
|
|
);
|
|
|
|
foreach ( $queries as $key => $query ) {
|
|
if ( 'relation' === $key ) {
|
|
$cleaned_query['relation'] = $this->sanitize_relation( $query );
|
|
|
|
// First-order clause.
|
|
} elseif ( self::is_first_order_clause( $query ) ) {
|
|
|
|
$cleaned_clause = array_merge( $defaults, $query );
|
|
$cleaned_clause['terms'] = (array) $cleaned_clause['terms'];
|
|
$cleaned_query[] = $cleaned_clause;
|
|
|
|
/*
|
|
* Keep a copy of the clause in the flate
|
|
* $queried_terms array, for use in WP_Query.
|
|
*/
|
|
if ( ! empty( $cleaned_clause['taxonomy'] ) && 'NOT IN' !== $cleaned_clause['operator'] ) {
|
|
$taxonomy = $cleaned_clause['taxonomy'];
|
|
if ( ! isset( $this->queried_terms[ $taxonomy ] ) ) {
|
|
$this->queried_terms[ $taxonomy ] = array();
|
|
}
|
|
|
|
/*
|
|
* Backward compatibility: Only store the first
|
|
* 'terms' and 'field' found for a given taxonomy.
|
|
*/
|
|
if ( ! empty( $cleaned_clause['terms'] ) && ! isset( $this->queried_terms[ $taxonomy ]['terms'] ) ) {
|
|
$this->queried_terms[ $taxonomy ]['terms'] = $cleaned_clause['terms'];
|
|
}
|
|
|
|
if ( ! empty( $cleaned_clause['field'] ) && ! isset( $this->queried_terms[ $taxonomy ]['field'] ) ) {
|
|
$this->queried_terms[ $taxonomy ]['field'] = $cleaned_clause['field'];
|
|
}
|
|
}
|
|
|
|
// Otherwise, it's a nested query, so we recurse.
|
|
} elseif ( is_array( $query ) ) {
|
|
$cleaned_subquery = $this->sanitize_query( $query );
|
|
|
|
if ( ! empty( $cleaned_subquery ) ) {
|
|
// All queries with children must have a relation.
|
|
if ( ! isset( $cleaned_subquery['relation'] ) ) {
|
|
$cleaned_subquery['relation'] = 'AND';
|
|
}
|
|
|
|
$cleaned_query[] = $cleaned_subquery;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $cleaned_query;
|
|
}
|
|
|
|
/**
|
|
* Sanitize a 'relation' operator.
|
|
*
|
|
* @since 4.1.0
|
|
* @access public
|
|
*
|
|
* @param string $relation Raw relation key from the query argument.
|
|
* @return string Sanitized relation ('AND' or 'OR').
|
|
*/
|
|
public function sanitize_relation( $relation ) {
|
|
if ( 'OR' === strtoupper( $relation ) ) {
|
|
return 'OR';
|
|
} else {
|
|
return 'AND';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Determine whether a clause is first-order.
|
|
*
|
|
* A "first-order" clause is one that contains any of the first-order
|
|
* clause keys ('terms', 'taxonomy', 'include_children', 'field',
|
|
* 'operator'). An empty clause also counts as a first-order clause,
|
|
* for backward compatibility. Any clause that doesn't meet this is
|
|
* determined, by process of elimination, to be a higher-order query.
|
|
*
|
|
* @since 4.1.0
|
|
*
|
|
* @static
|
|
* @access protected
|
|
*
|
|
* @param array $query Tax query arguments.
|
|
* @return bool Whether the query clause is a first-order clause.
|
|
*/
|
|
protected static function is_first_order_clause( $query ) {
|
|
return is_array( $query ) && ( empty( $query ) || array_key_exists( 'terms', $query ) || array_key_exists( 'taxonomy', $query ) || array_key_exists( 'include_children', $query ) || array_key_exists( 'field', $query ) || array_key_exists( 'operator', $query ) );
|
|
}
|
|
|
|
/**
|
|
* Generates SQL clauses to be appended to a main query.
|
|
*
|
|
* @since 3.1.0
|
|
*
|
|
* @static
|
|
* @access public
|
|
*
|
|
* @param string $primary_table Database table where the object being filtered is stored (eg wp_users).
|
|
* @param string $primary_id_column ID column for the filtered object in $primary_table.
|
|
* @return array {
|
|
* Array containing JOIN and WHERE SQL clauses to append to the main query.
|
|
*
|
|
* @type string $join SQL fragment to append to the main JOIN clause.
|
|
* @type string $where SQL fragment to append to the main WHERE clause.
|
|
* }
|
|
*/
|
|
public function get_sql( $primary_table, $primary_id_column ) {
|
|
$this->primary_table = $primary_table;
|
|
$this->primary_id_column = $primary_id_column;
|
|
|
|
return $this->get_sql_clauses();
|
|
}
|
|
|
|
/**
|
|
* Generate SQL clauses to be appended to a main query.
|
|
*
|
|
* Called by the public WP_Tax_Query::get_sql(), this method
|
|
* is abstracted out to maintain parity with the other Query classes.
|
|
*
|
|
* @since 4.1.0
|
|
* @access protected
|
|
*
|
|
* @return array {
|
|
* Array containing JOIN and WHERE SQL clauses to append to the main query.
|
|
*
|
|
* @type string $join SQL fragment to append to the main JOIN clause.
|
|
* @type string $where SQL fragment to append to the main WHERE clause.
|
|
* }
|
|
*/
|
|
protected function get_sql_clauses() {
|
|
/*
|
|
* $queries are passed by reference to get_sql_for_query() for recursion.
|
|
* To keep $this->queries unaltered, pass a copy.
|
|
*/
|
|
$queries = $this->queries;
|
|
$sql = $this->get_sql_for_query( $queries );
|
|
|
|
if ( ! empty( $sql['where'] ) ) {
|
|
$sql['where'] = ' AND ' . $sql['where'];
|
|
}
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Generate SQL clauses for a single query array.
|
|
*
|
|
* If nested subqueries are found, this method recurses the tree to
|
|
* produce the properly nested SQL.
|
|
*
|
|
* @since 4.1.0
|
|
* @access protected
|
|
*
|
|
* @param array $query Query to parse, passed by reference.
|
|
* @param int $depth Optional. Number of tree levels deep we currently are.
|
|
* Used to calculate indentation. Default 0.
|
|
* @return array {
|
|
* Array containing JOIN and WHERE SQL clauses to append to a single query array.
|
|
*
|
|
* @type string $join SQL fragment to append to the main JOIN clause.
|
|
* @type string $where SQL fragment to append to the main WHERE clause.
|
|
* }
|
|
*/
|
|
protected function get_sql_for_query( &$query, $depth = 0 ) {
|
|
$sql_chunks = array(
|
|
'join' => array(),
|
|
'where' => array(),
|
|
);
|
|
|
|
$sql = array(
|
|
'join' => '',
|
|
'where' => '',
|
|
);
|
|
|
|
$indent = '';
|
|
for ( $i = 0; $i < $depth; $i++ ) {
|
|
$indent .= " ";
|
|
}
|
|
|
|
foreach ( $query as $key => &$clause ) {
|
|
if ( 'relation' === $key ) {
|
|
$relation = $query['relation'];
|
|
} elseif ( is_array( $clause ) ) {
|
|
|
|
// This is a first-order clause.
|
|
if ( $this->is_first_order_clause( $clause ) ) {
|
|
$clause_sql = $this->get_sql_for_clause( $clause, $query );
|
|
|
|
$where_count = count( $clause_sql['where'] );
|
|
if ( ! $where_count ) {
|
|
$sql_chunks['where'][] = '';
|
|
} elseif ( 1 === $where_count ) {
|
|
$sql_chunks['where'][] = $clause_sql['where'][0];
|
|
} else {
|
|
$sql_chunks['where'][] = '( ' . implode( ' AND ', $clause_sql['where'] ) . ' )';
|
|
}
|
|
|
|
$sql_chunks['join'] = array_merge( $sql_chunks['join'], $clause_sql['join'] );
|
|
// This is a subquery, so we recurse.
|
|
} else {
|
|
$clause_sql = $this->get_sql_for_query( $clause, $depth + 1 );
|
|
|
|
$sql_chunks['where'][] = $clause_sql['where'];
|
|
$sql_chunks['join'][] = $clause_sql['join'];
|
|
}
|
|
}
|
|
}
|
|
|
|
// Filter to remove empties.
|
|
$sql_chunks['join'] = array_filter( $sql_chunks['join'] );
|
|
$sql_chunks['where'] = array_filter( $sql_chunks['where'] );
|
|
|
|
if ( empty( $relation ) ) {
|
|
$relation = 'AND';
|
|
}
|
|
|
|
// Filter duplicate JOIN clauses and combine into a single string.
|
|
if ( ! empty( $sql_chunks['join'] ) ) {
|
|
$sql['join'] = implode( ' ', array_unique( $sql_chunks['join'] ) );
|
|
}
|
|
|
|
// Generate a single WHERE clause with proper brackets and indentation.
|
|
if ( ! empty( $sql_chunks['where'] ) ) {
|
|
$sql['where'] = '( ' . "\n " . $indent . implode( ' ' . "\n " . $indent . $relation . ' ' . "\n " . $indent, $sql_chunks['where'] ) . "\n" . $indent . ')';
|
|
}
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Generate SQL JOIN and WHERE clauses for a "first-order" query clause.
|
|
*
|
|
* @since 4.1.0
|
|
* @access public
|
|
*
|
|
* @global wpdb $wpdb The WordPress database abstraction object.
|
|
*
|
|
* @param array $clause Query clause, passed by reference.
|
|
* @param array $parent_query Parent query array.
|
|
* @return array {
|
|
* Array containing JOIN and WHERE SQL clauses to append to a first-order query.
|
|
*
|
|
* @type string $join SQL fragment to append to the main JOIN clause.
|
|
* @type string $where SQL fragment to append to the main WHERE clause.
|
|
* }
|
|
*/
|
|
public function get_sql_for_clause( &$clause, $parent_query ) {
|
|
global $wpdb;
|
|
|
|
$sql = array(
|
|
'where' => array(),
|
|
'join' => array(),
|
|
);
|
|
|
|
$join = $where = '';
|
|
|
|
$this->clean_query( $clause );
|
|
|
|
if ( is_wp_error( $clause ) ) {
|
|
return self::$no_results;
|
|
}
|
|
|
|
$terms = $clause['terms'];
|
|
$operator = strtoupper( $clause['operator'] );
|
|
|
|
if ( 'IN' == $operator ) {
|
|
|
|
if ( empty( $terms ) ) {
|
|
return self::$no_results;
|
|
}
|
|
|
|
$terms = implode( ',', $terms );
|
|
|
|
/*
|
|
* Before creating another table join, see if this clause has a
|
|
* sibling with an existing join that can be shared.
|
|
*/
|
|
$alias = $this->find_compatible_table_alias( $clause, $parent_query );
|
|
if ( false === $alias ) {
|
|
$i = count( $this->table_aliases );
|
|
$alias = $i ? 'tt' . $i : $wpdb->term_relationships;
|
|
|
|
// Store the alias as part of a flat array to build future iterators.
|
|
$this->table_aliases[] = $alias;
|
|
|
|
// Store the alias with this clause, so later siblings can use it.
|
|
$clause['alias'] = $alias;
|
|
|
|
$join .= " INNER JOIN $wpdb->term_relationships";
|
|
$join .= $i ? " AS $alias" : '';
|
|
$join .= " ON ($this->primary_table.$this->primary_id_column = $alias.object_id)";
|
|
}
|
|
|
|
|
|
$where = "$alias.term_taxonomy_id $operator ($terms)";
|
|
|
|
} elseif ( 'NOT IN' == $operator ) {
|
|
|
|
if ( empty( $terms ) ) {
|
|
return $sql;
|
|
}
|
|
|
|
$terms = implode( ',', $terms );
|
|
|
|
$where = "$this->primary_table.$this->primary_id_column NOT IN (
|
|
SELECT object_id
|
|
FROM $wpdb->term_relationships
|
|
WHERE term_taxonomy_id IN ($terms)
|
|
)";
|
|
|
|
} elseif ( 'AND' == $operator ) {
|
|
|
|
if ( empty( $terms ) ) {
|
|
return $sql;
|
|
}
|
|
|
|
$num_terms = count( $terms );
|
|
|
|
$terms = implode( ',', $terms );
|
|
|
|
$where = "(
|
|
SELECT COUNT(1)
|
|
FROM $wpdb->term_relationships
|
|
WHERE term_taxonomy_id IN ($terms)
|
|
AND object_id = $this->primary_table.$this->primary_id_column
|
|
) = $num_terms";
|
|
|
|
} elseif ( 'NOT EXISTS' === $operator || 'EXISTS' === $operator ) {
|
|
|
|
$where = $wpdb->prepare( "$operator (
|
|
SELECT 1
|
|
FROM $wpdb->term_relationships
|
|
INNER JOIN $wpdb->term_taxonomy
|
|
ON $wpdb->term_taxonomy.term_taxonomy_id = $wpdb->term_relationships.term_taxonomy_id
|
|
WHERE $wpdb->term_taxonomy.taxonomy = %s
|
|
AND $wpdb->term_relationships.object_id = $this->primary_table.$this->primary_id_column
|
|
)", $clause['taxonomy'] );
|
|
|
|
}
|
|
|
|
$sql['join'][] = $join;
|
|
$sql['where'][] = $where;
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Identify an existing table alias that is compatible with the current query clause.
|
|
*
|
|
* We avoid unnecessary table joins by allowing each clause to look for
|
|
* an existing table alias that is compatible with the query that it
|
|
* needs to perform.
|
|
*
|
|
* An existing alias is compatible if (a) it is a sibling of `$clause`
|
|
* (ie, it's under the scope of the same relation), and (b) the combination
|
|
* of operator and relation between the clauses allows for a shared table
|
|
* join. In the case of WP_Tax_Query, this only applies to 'IN'
|
|
* clauses that are connected by the relation 'OR'.
|
|
*
|
|
* @since 4.1.0
|
|
* @access protected
|
|
*
|
|
* @param array $clause Query clause.
|
|
* @param array $parent_query Parent query of $clause.
|
|
* @return string|false Table alias if found, otherwise false.
|
|
*/
|
|
protected function find_compatible_table_alias( $clause, $parent_query ) {
|
|
$alias = false;
|
|
|
|
// Sanity check. Only IN queries use the JOIN syntax .
|
|
if ( ! isset( $clause['operator'] ) || 'IN' !== $clause['operator'] ) {
|
|
return $alias;
|
|
}
|
|
|
|
// Since we're only checking IN queries, we're only concerned with OR relations.
|
|
if ( ! isset( $parent_query['relation'] ) || 'OR' !== $parent_query['relation'] ) {
|
|
return $alias;
|
|
}
|
|
|
|
$compatible_operators = array( 'IN' );
|
|
|
|
foreach ( $parent_query as $sibling ) {
|
|
if ( ! is_array( $sibling ) || ! $this->is_first_order_clause( $sibling ) ) {
|
|
continue;
|
|
}
|
|
|
|
if ( empty( $sibling['alias'] ) || empty( $sibling['operator'] ) ) {
|
|
continue;
|
|
}
|
|
|
|
// The sibling must both have compatible operator to share its alias.
|
|
if ( in_array( strtoupper( $sibling['operator'] ), $compatible_operators ) ) {
|
|
$alias = $sibling['alias'];
|
|
break;
|
|
}
|
|
}
|
|
|
|
return $alias;
|
|
}
|
|
|
|
/**
|
|
* Validates a single query.
|
|
*
|
|
* @since 3.2.0
|
|
* @access private
|
|
*
|
|
* @param array &$query The single query.
|
|
*/
|
|
private function clean_query( &$query ) {
|
|
if ( empty( $query['taxonomy'] ) ) {
|
|
if ( 'term_taxonomy_id' !== $query['field'] ) {
|
|
$query = new WP_Error( 'Invalid taxonomy' );
|
|
return;
|
|
}
|
|
|
|
// so long as there are shared terms, include_children requires that a taxonomy is set
|
|
$query['include_children'] = false;
|
|
} elseif ( ! 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
|
|
*
|
|
* @global wpdb $wpdb The WordPress database abstraction object.
|
|
*
|
|
* @param array &$query The single query.
|
|
* @param string $resulting_field The resulting field. Accepts 'slug', 'name', 'term_taxonomy_id',
|
|
* or 'term_id'. Default 'term_id'.
|
|
*/
|
|
public function transform_query( &$query, $resulting_field ) {
|
|
global $wpdb;
|
|
|
|
if ( empty( $query['terms'] ) )
|
|
return;
|
|
|
|
if ( $query['field'] == $resulting_field )
|
|
return;
|
|
|
|
$resulting_field = sanitize_key( $resulting_field );
|
|
|
|
switch ( $query['field'] ) {
|
|
case 'slug':
|
|
case 'name':
|
|
foreach ( $query['terms'] as &$term ) {
|
|
/*
|
|
* 0 is the $term_id parameter. We don't have a term ID yet, but it doesn't
|
|
* matter because `sanitize_term_field()` ignores the $term_id param when the
|
|
* context is 'db'.
|
|
*/
|
|
$term = "'" . esc_sql( sanitize_term_field( $query['field'], $term, 0, $query['taxonomy'], 'db' ) ) . "'";
|
|
}
|
|
|
|
$terms = implode( ",", $query['terms'] );
|
|
|
|
$terms = $wpdb->get_col( "
|
|
SELECT $wpdb->term_taxonomy.$resulting_field
|
|
FROM $wpdb->term_taxonomy
|
|
INNER JOIN $wpdb->terms USING (term_id)
|
|
WHERE taxonomy = '{$query['taxonomy']}'
|
|
AND $wpdb->terms.{$query['field']} IN ($terms)
|
|
" );
|
|
break;
|
|
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;
|
|
default:
|
|
$terms = implode( ',', array_map( 'intval', $query['terms'] ) );
|
|
$terms = $wpdb->get_col( "
|
|
SELECT $resulting_field
|
|
FROM $wpdb->term_taxonomy
|
|
WHERE taxonomy = '{$query['taxonomy']}'
|
|
AND term_id IN ($terms)
|
|
" );
|
|
}
|
|
|
|
if ( 'AND' == $query['operator'] && count( $terms ) < count( $query['terms'] ) ) {
|
|
$query = new WP_Error( 'Inexistent terms' );
|
|
return;
|
|
}
|
|
|
|
$query['terms'] = $terms;
|
|
$query['field'] = $resulting_field;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get all Term data from database by Term ID.
|
|
*
|
|
* The usage of the get_term function is to apply filters to a term object. It
|
|
* is possible to get a term object from the database before applying the
|
|
* filters.
|
|
*
|
|
* $term ID must be part of $taxonomy, to get from the database. Failure, might
|
|
* be able to be captured by the hooks. Failure would be the same value as $wpdb
|
|
* returns for the get_row method.
|
|
*
|
|
* There are two hooks, one is specifically for each term, named 'get_term', and
|
|
* the second is for the taxonomy name, 'term_$taxonomy'. Both hooks gets the
|
|
* term object, and the taxonomy name as parameters. Both hooks are expected to
|
|
* return a Term object.
|
|
*
|
|
* {@see '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.
|
|
*
|
|
* {@see '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.
|
|
*
|
|
* @todo Better formatting for DocBlock
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @global wpdb $wpdb WordPress database abstraction object.
|
|
* @see sanitize_term_field() The $context param lists the available values for get_term_by() $filter param.
|
|
*
|
|
* @param int|object $term If integer, will get from database. If object will apply filters and return $term.
|
|
* @param string $taxonomy Taxonomy name that $term is part of.
|
|
* @param string $output Constant OBJECT, ARRAY_A, or ARRAY_N
|
|
* @param string $filter Optional, default is raw or no WordPress defined filter will applied.
|
|
* @return object|array|null|WP_Error Term Row from database. Will return null if $term is empty. If taxonomy does not
|
|
* exist then WP_Error will be returned.
|
|
*/
|
|
function get_term($term, $taxonomy, $output = OBJECT, $filter = 'raw') {
|
|
global $wpdb;
|
|
|
|
if ( empty( $term ) ) {
|
|
return new WP_Error( 'invalid_term', __( 'Empty Term' ) );
|
|
}
|
|
|
|
if ( ! taxonomy_exists( $taxonomy ) ) {
|
|
return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy' ) );
|
|
}
|
|
|
|
if ( is_object($term) && empty($term->filter) ) {
|
|
wp_cache_add( $term->term_id, $term, $taxonomy );
|
|
$_term = $term;
|
|
} else {
|
|
if ( is_object($term) )
|
|
$term = $term->term_id;
|
|
if ( !$term = (int) $term )
|
|
return null;
|
|
if ( ! $_term = wp_cache_get( $term, $taxonomy ) ) {
|
|
$_term = $wpdb->get_row( $wpdb->prepare( "SELECT t.*, tt.* FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id WHERE tt.taxonomy = %s AND t.term_id = %d LIMIT 1", $taxonomy, $term) );
|
|
if ( ! $_term )
|
|
return null;
|
|
wp_cache_add( $term, $_term, $taxonomy );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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 );
|
|
$_term = sanitize_term($_term, $taxonomy, $filter);
|
|
|
|
if ( $output == OBJECT ) {
|
|
return $_term;
|
|
} elseif ( $output == ARRAY_A ) {
|
|
$__term = get_object_vars($_term);
|
|
return $__term;
|
|
} elseif ( $output == ARRAY_N ) {
|
|
$__term = array_values(get_object_vars($_term));
|
|
return $__term;
|
|
} else {
|
|
return $_term;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get all Term data from database by Term field and data.
|
|
*
|
|
* Warning: $value is not escaped for 'name' $field. You must do it yourself, if
|
|
* required.
|
|
*
|
|
* The default $field is 'id', therefore it is possible to also use null for
|
|
* field, but not recommended that you do so.
|
|
*
|
|
* If $value does not exist, the return value will be false. If $taxonomy exists
|
|
* and $field and $value combinations exist, the Term will be returned.
|
|
*
|
|
* @todo Better formatting for DocBlock.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @global wpdb $wpdb WordPress database abstraction object.
|
|
* @see sanitize_term_field() The $context param lists the available values for get_term_by() $filter param.
|
|
*
|
|
* @param string $field Either 'slug', 'name', 'id' (term_id), or 'term_taxonomy_id'
|
|
* @param string|int $value Search for this term value
|
|
* @param string $taxonomy Taxonomy Name
|
|
* @param string $output Constant OBJECT, ARRAY_A, or ARRAY_N
|
|
* @param string $filter Optional, default is raw or no WordPress defined filter will applied.
|
|
* @return object|array|null|WP_Error|false Term Row from database.
|
|
* Will return false if $taxonomy does not exist or $term was not found.
|
|
*/
|
|
function get_term_by($field, $value, $taxonomy, $output = OBJECT, $filter = 'raw') {
|
|
global $wpdb;
|
|
|
|
if ( ! taxonomy_exists($taxonomy) )
|
|
return false;
|
|
|
|
if ( 'slug' == $field ) {
|
|
$field = 't.slug';
|
|
$value = sanitize_title($value);
|
|
if ( empty($value) )
|
|
return false;
|
|
} elseif ( 'name' == $field ) {
|
|
// Assume already escaped
|
|
$value = wp_unslash($value);
|
|
$field = 't.name';
|
|
} elseif ( 'term_taxonomy_id' == $field ) {
|
|
$value = (int) $value;
|
|
$field = 'tt.term_taxonomy_id';
|
|
} else {
|
|
$term = get_term( (int) $value, $taxonomy, $output, $filter );
|
|
if ( is_wp_error( $term ) )
|
|
$term = false;
|
|
return $term;
|
|
}
|
|
|
|
$term = $wpdb->get_row( $wpdb->prepare( "SELECT t.*, tt.* FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id WHERE tt.taxonomy = %s AND $field = %s LIMIT 1", $taxonomy, $value ) );
|
|
if ( ! $term )
|
|
return false;
|
|
|
|
wp_cache_add( $term->term_id, $term, $taxonomy );
|
|
|
|
/** 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 );
|
|
|
|
$term = sanitize_term($term, $taxonomy, $filter);
|
|
|
|
if ( $output == OBJECT ) {
|
|
return $term;
|
|
} elseif ( $output == ARRAY_A ) {
|
|
return get_object_vars($term);
|
|
} elseif ( $output == ARRAY_N ) {
|
|
return array_values(get_object_vars($term));
|
|
} else {
|
|
return $term;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Merge all term children into a single array of their IDs.
|
|
*
|
|
* This recursive function will merge all of the children of $term into the same
|
|
* array of term IDs. Only useful for taxonomies which are hierarchical.
|
|
*
|
|
* Will return an empty array if $term does not exist in $taxonomy.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @param string $term_id ID of Term to get children.
|
|
* @param string $taxonomy Taxonomy Name.
|
|
* @return array|WP_Error List of Term IDs. WP_Error returned if `$taxonomy` does not exist.
|
|
*/
|
|
function get_term_children( $term_id, $taxonomy ) {
|
|
if ( ! taxonomy_exists($taxonomy) )
|
|
return new WP_Error('invalid_taxonomy', __('Invalid taxonomy'));
|
|
|
|
$term_id = intval( $term_id );
|
|
|
|
$terms = _get_term_hierarchy($taxonomy);
|
|
|
|
if ( ! isset($terms[$term_id]) )
|
|
return array();
|
|
|
|
$children = $terms[$term_id];
|
|
|
|
foreach ( (array) $terms[$term_id] as $child ) {
|
|
if ( $term_id == $child ) {
|
|
continue;
|
|
}
|
|
|
|
if ( isset($terms[$child]) )
|
|
$children = array_merge($children, get_term_children($child, $taxonomy));
|
|
}
|
|
|
|
return $children;
|
|
}
|
|
|
|
/**
|
|
* Get sanitized Term field.
|
|
*
|
|
* 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.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @param string $field Term field to fetch.
|
|
* @param int $term Term ID.
|
|
* @param string $taxonomy Taxonomy Name.
|
|
* @param string $context Optional, default is display. Look at sanitize_term_field() for available options.
|
|
* @return string|int|null|WP_Error Will return an empty string if $term is not an object or if $field is not set in $term.
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/**
|
|
* Sanitizes Term for editing.
|
|
*
|
|
* Return value is sanitize_term() and usage is for sanitizing the term for
|
|
* editing. Function is for contextual and simplicity.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @param int|object $id Term ID or object.
|
|
* @param string $taxonomy Taxonomy name.
|
|
* @return string|int|null|WP_Error Will return empty string if $term is not an object.
|
|
*/
|
|
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');
|
|
}
|
|
|
|
/**
|
|
* Retrieve the terms in a given taxonomy or list of taxonomies.
|
|
*
|
|
* You can fully inject any customizations to the query before it is sent, as
|
|
* well as control the output with a filter.
|
|
*
|
|
* The {@see '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.
|
|
*
|
|
* The {@see 'list_terms_exclusions'} filter passes the compiled exclusions along with
|
|
* the $args.
|
|
*
|
|
* The {@see 'get_terms_orderby'} filter passes the `ORDER BY` clause for the query
|
|
* along with the $args array.
|
|
*
|
|
* @since 2.3.0
|
|
* @since 4.2.0 Introduced 'name' and 'childless' parameters.
|
|
*
|
|
* @global wpdb $wpdb WordPress database abstraction object.
|
|
* @global array $wp_filter
|
|
*
|
|
* @param string|array $taxonomies Taxonomy name or list of Taxonomy names.
|
|
* @param array|string $args {
|
|
* Optional. Array or string of arguments to get terms.
|
|
*
|
|
* @type string $orderby Field(s) to order terms by. Accepts term fields ('name', 'slug',
|
|
* 'term_group', 'term_id', 'id', 'description'), 'count' for term
|
|
* taxonomy count, 'include' to match the 'order' of the $include param,
|
|
* or 'none' to skip ORDER BY. Defaults to 'name'.
|
|
* @type string $order Whether to order terms in ascending or descending order.
|
|
* Accepts 'ASC' (ascending) or 'DESC' (descending).
|
|
* Default 'ASC'.
|
|
* @type bool|int $hide_empty Whether to hide terms not assigned to any posts. Accepts
|
|
* 1|true or 0|false. Default 1|true.
|
|
* @type array|string $include Array or comma/space-separated string of term ids to include.
|
|
* Default empty array.
|
|
* @type array|string $exclude Array or comma/space-separated string of term ids to exclude.
|
|
* If $include is non-empty, $exclude is ignored.
|
|
* Default empty array.
|
|
* @type array|string $exclude_tree Array or comma/space-separated string of term ids to exclude
|
|
* along with all of their descendant terms. If $include is
|
|
* non-empty, $exclude_tree is ignored. Default empty array.
|
|
* @type int|string $number Maximum number of terms to return. Accepts ''|0 (all) or any
|
|
* positive number. Default ''|0 (all).
|
|
* @type int $offset The number by which to offset the terms query. Default empty.
|
|
* @type string $fields Term fields to query for. Accepts 'all' (returns an array of
|
|
* term objects), 'ids' or 'names' (returns an array of integers
|
|
* or strings, respectively. Default 'all'.
|
|
* @type string|array $name Optional. Name or array of names to return term(s) for. Default empty.
|
|
* @type string|array $slug Optional. Slug or array of slugs to return term(s) for. Default empty.
|
|
* @type bool $hierarchical Whether to include terms that have non-empty descendants (even
|
|
* if $hide_empty is set to true). Default true.
|
|
* @type string $search Search criteria to match terms. Will be SQL-formatted with
|
|
* wildcards before and after. Default empty.
|
|
* @type string $name__like Retrieve terms with criteria by which a term is LIKE $name__like.
|
|
* Default empty.
|
|
* @type string $description__like Retrieve terms where the description is LIKE $description__like.
|
|
* Default empty.
|
|
* @type bool $pad_counts Whether to pad the quantity of a term's children in the quantity
|
|
* of each term's "count" object variable. Default false.
|
|
* @type string $get Whether to return terms regardless of ancestry or whether the terms
|
|
* are empty. Accepts 'all' or empty (disabled). Default empty.
|
|
* @type int $child_of Term ID to retrieve child terms of. If multiple taxonomies
|
|
* are passed, $child_of is ignored. Default 0.
|
|
* @type int|string $parent Parent term ID to retrieve direct-child terms of. Default empty.
|
|
* @type bool $childless True to limit results to terms that have no children. This parameter has
|
|
* no effect on non-hierarchical taxonomies. Default false.
|
|
* @type string $cache_domain Unique cache key to be produced when this query is stored in an
|
|
* object cache. Default is 'core'.
|
|
* }
|
|
* @return array|int|WP_Error List of Term Objects and their children. Will return WP_Error, if any of $taxonomies
|
|
* do not exist.
|
|
*/
|
|
function get_terms( $taxonomies, $args = '' ) {
|
|
global $wpdb;
|
|
$empty_array = array();
|
|
|
|
$single_taxonomy = ! is_array( $taxonomies ) || 1 === count( $taxonomies );
|
|
if ( ! is_array( $taxonomies ) ) {
|
|
$taxonomies = array( $taxonomies );
|
|
}
|
|
|
|
foreach ( $taxonomies as $taxonomy ) {
|
|
if ( ! taxonomy_exists($taxonomy) ) {
|
|
return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy' ) );
|
|
}
|
|
}
|
|
|
|
$defaults = array('orderby' => 'name', 'order' => 'ASC',
|
|
'hide_empty' => true, 'exclude' => array(), 'exclude_tree' => array(), 'include' => array(),
|
|
'number' => '', 'fields' => 'all', 'name' => '', 'slug' => '', 'parent' => '', 'childless' => false,
|
|
'hierarchical' => true, 'child_of' => 0, 'get' => '', 'name__like' => '', 'description__like' => '',
|
|
'pad_counts' => false, 'offset' => '', 'search' => '', 'cache_domain' => 'core' );
|
|
$args = wp_parse_args( $args, $defaults );
|
|
$args['number'] = absint( $args['number'] );
|
|
$args['offset'] = absint( $args['offset'] );
|
|
|
|
// Save queries by not crawling the tree in the case of multiple taxes or a flat tax.
|
|
$has_hierarchical_tax = false;
|
|
foreach ( $taxonomies as $_tax ) {
|
|
if ( is_taxonomy_hierarchical( $_tax ) ) {
|
|
$has_hierarchical_tax = true;
|
|
}
|
|
}
|
|
|
|
if ( ! $has_hierarchical_tax ) {
|
|
$args['hierarchical'] = false;
|
|
$args['pad_counts'] = false;
|
|
}
|
|
|
|
// 'parent' overrides 'child_of'.
|
|
if ( 0 < intval( $args['parent'] ) ) {
|
|
$args['child_of'] = false;
|
|
}
|
|
|
|
if ( 'all' == $args['get'] ) {
|
|
$args['childless'] = false;
|
|
$args['child_of'] = 0;
|
|
$args['hide_empty'] = 0;
|
|
$args['hierarchical'] = false;
|
|
$args['pad_counts'] = false;
|
|
}
|
|
|
|
/**
|
|
* Filter the terms query arguments.
|
|
*
|
|
* @since 3.1.0
|
|
*
|
|
* @param array $args An array of get_term() arguments.
|
|
* @param array $taxonomies An array of taxonomies.
|
|
*/
|
|
$args = apply_filters( 'get_terms_args', $args, $taxonomies );
|
|
|
|
// Avoid the query if the queried parent/child_of term has no descendants.
|
|
$child_of = $args['child_of'];
|
|
$parent = $args['parent'];
|
|
|
|
if ( $child_of ) {
|
|
$_parent = $child_of;
|
|
} elseif ( $parent ) {
|
|
$_parent = $parent;
|
|
} else {
|
|
$_parent = false;
|
|
}
|
|
|
|
if ( $_parent ) {
|
|
$in_hierarchy = false;
|
|
foreach ( $taxonomies as $_tax ) {
|
|
$hierarchy = _get_term_hierarchy( $_tax );
|
|
|
|
if ( isset( $hierarchy[ $_parent ] ) ) {
|
|
$in_hierarchy = true;
|
|
}
|
|
}
|
|
|
|
if ( ! $in_hierarchy ) {
|
|
return $empty_array;
|
|
}
|
|
}
|
|
|
|
// $args can be whatever, only use the args defined in defaults to compute the key.
|
|
$filter_key = ( has_filter('list_terms_exclusions') ) ? serialize($GLOBALS['wp_filter']['list_terms_exclusions']) : '';
|
|
$key = md5( serialize( wp_array_slice_assoc( $args, array_keys( $defaults ) ) ) . serialize( $taxonomies ) . $filter_key );
|
|
$last_changed = wp_cache_get( 'last_changed', 'terms' );
|
|
if ( ! $last_changed ) {
|
|
$last_changed = microtime();
|
|
wp_cache_set( 'last_changed', $last_changed, 'terms' );
|
|
}
|
|
$cache_key = "get_terms:$key:$last_changed";
|
|
$cache = wp_cache_get( $cache_key, 'terms' );
|
|
if ( false !== $cache ) {
|
|
|
|
/**
|
|
* Filter the given taxonomy's terms cache.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @param array $cache Cached array of terms for the given taxonomy.
|
|
* @param array $taxonomies An array of taxonomies.
|
|
* @param array $args An array of get_terms() arguments.
|
|
*/
|
|
return apply_filters( 'get_terms', $cache, $taxonomies, $args );
|
|
}
|
|
|
|
$_orderby = strtolower( $args['orderby'] );
|
|
if ( 'count' == $_orderby ) {
|
|
$orderby = 'tt.count';
|
|
} elseif ( 'name' == $_orderby ) {
|
|
$orderby = 't.name';
|
|
} elseif ( 'slug' == $_orderby ) {
|
|
$orderby = 't.slug';
|
|
} elseif ( 'include' == $_orderby && ! empty( $args['include'] ) ) {
|
|
$include = implode( ',', array_map( 'absint', $args['include'] ) );
|
|
$orderby = "FIELD( t.term_id, $include )";
|
|
} elseif ( 'term_group' == $_orderby ) {
|
|
$orderby = 't.term_group';
|
|
} elseif ( 'description' == $_orderby ) {
|
|
$orderby = 'tt.description';
|
|
} elseif ( 'none' == $_orderby ) {
|
|
$orderby = '';
|
|
} elseif ( empty($_orderby) || 'id' == $_orderby ) {
|
|
$orderby = 't.term_id';
|
|
} else {
|
|
$orderby = 't.name';
|
|
}
|
|
|
|
/**
|
|
* 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 array $taxonomies An array of taxonomies.
|
|
*/
|
|
$orderby = apply_filters( 'get_terms_orderby', $orderby, $args, $taxonomies );
|
|
|
|
$order = strtoupper( $args['order'] );
|
|
if ( ! empty( $orderby ) ) {
|
|
$orderby = "ORDER BY $orderby";
|
|
} else {
|
|
$order = '';
|
|
}
|
|
|
|
if ( '' !== $order && ! in_array( $order, array( 'ASC', 'DESC' ) ) ) {
|
|
$order = 'ASC';
|
|
}
|
|
|
|
$where = "tt.taxonomy IN ('" . implode("', '", array_map( 'esc_sql', $taxonomies ) ) . "')";
|
|
|
|
$exclude = $args['exclude'];
|
|
$exclude_tree = $args['exclude_tree'];
|
|
$include = $args['include'];
|
|
|
|
$inclusions = '';
|
|
if ( ! empty( $include ) ) {
|
|
$exclude = '';
|
|
$exclude_tree = '';
|
|
$inclusions = implode( ',', wp_parse_id_list( $include ) );
|
|
}
|
|
|
|
if ( ! empty( $inclusions ) ) {
|
|
$inclusions = ' AND t.term_id IN ( ' . $inclusions . ' )';
|
|
$where .= $inclusions;
|
|
}
|
|
|
|
$exclusions = array();
|
|
if ( ! empty( $exclude_tree ) ) {
|
|
$exclude_tree = wp_parse_id_list( $exclude_tree );
|
|
$excluded_children = $exclude_tree;
|
|
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 ) )
|
|
);
|
|
}
|
|
$exclusions = array_merge( $excluded_children, $exclusions );
|
|
}
|
|
|
|
if ( ! empty( $exclude ) ) {
|
|
$exclusions = array_merge( wp_parse_id_list( $exclude ), $exclusions );
|
|
}
|
|
|
|
// 'childless' terms are those without an entry in the flattened term hierarchy.
|
|
$childless = (bool) $args['childless'];
|
|
if ( $childless ) {
|
|
foreach ( $taxonomies as $_tax ) {
|
|
$term_hierarchy = _get_term_hierarchy( $_tax );
|
|
$exclusions = array_merge( array_keys( $term_hierarchy ), $exclusions );
|
|
}
|
|
}
|
|
|
|
if ( ! empty( $exclusions ) ) {
|
|
$exclusions = ' AND t.term_id NOT IN (' . implode( ',', array_map( 'intval', $exclusions ) ) . ')';
|
|
} else {
|
|
$exclusions = '';
|
|
}
|
|
|
|
/**
|
|
* 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 array $taxonomies An array of taxonomies.
|
|
*/
|
|
$exclusions = apply_filters( 'list_terms_exclusions', $exclusions, $args, $taxonomies );
|
|
|
|
if ( ! empty( $exclusions ) ) {
|
|
$where .= $exclusions;
|
|
}
|
|
|
|
if ( ! empty( $args['name'] ) ) {
|
|
$names = (array) $args['name'];
|
|
foreach ( $names as &$_name ) {
|
|
$_name = sanitize_term_field( 'name', $_name, 0, reset( $taxonomies ), 'db' );
|
|
}
|
|
|
|
$where .= " AND t.name IN ('" . implode( "', '", array_map( 'esc_sql', $names ) ) . "')";
|
|
}
|
|
|
|
if ( ! empty( $args['slug'] ) ) {
|
|
if ( is_array( $args['slug'] ) ) {
|
|
$slug = array_map( 'sanitize_title', $args['slug'] );
|
|
$where .= " AND t.slug IN ('" . implode( "', '", $slug ) . "')";
|
|
} else {
|
|
$slug = sanitize_title( $args['slug'] );
|
|
$where .= " AND t.slug = '$slug'";
|
|
}
|
|
}
|
|
|
|
if ( ! empty( $args['name__like'] ) ) {
|
|
$where .= $wpdb->prepare( " AND t.name LIKE %s", '%' . $wpdb->esc_like( $args['name__like'] ) . '%' );
|
|
}
|
|
|
|
if ( ! empty( $args['description__like'] ) ) {
|
|
$where .= $wpdb->prepare( " AND tt.description LIKE %s", '%' . $wpdb->esc_like( $args['description__like'] ) . '%' );
|
|
}
|
|
|
|
if ( '' !== $parent ) {
|
|
$parent = (int) $parent;
|
|
$where .= " AND tt.parent = '$parent'";
|
|
}
|
|
|
|
$hierarchical = $args['hierarchical'];
|
|
if ( 'count' == $args['fields'] ) {
|
|
$hierarchical = false;
|
|
}
|
|
if ( $args['hide_empty'] && !$hierarchical ) {
|
|
$where .= ' AND tt.count > 0';
|
|
}
|
|
|
|
$number = $args['number'];
|
|
$offset = $args['offset'];
|
|
|
|
// Don't limit the query results when we have to descend the family tree.
|
|
if ( $number && ! $hierarchical && ! $child_of && '' === $parent ) {
|
|
if ( $offset ) {
|
|
$limits = 'LIMIT ' . $offset . ',' . $number;
|
|
} else {
|
|
$limits = 'LIMIT ' . $number;
|
|
}
|
|
} else {
|
|
$limits = '';
|
|
}
|
|
|
|
if ( ! empty( $args['search'] ) ) {
|
|
$like = '%' . $wpdb->esc_like( $args['search'] ) . '%';
|
|
$where .= $wpdb->prepare( ' AND ((t.name LIKE %s) OR (t.slug LIKE %s))', $like, $like );
|
|
}
|
|
|
|
$selects = array();
|
|
switch ( $args['fields'] ) {
|
|
case 'all':
|
|
$selects = array( 't.*', 'tt.*' );
|
|
break;
|
|
case 'ids':
|
|
case 'id=>parent':
|
|
$selects = array( 't.term_id', 'tt.parent', 'tt.count', 'tt.taxonomy' );
|
|
break;
|
|
case 'names':
|
|
$selects = array( 't.term_id', 'tt.parent', 'tt.count', 't.name', 'tt.taxonomy' );
|
|
break;
|
|
case 'count':
|
|
$orderby = '';
|
|
$order = '';
|
|
$selects = array( 'COUNT(*)' );
|
|
break;
|
|
case 'id=>name':
|
|
$selects = array( 't.term_id', 't.name', 'tt.count', 'tt.taxonomy' );
|
|
break;
|
|
case 'id=>slug':
|
|
$selects = array( 't.term_id', 't.slug', 'tt.count', 'tt.taxonomy' );
|
|
break;
|
|
}
|
|
|
|
$_fields = $args['fields'];
|
|
|
|
/**
|
|
* Filter the fields to select in the terms query.
|
|
*
|
|
* Field lists modified using this filter will only modify the term fields returned
|
|
* by the function when the `$fields` parameter set to 'count' or 'all'. In all other
|
|
* cases, the term fields in the results array will be determined by the `$fields`
|
|
* parameter alone.
|
|
*
|
|
* Use of this filter can result in unpredictable behavior, and is not recommended.
|
|
*
|
|
* @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 array $taxonomies An array of taxonomies.
|
|
*/
|
|
$fields = implode( ', ', apply_filters( 'get_terms_fields', $selects, $args, $taxonomies ) );
|
|
|
|
$join = "INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id";
|
|
|
|
$pieces = array( 'fields', 'join', 'where', 'orderby', 'order', 'limits' );
|
|
|
|
/**
|
|
* Filter the terms query SQL clauses.
|
|
*
|
|
* @since 3.1.0
|
|
*
|
|
* @param array $pieces Terms query SQL clauses.
|
|
* @param array $taxonomies An array of taxonomies.
|
|
* @param array $args An array of terms query arguments.
|
|
*/
|
|
$clauses = apply_filters( 'terms_clauses', compact( $pieces ), $taxonomies, $args );
|
|
|
|
$fields = isset( $clauses[ 'fields' ] ) ? $clauses[ 'fields' ] : '';
|
|
$join = isset( $clauses[ 'join' ] ) ? $clauses[ 'join' ] : '';
|
|
$where = isset( $clauses[ 'where' ] ) ? $clauses[ 'where' ] : '';
|
|
$orderby = isset( $clauses[ 'orderby' ] ) ? $clauses[ 'orderby' ] : '';
|
|
$order = isset( $clauses[ 'order' ] ) ? $clauses[ 'order' ] : '';
|
|
$limits = isset( $clauses[ 'limits' ] ) ? $clauses[ 'limits' ] : '';
|
|
|
|
$query = "SELECT $fields FROM $wpdb->terms AS t $join WHERE $where $orderby $order $limits";
|
|
|
|
if ( 'count' == $_fields ) {
|
|
return $wpdb->get_var( $query );
|
|
}
|
|
|
|
$terms = $wpdb->get_results($query);
|
|
if ( 'all' == $_fields ) {
|
|
update_term_cache( $terms );
|
|
}
|
|
|
|
if ( empty($terms) ) {
|
|
wp_cache_add( $cache_key, array(), 'terms', DAY_IN_SECONDS );
|
|
|
|
/** This filter is documented in wp-includes/taxonomy.php */
|
|
return apply_filters( 'get_terms', array(), $taxonomies, $args );
|
|
}
|
|
|
|
if ( $child_of ) {
|
|
foreach ( $taxonomies as $_tax ) {
|
|
$children = _get_term_hierarchy( $_tax );
|
|
if ( ! empty( $children ) ) {
|
|
$terms = _get_term_children( $child_of, $terms, $_tax );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Update term counts to include children.
|
|
if ( $args['pad_counts'] && 'all' == $_fields ) {
|
|
foreach ( $taxonomies as $_tax ) {
|
|
_pad_term_counts( $terms, $_tax );
|
|
}
|
|
}
|
|
|
|
// Make sure we show empty categories that have children.
|
|
if ( $hierarchical && $args['hide_empty'] && is_array( $terms ) ) {
|
|
foreach ( $terms as $k => $term ) {
|
|
if ( ! $term->count ) {
|
|
$children = get_term_children( $term->term_id, $term->taxonomy );
|
|
if ( is_array( $children ) ) {
|
|
foreach ( $children as $child_id ) {
|
|
$child = get_term( $child_id, $term->taxonomy );
|
|
if ( $child->count ) {
|
|
continue 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
// It really is empty.
|
|
unset($terms[$k]);
|
|
}
|
|
}
|
|
}
|
|
|
|
$_terms = array();
|
|
if ( 'id=>parent' == $_fields ) {
|
|
foreach ( $terms as $term ) {
|
|
$_terms[ $term->term_id ] = $term->parent;
|
|
}
|
|
} elseif ( 'ids' == $_fields ) {
|
|
foreach ( $terms as $term ) {
|
|
$_terms[] = $term->term_id;
|
|
}
|
|
} elseif ( 'names' == $_fields ) {
|
|
foreach ( $terms as $term ) {
|
|
$_terms[] = $term->name;
|
|
}
|
|
} elseif ( 'id=>name' == $_fields ) {
|
|
foreach ( $terms as $term ) {
|
|
$_terms[ $term->term_id ] = $term->name;
|
|
}
|
|
} elseif ( 'id=>slug' == $_fields ) {
|
|
foreach ( $terms as $term ) {
|
|
$_terms[ $term->term_id ] = $term->slug;
|
|
}
|
|
}
|
|
|
|
if ( ! empty( $_terms ) ) {
|
|
$terms = $_terms;
|
|
}
|
|
|
|
if ( $number && is_array( $terms ) && count( $terms ) > $number ) {
|
|
$terms = array_slice( $terms, $offset, $number );
|
|
}
|
|
|
|
wp_cache_add( $cache_key, $terms, 'terms', DAY_IN_SECONDS );
|
|
|
|
/** This filter is documented in wp-includes/taxonomy */
|
|
return apply_filters( 'get_terms', $terms, $taxonomies, $args );
|
|
}
|
|
|
|
/**
|
|
* Check if Term exists.
|
|
*
|
|
* Formerly is_term(), introduced in 2.3.0.
|
|
*
|
|
* @since 3.0.0
|
|
*
|
|
* @global wpdb $wpdb WordPress database abstraction object.
|
|
*
|
|
* @param int|string $term The term to check
|
|
* @param string $taxonomy The taxonomy name to use
|
|
* @param int $parent Optional. ID of parent term under which to confine the exists search.
|
|
* @return mixed Returns null 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 term taxonomy ID the taxonomy
|
|
* is specified and the pairing exists.
|
|
*/
|
|
function term_exists( $term, $taxonomy = '', $parent = null ) {
|
|
global $wpdb;
|
|
|
|
$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 ";
|
|
|
|
if ( is_int($term) ) {
|
|
if ( 0 == $term )
|
|
return 0;
|
|
$where = 't.term_id = %d';
|
|
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 ) );
|
|
}
|
|
|
|
$term = trim( wp_unslash( $term ) );
|
|
$slug = sanitize_title( $term );
|
|
|
|
$where = 't.slug = %s';
|
|
$else_where = 't.name = %s';
|
|
$where_fields = array($slug);
|
|
$else_where_fields = array($term);
|
|
$orderby = 'ORDER BY t.term_id ASC';
|
|
$limit = 'LIMIT 1';
|
|
if ( !empty($taxonomy) ) {
|
|
if ( is_numeric( $parent ) ) {
|
|
$parent = (int) $parent;
|
|
$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 $orderby $limit", $where_fields), ARRAY_A) )
|
|
return $result;
|
|
|
|
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 $orderby $limit", $else_where_fields), ARRAY_A);
|
|
}
|
|
|
|
if ( $result = $wpdb->get_var( $wpdb->prepare("SELECT term_id FROM $wpdb->terms as t WHERE $where $orderby $limit", $where_fields) ) )
|
|
return $result;
|
|
|
|
return $wpdb->get_var( $wpdb->prepare("SELECT term_id FROM $wpdb->terms as t WHERE $else_where $orderby $limit", $else_where_fields) );
|
|
}
|
|
|
|
/**
|
|
* 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 a 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 );
|
|
}
|
|
|
|
/**
|
|
* Sanitize Term all fields.
|
|
*
|
|
* Relies on sanitize_term_field() to sanitize the term. The difference is that
|
|
* this function will sanitize <strong>all</strong> fields. The context is based
|
|
* on sanitize_term_field().
|
|
*
|
|
* The $term is expected to be either an array or an object.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @param array|object $term The term to check.
|
|
* @param string $taxonomy The taxonomy name to use.
|
|
* @param string $context Optional. Context in which to sanitize the term. Accepts 'edit', 'db',
|
|
* 'display', 'attribute', or 'js'. Default 'display'.
|
|
* @return array|object Term with all fields sanitized.
|
|
*/
|
|
function sanitize_term($term, $taxonomy, $context = 'display') {
|
|
$fields = array( 'term_id', 'name', 'description', 'slug', 'count', 'parent', 'term_group', 'term_taxonomy_id', 'object_id' );
|
|
|
|
$do_object = is_object( $term );
|
|
|
|
$term_id = $do_object ? $term->term_id : (isset($term['term_id']) ? $term['term_id'] : 0);
|
|
|
|
foreach ( (array) $fields as $field ) {
|
|
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);
|
|
}
|
|
}
|
|
|
|
if ( $do_object )
|
|
$term->filter = $context;
|
|
else
|
|
$term['filter'] = $context;
|
|
|
|
return $term;
|
|
}
|
|
|
|
/**
|
|
* Cleanse the field value in the term based on the context.
|
|
*
|
|
* 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.
|
|
*
|
|
* If no context or an unsupported context is given, then default filters will
|
|
* be applied.
|
|
*
|
|
* 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.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @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 Context in which to sanitize the term field. Accepts 'edit', 'db', 'display',
|
|
* 'attribute', or 'js'.
|
|
* @return mixed Sanitized field.
|
|
*/
|
|
function sanitize_term_field($field, $value, $term_id, $taxonomy, $context) {
|
|
$int_fields = array( 'parent', 'term_id', 'count', 'term_group', 'term_taxonomy_id', 'object_id' );
|
|
if ( in_array( $field, $int_fields ) ) {
|
|
$value = (int) $value;
|
|
if ( $value < 0 )
|
|
$value = 0;
|
|
}
|
|
|
|
if ( 'raw' == $context )
|
|
return $value;
|
|
|
|
if ( 'edit' == $context ) {
|
|
|
|
/**
|
|
* 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 );
|
|
|
|
if ( 'description' == $field )
|
|
$value = esc_html($value); // textarea_escaped
|
|
else
|
|
$value = esc_attr($value);
|
|
} elseif ( 'db' == $context ) {
|
|
|
|
/**
|
|
* 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 );
|
|
|
|
// Back compat filters
|
|
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 );
|
|
}
|
|
|
|
} elseif ( 'rss' == $context ) {
|
|
|
|
/**
|
|
* 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 );
|
|
} else {
|
|
// Use display filters by default.
|
|
|
|
/**
|
|
* 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 );
|
|
}
|
|
|
|
if ( 'attribute' == $context ) {
|
|
$value = esc_attr($value);
|
|
} elseif ( 'js' == $context ) {
|
|
$value = esc_js($value);
|
|
}
|
|
return $value;
|
|
}
|
|
|
|
/**
|
|
* Count how many terms are in Taxonomy.
|
|
*
|
|
* Default $args is 'hide_empty' which can be 'hide_empty=true' or array('hide_empty' => true).
|
|
*
|
|
* @todo Document $args as a hash notation.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @param string $taxonomy Taxonomy name
|
|
* @param array|string $args Overwrite defaults. See get_terms()
|
|
* @return array|int|WP_Error How many terms are in $taxonomy. WP_Error if $taxonomy does not exist.
|
|
*/
|
|
function wp_count_terms( $taxonomy, $args = array() ) {
|
|
$defaults = array('hide_empty' => false);
|
|
$args = wp_parse_args($args, $defaults);
|
|
|
|
// backwards compatibility
|
|
if ( isset($args['ignore_empty']) ) {
|
|
$args['hide_empty'] = $args['ignore_empty'];
|
|
unset($args['ignore_empty']);
|
|
}
|
|
|
|
$args['fields'] = 'count';
|
|
|
|
return get_terms($taxonomy, $args);
|
|
}
|
|
|
|
/**
|
|
* Will unlink the object from the taxonomy or taxonomies.
|
|
*
|
|
* Will remove all relationships between the object and any terms in
|
|
* a particular taxonomy or taxonomies. Does not remove the term or
|
|
* taxonomy itself.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @param int $object_id The term Object Id that refers to the term.
|
|
* @param string|array $taxonomies List of Taxonomy Names or single Taxonomy name.
|
|
*/
|
|
function wp_delete_object_term_relationships( $object_id, $taxonomies ) {
|
|
$object_id = (int) $object_id;
|
|
|
|
if ( !is_array($taxonomies) )
|
|
$taxonomies = array($taxonomies);
|
|
|
|
foreach ( (array) $taxonomies as $taxonomy ) {
|
|
$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 );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes a term from the database.
|
|
*
|
|
* If the term is a parent of other terms, then the children will be updated to
|
|
* that term's parent.
|
|
*
|
|
* The `$args` 'default' will only override the terms found, if there is only one
|
|
* term found. Any other and the found terms are used.
|
|
*
|
|
* The $args 'force_default' will force the term supplied as default to be
|
|
* assigned even if the object was not going to be termless
|
|
*
|
|
* @todo Document $args as a hash notation.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @global wpdb $wpdb WordPress database abstraction object.
|
|
*
|
|
* @param int $term Term ID.
|
|
* @param string $taxonomy Taxonomy Name.
|
|
* @param array|string $args Optional. Change 'default' term id and override found term ids.
|
|
* @return bool|int|WP_Error Returns false if not term; true if completes delete action.
|
|
*/
|
|
function wp_delete_term( $term, $taxonomy, $args = array() ) {
|
|
global $wpdb;
|
|
|
|
$term = (int) $term;
|
|
|
|
if ( ! $ids = term_exists($term, $taxonomy) )
|
|
return false;
|
|
if ( is_wp_error( $ids ) )
|
|
return $ids;
|
|
|
|
$tt_id = $ids['term_taxonomy_id'];
|
|
|
|
$defaults = array();
|
|
|
|
if ( 'category' == $taxonomy ) {
|
|
$defaults['default'] = get_option( 'default_category' );
|
|
if ( $defaults['default'] == $term )
|
|
return 0; // Don't delete the default category
|
|
}
|
|
|
|
$args = wp_parse_args($args, $defaults);
|
|
|
|
if ( isset( $args['default'] ) ) {
|
|
$default = (int) $args['default'];
|
|
if ( ! term_exists( $default, $taxonomy ) ) {
|
|
unset( $default );
|
|
}
|
|
}
|
|
|
|
if ( isset( $args['force_default'] ) ) {
|
|
$force_default = $args['force_default'];
|
|
}
|
|
|
|
/**
|
|
* Fires when deleting a term, before any modifications are made to posts or terms.
|
|
*
|
|
* @since 4.1.0
|
|
*
|
|
* @param int $term Term ID.
|
|
* @param string $taxonomy Taxonomy Name.
|
|
*/
|
|
do_action( 'pre_delete_term', $term, $taxonomy );
|
|
|
|
// Update children to point to new parent
|
|
if ( is_taxonomy_hierarchical($taxonomy) ) {
|
|
$term_obj = get_term($term, $taxonomy);
|
|
if ( is_wp_error( $term_obj ) )
|
|
return $term_obj;
|
|
$parent = $term_obj->parent;
|
|
|
|
$edit_ids = $wpdb->get_results( "SELECT term_id, term_taxonomy_id FROM $wpdb->term_taxonomy WHERE `parent` = " . (int)$term_obj->term_id );
|
|
$edit_tt_ids = wp_list_pluck( $edit_ids, 'term_taxonomy_id' );
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
do_action( 'edit_term_taxonomies', $edit_tt_ids );
|
|
|
|
$wpdb->update( $wpdb->term_taxonomy, compact( 'parent' ), array( 'parent' => $term_obj->term_id) + compact( 'taxonomy' ) );
|
|
|
|
// Clean the cache for all child terms.
|
|
$edit_term_ids = wp_list_pluck( $edit_ids, 'term_id' );
|
|
clean_term_cache( $edit_term_ids, $taxonomy );
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
do_action( 'edited_term_taxonomies', $edit_tt_ids );
|
|
}
|
|
|
|
$objects = $wpdb->get_col( $wpdb->prepare( "SELECT object_id FROM $wpdb->term_relationships WHERE term_taxonomy_id = %d", $tt_id ) );
|
|
|
|
foreach ( (array) $objects as $object ) {
|
|
$terms = wp_get_object_terms($object, $taxonomy, array('fields' => 'ids', 'orderby' => 'none'));
|
|
if ( 1 == count($terms) && isset($default) ) {
|
|
$terms = array($default);
|
|
} else {
|
|
$terms = array_diff($terms, array($term));
|
|
if (isset($default) && isset($force_default) && $force_default)
|
|
$terms = array_merge($terms, array($default));
|
|
}
|
|
$terms = array_map('intval', $terms);
|
|
wp_set_object_terms($object, $terms, $taxonomy);
|
|
}
|
|
|
|
// Clean the relationship caches for all object types using this term.
|
|
$tax_object = get_taxonomy( $taxonomy );
|
|
foreach ( $tax_object->object_type as $object_type )
|
|
clean_object_term_cache( $objects, $object_type );
|
|
|
|
// Get the object before deletion so we can pass to actions below
|
|
$deleted_term = get_term( $term, $taxonomy );
|
|
|
|
/**
|
|
* Fires immediately before a term taxonomy ID is deleted.
|
|
*
|
|
* @since 2.9.0
|
|
*
|
|
* @param int $tt_id Term taxonomy ID.
|
|
*/
|
|
do_action( 'delete_term_taxonomy', $tt_id );
|
|
$wpdb->delete( $wpdb->term_taxonomy, array( 'term_taxonomy_id' => $tt_id ) );
|
|
|
|
/**
|
|
* Fires immediately after a term taxonomy ID is deleted.
|
|
*
|
|
* @since 2.9.0
|
|
*
|
|
* @param int $tt_id Term taxonomy ID.
|
|
*/
|
|
do_action( 'deleted_term_taxonomy', $tt_id );
|
|
|
|
// Delete the term if no taxonomies use it.
|
|
if ( !$wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->term_taxonomy WHERE term_id = %d", $term) ) )
|
|
$wpdb->delete( $wpdb->terms, array( 'term_id' => $term ) );
|
|
|
|
clean_term_cache($term, $taxonomy);
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
do_action( 'delete_term', $term, $tt_id, $taxonomy, $deleted_term );
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
do_action( "delete_$taxonomy", $term, $tt_id, $deleted_term );
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Deletes one existing category.
|
|
*
|
|
* @since 2.0.0
|
|
*
|
|
* @param int $cat_ID
|
|
* @return bool|int|WP_Error Returns true if completes delete action; false if term doesn't exist;
|
|
* 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' );
|
|
}
|
|
|
|
/**
|
|
* Retrieves the terms associated with the given object(s), in the supplied taxonomies.
|
|
*
|
|
* @since 2.3.0
|
|
* @since 4.2.0 Added support for 'taxonomy', 'parent', and 'term_taxonomy_id' values of `$orderby`.
|
|
* Introduced `$parent` argument.
|
|
*
|
|
* @global wpdb $wpdb WordPress database abstraction object.
|
|
*
|
|
* @param int|array $object_ids The ID(s) of the object(s) to retrieve.
|
|
* @param string|array $taxonomies The taxonomies to retrieve terms from.
|
|
* @param array|string $args {
|
|
* Array of arguments.
|
|
* @type string $orderby Field by which results should be sorted. Accepts 'name', 'count', 'slug', 'term_group',
|
|
* 'term_order', 'taxonomy', 'parent', or 'term_taxonomy_id'. Default 'name'.
|
|
* @type string $order Sort order. Accepts 'ASC' or 'DESC'. Default 'ASC'.
|
|
* @type string $fields Fields to return for matched terms. Accepts 'all', 'ids', 'names', and
|
|
* 'all_with_object_id'. Note that 'all' or 'all_with_object_id' will result in an array of
|
|
* term objects being returned, 'ids' will return an array of integers, and 'names' an array
|
|
* of strings.
|
|
* @type int $parent Optional. Limit results to the direct children of a given term ID.
|
|
* }
|
|
* @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.
|
|
*/
|
|
function wp_get_object_terms($object_ids, $taxonomies, $args = array()) {
|
|
global $wpdb;
|
|
|
|
if ( empty( $object_ids ) || empty( $taxonomies ) )
|
|
return array();
|
|
|
|
if ( !is_array($taxonomies) )
|
|
$taxonomies = array($taxonomies);
|
|
|
|
foreach ( $taxonomies as $taxonomy ) {
|
|
if ( ! taxonomy_exists($taxonomy) )
|
|
return new WP_Error('invalid_taxonomy', __('Invalid taxonomy'));
|
|
}
|
|
|
|
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',
|
|
'parent' => '',
|
|
);
|
|
$args = wp_parse_args( $args, $defaults );
|
|
|
|
$terms = array();
|
|
if ( count($taxonomies) > 1 ) {
|
|
foreach ( $taxonomies as $index => $taxonomy ) {
|
|
$t = get_taxonomy($taxonomy);
|
|
if ( isset($t->args) && is_array($t->args) && $args != array_merge($args, $t->args) ) {
|
|
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]);
|
|
if ( isset($t->args) && is_array($t->args) )
|
|
$args = array_merge($args, $t->args);
|
|
}
|
|
|
|
$orderby = $args['orderby'];
|
|
$order = $args['order'];
|
|
$fields = $args['fields'];
|
|
|
|
if ( in_array( $orderby, array( 'term_id', 'name', 'slug', 'term_group' ) ) ) {
|
|
$orderby = "t.$orderby";
|
|
} elseif ( in_array( $orderby, array( 'count', 'parent', 'taxonomy', 'term_taxonomy_id' ) ) ) {
|
|
$orderby = "tt.$orderby";
|
|
} elseif ( 'term_order' === $orderby ) {
|
|
$orderby = 'tr.term_order';
|
|
} elseif ( 'none' === $orderby ) {
|
|
$orderby = '';
|
|
$order = '';
|
|
} else {
|
|
$orderby = 't.term_id';
|
|
}
|
|
|
|
// tt_ids queries can only be none or tr.term_taxonomy_id
|
|
if ( ('tt_ids' == $fields) && !empty($orderby) )
|
|
$orderby = 'tr.term_taxonomy_id';
|
|
|
|
if ( !empty($orderby) )
|
|
$orderby = "ORDER BY $orderby";
|
|
|
|
$order = strtoupper( $order );
|
|
if ( '' !== $order && ! in_array( $order, array( 'ASC', 'DESC' ) ) )
|
|
$order = 'ASC';
|
|
|
|
$taxonomy_array = $taxonomies;
|
|
$object_id_array = $object_ids;
|
|
$taxonomies = "'" . implode("', '", array_map( 'esc_sql', $taxonomies ) ) . "'";
|
|
$object_ids = implode(', ', $object_ids);
|
|
|
|
$select_this = '';
|
|
if ( 'all' == $fields ) {
|
|
$select_this = 't.*, tt.*';
|
|
} elseif ( 'ids' == $fields ) {
|
|
$select_this = 't.term_id';
|
|
} elseif ( 'names' == $fields ) {
|
|
$select_this = 't.name';
|
|
} elseif ( 'slugs' == $fields ) {
|
|
$select_this = 't.slug';
|
|
} elseif ( 'all_with_object_id' == $fields ) {
|
|
$select_this = 't.*, tt.*, tr.object_id';
|
|
}
|
|
|
|
$where = array(
|
|
"tt.taxonomy IN ($taxonomies)",
|
|
"tr.object_id IN ($object_ids)",
|
|
);
|
|
|
|
if ( '' !== $args['parent'] ) {
|
|
$where[] = $wpdb->prepare( 'tt.parent = %d', $args['parent'] );
|
|
}
|
|
|
|
$where = implode( ' AND ', $where );
|
|
|
|
$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 $where $orderby $order";
|
|
|
|
$objects = false;
|
|
if ( 'all' == $fields || 'all_with_object_id' == $fields ) {
|
|
$_terms = $wpdb->get_results( $query );
|
|
foreach ( $_terms as $key => $term ) {
|
|
$_terms[$key] = sanitize_term( $term, $taxonomy, 'raw' );
|
|
}
|
|
$terms = array_merge( $terms, $_terms );
|
|
update_term_cache( $terms );
|
|
$objects = true;
|
|
} elseif ( 'ids' == $fields || 'names' == $fields || 'slugs' == $fields ) {
|
|
$_terms = $wpdb->get_col( $query );
|
|
$_field = ( 'ids' == $fields ) ? 'term_id' : 'name';
|
|
foreach ( $_terms as $key => $term ) {
|
|
$_terms[$key] = sanitize_term_field( $_field, $term, $term, $taxonomy, 'raw' );
|
|
}
|
|
$terms = array_merge( $terms, $_terms );
|
|
} elseif ( 'tt_ids' == $fields ) {
|
|
$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");
|
|
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.
|
|
}
|
|
}
|
|
|
|
if ( ! $terms ) {
|
|
$terms = array();
|
|
} elseif ( $objects && 'all_with_object_id' !== $fields ) {
|
|
$_tt_ids = array();
|
|
$_terms = array();
|
|
foreach ( $terms as $term ) {
|
|
if ( in_array( $term->term_taxonomy_id, $_tt_ids ) ) {
|
|
continue;
|
|
}
|
|
|
|
$_tt_ids[] = $term->term_taxonomy_id;
|
|
$_terms[] = $term;
|
|
}
|
|
$terms = $_terms;
|
|
} elseif ( ! $objects ) {
|
|
$terms = array_values( array_unique( $terms ) );
|
|
}
|
|
|
|
/**
|
|
* Filter the terms for a given object or objects.
|
|
*
|
|
* @since 4.2.0
|
|
*
|
|
* @param array $terms An array of terms for the given object or objects.
|
|
* @param array $object_id_array Array of object IDs for which `$terms` were retrieved.
|
|
* @param array $taxonomy_array Array of taxonomies from which `$terms` were retrieved.
|
|
* @param array $args An array of arguments for retrieving terms for the given
|
|
* object(s). See wp_get_object_terms() for details.
|
|
*/
|
|
$terms = apply_filters( 'get_object_terms', $terms, $object_id_array, $taxonomy_array, $args );
|
|
|
|
/**
|
|
* Filter the terms for a given object or objects.
|
|
*
|
|
* The `$taxonomies` parameter passed to this filter is formatted as a SQL fragment. The
|
|
* {@see 'get_object_terms'} filter is recommended as an alternative.
|
|
*
|
|
* @since 2.8.0
|
|
*
|
|
* @param array $terms An array of terms for the given object or objects.
|
|
* @param int|array $object_ids Object ID or array of IDs.
|
|
* @param string $taxonomies SQL-formatted (comma-separated and quoted) list of taxonomy names.
|
|
* @param array $args An array of arguments for retrieving terms for the given object(s).
|
|
* See {@see wp_get_object_terms()} for details.
|
|
*/
|
|
return apply_filters( 'wp_get_object_terms', $terms, $object_ids, $taxonomies, $args );
|
|
}
|
|
|
|
/**
|
|
* Add a new term to the database.
|
|
*
|
|
* 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.
|
|
*
|
|
* 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.
|
|
|
|
* Error handling:
|
|
* If $taxonomy does not exist or $term is empty,
|
|
* a WP_Error object will be returned.
|
|
*
|
|
* 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.
|
|
*
|
|
* @global wpdb $wpdb WordPress database abstraction object.
|
|
|
|
* @since 2.3.0
|
|
*
|
|
* @param string $term The term to add or update.
|
|
* @param string $taxonomy The taxonomy to which to add the term.
|
|
* @param array|string $args {
|
|
* Optional. Array or string of arguments for inserting a 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`,
|
|
* {@see WP_Error} otherwise.
|
|
*/
|
|
function wp_insert_term( $term, $taxonomy, $args = array() ) {
|
|
global $wpdb;
|
|
|
|
if ( ! taxonomy_exists($taxonomy) ) {
|
|
return new WP_Error('invalid_taxonomy', __('Invalid taxonomy'));
|
|
}
|
|
/**
|
|
* 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.
|
|
*/
|
|
$term = apply_filters( 'pre_insert_term', $term, $taxonomy );
|
|
if ( is_wp_error( $term ) ) {
|
|
return $term;
|
|
}
|
|
if ( is_int($term) && 0 == $term ) {
|
|
return new WP_Error('invalid_term_id', __('Invalid term ID'));
|
|
}
|
|
if ( '' == trim($term) ) {
|
|
return new WP_Error('empty_term_name', __('A name is required for this term'));
|
|
}
|
|
$defaults = array( 'alias_of' => '', 'description' => '', 'parent' => 0, 'slug' => '');
|
|
$args = wp_parse_args( $args, $defaults );
|
|
|
|
if ( $args['parent'] > 0 && ! term_exists( (int) $args['parent'] ) ) {
|
|
return new WP_Error( 'missing_parent', __( 'Parent term does not exist.' ) );
|
|
}
|
|
$args['name'] = $term;
|
|
$args['taxonomy'] = $taxonomy;
|
|
$args = sanitize_term($args, $taxonomy, 'db');
|
|
|
|
// expected_slashed ($name)
|
|
$name = wp_unslash( $args['name'] );
|
|
$description = wp_unslash( $args['description'] );
|
|
$parent = (int) $args['parent'];
|
|
|
|
$slug_provided = ! empty( $args['slug'] );
|
|
if ( ! $slug_provided ) {
|
|
$slug = sanitize_title( $name );
|
|
} else {
|
|
$slug = $args['slug'];
|
|
}
|
|
|
|
$term_group = 0;
|
|
if ( $args['alias_of'] ) {
|
|
$alias = get_term_by( 'slug', $args['alias_of'], $taxonomy );
|
|
if ( ! empty( $alias->term_group ) ) {
|
|
// The alias we want is already in a group, so let's use that one.
|
|
$term_group = $alias->term_group;
|
|
} elseif ( ! empty( $alias->term_id ) ) {
|
|
/*
|
|
* The alias is not in a group, so we create a new one
|
|
* and add the alias to it.
|
|
*/
|
|
$term_group = $wpdb->get_var("SELECT MAX(term_group) FROM $wpdb->terms") + 1;
|
|
|
|
wp_update_term( $alias->term_id, $taxonomy, array(
|
|
'term_group' => $term_group,
|
|
) );
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Prevent the creation of terms with duplicate names at the same level of a taxonomy hierarchy,
|
|
* unless a unique slug has been explicitly provided.
|
|
*/
|
|
if ( $name_match = get_term_by( 'name', $name, $taxonomy ) ) {
|
|
$slug_match = get_term_by( 'slug', $slug, $taxonomy );
|
|
if ( ! $slug_provided || $name_match->slug === $slug || $slug_match ) {
|
|
if ( is_taxonomy_hierarchical( $taxonomy ) ) {
|
|
$siblings = get_terms( $taxonomy, array( 'get' => 'all', 'parent' => $parent ) );
|
|
|
|
$existing_term = null;
|
|
if ( $name_match->slug === $slug && in_array( $name, wp_list_pluck( $siblings, 'name' ) ) ) {
|
|
$existing_term = $name_match;
|
|
} elseif ( $slug_match && in_array( $slug, wp_list_pluck( $siblings, 'slug' ) ) ) {
|
|
$existing_term = $slug_match;
|
|
}
|
|
|
|
if ( $existing_term ) {
|
|
return new WP_Error( 'term_exists', __( 'A term with the name provided already exists with this parent.' ), $existing_term->term_id );
|
|
}
|
|
} else {
|
|
return new WP_Error( 'term_exists', __( 'A term with the name provided already exists in this taxonomy.' ), $name_match->term_id );
|
|
}
|
|
}
|
|
}
|
|
|
|
$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;
|
|
|
|
// Seems unreachable, However, Is used in the case that a term name is provided, which sanitizes to an empty string.
|
|
if ( empty($slug) ) {
|
|
$slug = sanitize_title($slug, $term_id);
|
|
|
|
/** This action is documented in wp-includes/taxonomy.php */
|
|
do_action( 'edit_terms', $term_id, $taxonomy );
|
|
$wpdb->update( $wpdb->terms, compact( 'slug' ), compact( 'term_id' ) );
|
|
|
|
/** This action is documented in wp-includes/taxonomy.php */
|
|
do_action( 'edited_terms', $term_id, $taxonomy );
|
|
}
|
|
|
|
$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 ) );
|
|
|
|
if ( !empty($tt_id) ) {
|
|
return array('term_id' => $term_id, 'term_taxonomy_id' => $tt_id);
|
|
}
|
|
$wpdb->insert( $wpdb->term_taxonomy, compact( 'term_id', 'taxonomy', 'description', 'parent') + array( 'count' => 0 ) );
|
|
$tt_id = (int) $wpdb->insert_id;
|
|
|
|
/*
|
|
* Sanity check: if we just created a term with the same parent + taxonomy + slug but a higher term_id than
|
|
* an existing term, then we have unwittingly created a duplicate term. Delete the dupe, and use the term_id
|
|
* and term_taxonomy_id of the older term instead. Then return out of the function so that the "create" hooks
|
|
* are not fired.
|
|
*/
|
|
$duplicate_term = $wpdb->get_row( $wpdb->prepare( "SELECT t.term_id, tt.term_taxonomy_id FROM $wpdb->terms t INNER JOIN $wpdb->term_taxonomy tt ON ( tt.term_id = t.term_id ) WHERE t.slug = %s AND tt.parent = %d AND tt.taxonomy = %s AND t.term_id < %d AND tt.term_taxonomy_id != %d", $slug, $parent, $taxonomy, $term_id, $tt_id ) );
|
|
if ( $duplicate_term ) {
|
|
$wpdb->delete( $wpdb->terms, array( 'term_id' => $term_id ) );
|
|
$wpdb->delete( $wpdb->term_taxonomy, array( 'term_taxonomy_id' => $tt_id ) );
|
|
|
|
$term_id = (int) $duplicate_term->term_id;
|
|
$tt_id = (int) $duplicate_term->term_taxonomy_id;
|
|
|
|
clean_term_cache( $term_id, $taxonomy );
|
|
return array( 'term_id' => $term_id, 'term_taxonomy_id' => $tt_id );
|
|
}
|
|
|
|
/**
|
|
* 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 );
|
|
|
|
/**
|
|
* 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 );
|
|
|
|
clean_term_cache($term_id, $taxonomy);
|
|
|
|
/**
|
|
* Fires after a new term 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.
|
|
* @param string $taxonomy Taxonomy slug.
|
|
*/
|
|
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.
|
|
*
|
|
* 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( "created_$taxonomy", $term_id, $tt_id );
|
|
|
|
return array('term_id' => $term_id, 'term_taxonomy_id' => $tt_id);
|
|
}
|
|
|
|
/**
|
|
* Create Term and Taxonomy Relationships.
|
|
*
|
|
* 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).
|
|
*
|
|
* 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.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @global wpdb $wpdb The WordPress database abstraction object.
|
|
*
|
|
* @param int $object_id The object to relate to.
|
|
* @param array|int|string $terms A single term slug, single term id, or array of either term slugs or ids.
|
|
* Will replace all existing related terms in this taxonomy.
|
|
* @param string $taxonomy The context in which to relate the term to the object.
|
|
* @param bool $append Optional. If false will delete difference of terms. Default false.
|
|
* @return array|WP_Error Affected Term IDs.
|
|
*/
|
|
function wp_set_object_terms( $object_id, $terms, $taxonomy, $append = false ) {
|
|
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);
|
|
|
|
if ( ! $append )
|
|
$old_tt_ids = wp_get_object_terms($object_id, $taxonomy, array('fields' => 'tt_ids', 'orderby' => 'none'));
|
|
else
|
|
$old_tt_ids = array();
|
|
|
|
$tt_ids = array();
|
|
$term_ids = array();
|
|
$new_tt_ids = array();
|
|
|
|
foreach ( (array) $terms as $term) {
|
|
if ( !strlen(trim($term)) )
|
|
continue;
|
|
|
|
if ( !$term_info = term_exists($term, $taxonomy) ) {
|
|
// Skip if a non-existent term ID is passed.
|
|
if ( is_int($term) )
|
|
continue;
|
|
$term_info = wp_insert_term($term, $taxonomy);
|
|
}
|
|
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;
|
|
|
|
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 ) ) )
|
|
continue;
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
do_action( 'add_term_relationship', $object_id, $tt_id );
|
|
$wpdb->insert( $wpdb->term_relationships, array( 'object_id' => $object_id, 'term_taxonomy_id' => $tt_id ) );
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
do_action( 'added_term_relationship', $object_id, $tt_id );
|
|
$new_tt_ids[] = $tt_id;
|
|
}
|
|
|
|
if ( $new_tt_ids )
|
|
wp_update_term_count( $new_tt_ids, $taxonomy );
|
|
|
|
if ( ! $append ) {
|
|
$delete_tt_ids = array_diff( $old_tt_ids, $tt_ids );
|
|
|
|
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 );
|
|
|
|
$remove = wp_remove_object_terms( $object_id, $delete_term_ids, $taxonomy );
|
|
if ( is_wp_error( $remove ) ) {
|
|
return $remove;
|
|
}
|
|
}
|
|
}
|
|
|
|
$t = get_taxonomy($taxonomy);
|
|
if ( ! $append && isset($t->sort) && $t->sort ) {
|
|
$values = array();
|
|
$term_order = 0;
|
|
$final_tt_ids = wp_get_object_terms($object_id, $taxonomy, array('fields' => 'tt_ids'));
|
|
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);
|
|
if ( $values )
|
|
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 );
|
|
}
|
|
|
|
wp_cache_delete( $object_id, $taxonomy . '_relationships' );
|
|
|
|
/**
|
|
* 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 );
|
|
return $tt_ids;
|
|
}
|
|
|
|
/**
|
|
* Add term(s) associated with a given object.
|
|
*
|
|
* @since 3.6.0
|
|
*
|
|
* @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.
|
|
*
|
|
* @since 3.6.0
|
|
*
|
|
* @global wpdb $wpdb WordPress database abstraction object.
|
|
*
|
|
* @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();
|
|
|
|
foreach ( (array) $terms as $term ) {
|
|
if ( ! strlen( trim( $term ) ) ) {
|
|
continue;
|
|
}
|
|
|
|
if ( ! $term_info = term_exists( $term, $taxonomy ) ) {
|
|
// Skip if a non-existent term ID is passed.
|
|
if ( is_int( $term ) ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( is_wp_error( $term_info ) ) {
|
|
return $term_info;
|
|
}
|
|
|
|
$tt_ids[] = $term_info['term_taxonomy_id'];
|
|
}
|
|
|
|
if ( $tt_ids ) {
|
|
$in_tt_ids = "'" . implode( "', '", $tt_ids ) . "'";
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
do_action( 'delete_term_relationships', $object_id, $tt_ids );
|
|
$deleted = $wpdb->query( $wpdb->prepare( "DELETE FROM $wpdb->term_relationships WHERE object_id = %d AND term_taxonomy_id IN ($in_tt_ids)", $object_id ) );
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
do_action( 'deleted_term_relationships', $object_id, $tt_ids );
|
|
|
|
wp_update_term_count( $tt_ids, $taxonomy );
|
|
|
|
return (bool) $deleted;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Will make slug unique, if it isn't already.
|
|
*
|
|
* 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.
|
|
*
|
|
* The way this works is that if the taxonomy that the term belongs to is
|
|
* hierarchical and has a parent, it will append that parent to the $slug.
|
|
*
|
|
* If that still doesn't return an unique slug, then it try to append a number
|
|
* until it finds a number that is truly unique.
|
|
*
|
|
* The only purpose for `$term` is for appending a parent, if one exists.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @global wpdb $wpdb WordPress database abstraction object.
|
|
*
|
|
* @param string $slug The string that will be tried for a unique slug.
|
|
* @param object $term The term object that the `$slug` will belong to.
|
|
* @return string Will return a true unique slug.
|
|
*/
|
|
function wp_unique_term_slug( $slug, $term ) {
|
|
global $wpdb;
|
|
|
|
$needs_suffix = true;
|
|
$original_slug = $slug;
|
|
|
|
// As of 4.1, duplicate slugs are allowed as long as they're in different taxonomies.
|
|
if ( ! term_exists( $slug ) || get_option( 'db_version' ) >= 30133 && ! get_term_by( 'slug', $slug, $term->taxonomy ) ) {
|
|
$needs_suffix = false;
|
|
}
|
|
|
|
/*
|
|
* If the taxonomy supports hierarchy and the term has a parent, make the slug unique
|
|
* by incorporating parent slugs.
|
|
*/
|
|
$parent_suffix = '';
|
|
if ( $needs_suffix && 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;
|
|
$parent_suffix .= '-' . $parent_term->slug;
|
|
if ( ! term_exists( $slug . $parent_suffix ) ) {
|
|
break;
|
|
}
|
|
|
|
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.
|
|
|
|
/**
|
|
* Filter whether the proposed unique term slug is bad.
|
|
*
|
|
* @since 4.3.0
|
|
*
|
|
* @param bool $needs_suffix Whether the slug needs to be made unique with a suffix.
|
|
* @param string $slug The slug.
|
|
* @param object $term Term object.
|
|
*/
|
|
if ( apply_filters( 'wp_unique_term_slug_is_bad_slug', $needs_suffix, $slug, $term ) ) {
|
|
if ( $parent_suffix ) {
|
|
$slug .= $parent_suffix;
|
|
} else {
|
|
if ( ! empty( $term->term_id ) )
|
|
$query = $wpdb->prepare( "SELECT slug FROM $wpdb->terms WHERE slug = %s AND term_id != %d", $slug, $term->term_id );
|
|
else
|
|
$query = $wpdb->prepare( "SELECT slug FROM $wpdb->terms WHERE slug = %s", $slug );
|
|
|
|
if ( $wpdb->get_var( $query ) ) {
|
|
$num = 2;
|
|
do {
|
|
$alt_slug = $slug . "-$num";
|
|
$num++;
|
|
$slug_check = $wpdb->get_var( $wpdb->prepare( "SELECT slug FROM $wpdb->terms WHERE slug = %s", $alt_slug ) );
|
|
} while ( $slug_check );
|
|
$slug = $alt_slug;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Filter the unique term slug.
|
|
*
|
|
* @since 4.3.0
|
|
*
|
|
* @param string $slug Unique term slug.
|
|
* @param object $term Term object.
|
|
* @param string $original_slug Slug originally passed to the function for testing.
|
|
*/
|
|
return apply_filters( 'wp_unique_term_slug', $slug, $term, $original_slug );
|
|
}
|
|
|
|
/**
|
|
* Update term based on arguments provided.
|
|
*
|
|
* 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).
|
|
*
|
|
* Defaults will set 'alias_of', 'description', 'parent', and 'slug' if not
|
|
* defined in $args already.
|
|
*
|
|
* 'alias_of' will create a term group, if it doesn't already exist, and update
|
|
* it for the $term.
|
|
*
|
|
* 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.
|
|
*
|
|
* For what can be overrode in `$args`, check the term scheme can contain and stay
|
|
* away from the term keys.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @global wpdb $wpdb WordPress database abstraction object.
|
|
*
|
|
* @param int $term_id The ID of the term
|
|
* @param string $taxonomy The context in which to relate the term to the object.
|
|
* @param array|string $args Optional. Array of get_terms() arguments. Default empty array.
|
|
* @return array|WP_Error Returns Term ID and Taxonomy Term ID
|
|
*/
|
|
function wp_update_term( $term_id, $taxonomy, $args = array() ) {
|
|
global $wpdb;
|
|
|
|
if ( ! taxonomy_exists( $taxonomy ) ) {
|
|
return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy' ) );
|
|
}
|
|
|
|
$term_id = (int) $term_id;
|
|
|
|
// First, get all of the original args
|
|
$term = get_term( $term_id, $taxonomy, ARRAY_A );
|
|
|
|
if ( is_wp_error( $term ) ) {
|
|
return $term;
|
|
}
|
|
|
|
if ( ! $term ) {
|
|
return new WP_Error( 'invalid_term', __( 'Empty Term' ) );
|
|
}
|
|
|
|
// Escape data pulled from DB.
|
|
$term = wp_slash($term);
|
|
|
|
// 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');
|
|
$parsed_args = $args;
|
|
|
|
// expected_slashed ($name)
|
|
$name = wp_unslash( $args['name'] );
|
|
$description = wp_unslash( $args['description'] );
|
|
|
|
$parsed_args['name'] = $name;
|
|
$parsed_args['description'] = $description;
|
|
|
|
if ( '' == trim($name) )
|
|
return new WP_Error('empty_term_name', __('A name is required for this term'));
|
|
|
|
if ( $parsed_args['parent'] > 0 && ! term_exists( (int) $parsed_args['parent'] ) ) {
|
|
return new WP_Error( 'missing_parent', __( 'Parent term does not exist.' ) );
|
|
}
|
|
|
|
$empty_slug = false;
|
|
if ( empty( $args['slug'] ) ) {
|
|
$empty_slug = true;
|
|
$slug = sanitize_title($name);
|
|
} else {
|
|
$slug = $args['slug'];
|
|
}
|
|
|
|
$parsed_args['slug'] = $slug;
|
|
|
|
$term_group = isset( $parsed_args['term_group'] ) ? $parsed_args['term_group'] : 0;
|
|
if ( $args['alias_of'] ) {
|
|
$alias = get_term_by( 'slug', $args['alias_of'], $taxonomy );
|
|
if ( ! empty( $alias->term_group ) ) {
|
|
// The alias we want is already in a group, so let's use that one.
|
|
$term_group = $alias->term_group;
|
|
} elseif ( ! empty( $alias->term_id ) ) {
|
|
/*
|
|
* The alias is not in a group, so we create a new one
|
|
* and add the alias to it.
|
|
*/
|
|
$term_group = $wpdb->get_var("SELECT MAX(term_group) FROM $wpdb->terms") + 1;
|
|
|
|
wp_update_term( $alias->term_id, $taxonomy, array(
|
|
'term_group' => $term_group,
|
|
) );
|
|
}
|
|
|
|
$parsed_args['term_group'] = $term_group;
|
|
}
|
|
|
|
/**
|
|
* 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 $parsed_args An array of potentially altered update arguments for the given term.
|
|
* @param array $args An array of update arguments for the given term.
|
|
*/
|
|
$parent = apply_filters( 'wp_update_term_parent', $args['parent'], $term_id, $taxonomy, $parsed_args, $args );
|
|
|
|
// Check for duplicate slug
|
|
$duplicate = get_term_by( 'slug', $slug, $taxonomy );
|
|
if ( $duplicate && $duplicate->term_id != $term_id ) {
|
|
// If an empty slug was passed or the parent changed, reset the slug to something unique.
|
|
// Otherwise, bail.
|
|
if ( $empty_slug || ( $parent != $term['parent']) )
|
|
$slug = wp_unique_term_slug($slug, (object) $args);
|
|
else
|
|
return new WP_Error('duplicate_term_slug', sprintf(__('The slug “%s” is already in use by another term'), $slug));
|
|
}
|
|
|
|
$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) );
|
|
|
|
// Check whether this is a shared term that needs splitting.
|
|
$_term_id = _split_shared_term( $term_id, $tt_id );
|
|
if ( ! is_wp_error( $_term_id ) ) {
|
|
$term_id = $_term_id;
|
|
}
|
|
|
|
/**
|
|
* Fires immediately before the given terms are edited.
|
|
*
|
|
* @since 2.9.0
|
|
*
|
|
* @param int $term_id Term ID.
|
|
* @param string $taxonomy Taxonomy slug.
|
|
*/
|
|
do_action( 'edit_terms', $term_id, $taxonomy );
|
|
$wpdb->update($wpdb->terms, compact( 'name', 'slug', 'term_group' ), compact( 'term_id' ) );
|
|
if ( empty($slug) ) {
|
|
$slug = sanitize_title($name, $term_id);
|
|
$wpdb->update( $wpdb->terms, compact( 'slug' ), compact( 'term_id' ) );
|
|
}
|
|
|
|
/**
|
|
* Fires immediately after the given terms are edited.
|
|
*
|
|
* @since 2.9.0
|
|
*
|
|
* @param int $term_id Term ID
|
|
* @param string $taxonomy Taxonomy slug.
|
|
*/
|
|
do_action( 'edited_terms', $term_id, $taxonomy );
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
do_action( 'edit_term_taxonomy', $tt_id, $taxonomy );
|
|
|
|
$wpdb->update( $wpdb->term_taxonomy, compact( 'term_id', 'taxonomy', 'description', 'parent' ), array( 'term_taxonomy_id' => $tt_id ) );
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
do_action( 'edited_term_taxonomy', $tt_id, $taxonomy );
|
|
|
|
// 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 );
|
|
foreach ( $tax_object->object_type as $object_type ) {
|
|
clean_object_term_cache( $objects, $object_type );
|
|
}
|
|
|
|
/**
|
|
* 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 );
|
|
|
|
/**
|
|
* 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 );
|
|
|
|
clean_term_cache($term_id, $taxonomy);
|
|
|
|
/**
|
|
* 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 );
|
|
|
|
return array('term_id' => $term_id, 'term_taxonomy_id' => $tt_id);
|
|
}
|
|
|
|
/**
|
|
* Enable or disable term counting.
|
|
*
|
|
* @since 2.5.0
|
|
*
|
|
* @staticvar bool $_defer
|
|
*
|
|
* @param bool $defer Optional. Enable if true, disable if false.
|
|
* @return bool Whether term counting is enabled or disabled.
|
|
*/
|
|
function wp_defer_term_counting($defer=null) {
|
|
static $_defer = false;
|
|
|
|
if ( is_bool($defer) ) {
|
|
$_defer = $defer;
|
|
// flush any deferred counts
|
|
if ( !$defer )
|
|
wp_update_term_count( null, null, true );
|
|
}
|
|
|
|
return $_defer;
|
|
}
|
|
|
|
/**
|
|
* Updates the amount of terms in taxonomy.
|
|
*
|
|
* If there is a taxonomy callback applied, then it will be called for updating
|
|
* the count.
|
|
*
|
|
* 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.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @staticvar array $_deferred
|
|
*
|
|
* @param int|array $terms The term_taxonomy_id of the terms.
|
|
* @param string $taxonomy The context of the term.
|
|
* @return bool If no terms will return false, and if successful will return true.
|
|
*/
|
|
function wp_update_term_count( $terms, $taxonomy, $do_deferred=false ) {
|
|
static $_deferred = array();
|
|
|
|
if ( $do_deferred ) {
|
|
foreach ( (array) array_keys($_deferred) as $tax ) {
|
|
wp_update_term_count_now( $_deferred[$tax], $tax );
|
|
unset( $_deferred[$tax] );
|
|
}
|
|
}
|
|
|
|
if ( empty($terms) )
|
|
return false;
|
|
|
|
if ( !is_array($terms) )
|
|
$terms = array($terms);
|
|
|
|
if ( wp_defer_term_counting() ) {
|
|
if ( !isset($_deferred[$taxonomy]) )
|
|
$_deferred[$taxonomy] = array();
|
|
$_deferred[$taxonomy] = array_unique( array_merge($_deferred[$taxonomy], $terms) );
|
|
return true;
|
|
}
|
|
|
|
return wp_update_term_count_now( $terms, $taxonomy );
|
|
}
|
|
|
|
/**
|
|
* Perform term count update immediately.
|
|
*
|
|
* @since 2.5.0
|
|
*
|
|
* @param array $terms The term_taxonomy_id of terms to update.
|
|
* @param string $taxonomy The context of the term.
|
|
* @return true Always true when complete.
|
|
*/
|
|
function wp_update_term_count_now( $terms, $taxonomy ) {
|
|
$terms = array_map('intval', $terms);
|
|
|
|
$taxonomy = get_taxonomy($taxonomy);
|
|
if ( !empty($taxonomy->update_count_callback) ) {
|
|
call_user_func($taxonomy->update_count_callback, $terms, $taxonomy);
|
|
} else {
|
|
$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 );
|
|
}
|
|
}
|
|
|
|
clean_term_cache($terms, '', false);
|
|
|
|
return true;
|
|
}
|
|
|
|
//
|
|
// Cache
|
|
//
|
|
|
|
/**
|
|
* Removes the taxonomy relationship to terms from the cache.
|
|
*
|
|
* 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.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @see get_object_taxonomies() for more on $object_type.
|
|
*
|
|
* @param int|array $object_ids Single or list of term object ID(s).
|
|
* @param array|string $object_type The taxonomy object type.
|
|
*/
|
|
function clean_object_term_cache($object_ids, $object_type) {
|
|
if ( !is_array($object_ids) )
|
|
$object_ids = array($object_ids);
|
|
|
|
$taxonomies = get_object_taxonomies( $object_type );
|
|
|
|
foreach ( $object_ids as $id ) {
|
|
foreach ( $taxonomies as $taxonomy ) {
|
|
wp_cache_delete($id, "{$taxonomy}_relationships");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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 );
|
|
}
|
|
|
|
/**
|
|
* Will remove all of the term ids from the cache.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @global wpdb $wpdb WordPress database abstraction object.
|
|
* @global bool $_wp_suspend_cache_invalidation
|
|
*
|
|
* @param int|array $ids Single or list of Term IDs.
|
|
* @param string $taxonomy Optional. Can be empty and will assume `tt_ids`, else will use for context.
|
|
* Default empty.
|
|
* @param bool $clean_taxonomy Optional. Whether to clean taxonomy wide caches (true), or just individual
|
|
* term object caches (false). Default true.
|
|
*/
|
|
function clean_term_cache($ids, $taxonomy = '', $clean_taxonomy = true) {
|
|
global $wpdb, $_wp_suspend_cache_invalidation;
|
|
|
|
if ( ! empty( $_wp_suspend_cache_invalidation ) ) {
|
|
return;
|
|
}
|
|
|
|
if ( !is_array($ids) )
|
|
$ids = array($ids);
|
|
|
|
$taxonomies = array();
|
|
// If no taxonomy, assume tt_ids.
|
|
if ( empty($taxonomy) ) {
|
|
$tt_ids = array_map('intval', $ids);
|
|
$tt_ids = implode(', ', $tt_ids);
|
|
$terms = $wpdb->get_results("SELECT term_id, taxonomy FROM $wpdb->term_taxonomy WHERE term_taxonomy_id IN ($tt_ids)");
|
|
$ids = array();
|
|
foreach ( (array) $terms as $term ) {
|
|
$taxonomies[] = $term->taxonomy;
|
|
$ids[] = $term->term_id;
|
|
wp_cache_delete($term->term_id, $term->taxonomy);
|
|
}
|
|
$taxonomies = array_unique($taxonomies);
|
|
} else {
|
|
$taxonomies = array($taxonomy);
|
|
foreach ( $taxonomies as $taxonomy ) {
|
|
foreach ( $ids as $id ) {
|
|
wp_cache_delete($id, $taxonomy);
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach ( $taxonomies as $taxonomy ) {
|
|
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);
|
|
}
|
|
|
|
/**
|
|
* 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 );
|
|
}
|
|
|
|
wp_cache_set( 'last_changed', microtime(), 'terms' );
|
|
}
|
|
|
|
/**
|
|
* Retrieves the taxonomy relationship to the term object id.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @param int $id Term object ID.
|
|
* @param string $taxonomy Taxonomy name.
|
|
* @return bool|mixed Empty array if $terms found, but not `$taxonomy`. False if nothing is in cache
|
|
* for `$taxonomy` and `$id`.
|
|
*/
|
|
function get_object_term_cache( $id, $taxonomy ) {
|
|
return wp_cache_get( $id, "{$taxonomy}_relationships" );
|
|
}
|
|
|
|
/**
|
|
* Updates the cache for the given term object ID(s).
|
|
*
|
|
* Note: Due to performance concerns, great care should be taken to only update
|
|
* term caches when necessary. Processing time can increase exponentially depending
|
|
* on both the number of passed term IDs and the number of taxonomies those terms
|
|
* belong to.
|
|
*
|
|
* Caches will only be updated for terms not already cached.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @param string|array $object_ids Comma-separated list or array of term object IDs.
|
|
* @param array|string $object_type The taxonomy object type.
|
|
* @return void|false False if all of the terms in `$object_ids` are already cached.
|
|
*/
|
|
function update_object_term_cache($object_ids, $object_type) {
|
|
if ( empty($object_ids) )
|
|
return;
|
|
|
|
if ( !is_array($object_ids) )
|
|
$object_ids = explode(',', $object_ids);
|
|
|
|
$object_ids = array_map('intval', $object_ids);
|
|
|
|
$taxonomies = get_object_taxonomies($object_type);
|
|
|
|
$ids = array();
|
|
foreach ( (array) $object_ids as $id ) {
|
|
foreach ( $taxonomies as $taxonomy ) {
|
|
if ( false === wp_cache_get($id, "{$taxonomy}_relationships") ) {
|
|
$ids[] = $id;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( empty( $ids ) )
|
|
return false;
|
|
|
|
$terms = wp_get_object_terms($ids, $taxonomies, array('fields' => 'all_with_object_id'));
|
|
|
|
$object_terms = array();
|
|
foreach ( (array) $terms as $term )
|
|
$object_terms[$term->object_id][$term->taxonomy][] = $term;
|
|
|
|
foreach ( $ids as $id ) {
|
|
foreach ( $taxonomies as $taxonomy ) {
|
|
if ( ! isset($object_terms[$id][$taxonomy]) ) {
|
|
if ( !isset($object_terms[$id]) )
|
|
$object_terms[$id] = array();
|
|
$object_terms[$id][$taxonomy] = array();
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach ( $object_terms as $id => $value ) {
|
|
foreach ( $value as $taxonomy => $terms ) {
|
|
wp_cache_add( $id, $terms, "{$taxonomy}_relationships" );
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Updates Terms to Taxonomy in cache.
|
|
*
|
|
* @since 2.3.0
|
|
*
|
|
* @param array $terms List of term objects to change.
|
|
* @param string $taxonomy Optional. Update Term to this taxonomy in cache. Default empty.
|
|
*/
|
|
function update_term_cache( $terms, $taxonomy = '' ) {
|
|
foreach ( (array) $terms as $term ) {
|
|
$term_taxonomy = $taxonomy;
|
|
if ( empty($term_taxonomy) )
|
|
$term_taxonomy = $term->taxonomy;
|
|
|
|
wp_cache_add( $term->term_id, $term, $term_taxonomy );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Private
|
|
//
|
|
|
|
/**
|
|
* Retrieves children of taxonomy as Term IDs.
|
|
*
|
|
* @ignore
|
|
* @since 2.3.0
|
|
*
|
|
* @param string $taxonomy Taxonomy name.
|
|
* @return array Empty if $taxonomy isn't hierarchical or returns children as Term IDs.
|
|
*/
|
|
function _get_term_hierarchy( $taxonomy ) {
|
|
if ( !is_taxonomy_hierarchical($taxonomy) )
|
|
return array();
|
|
$children = get_option("{$taxonomy}_children");
|
|
|
|
if ( is_array($children) )
|
|
return $children;
|
|
$children = array();
|
|
$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;
|
|
}
|
|
update_option("{$taxonomy}_children", $children);
|
|
|
|
return $children;
|
|
}
|
|
|
|
/**
|
|
* Get the subset of $terms that are descendants of $term_id.
|
|
*
|
|
* 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.
|
|
*
|
|
* @access private
|
|
* @since 2.3.0
|
|
*
|
|
* @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.
|
|
* @param array $ancestors Optional. Term ancestors that have already been identified. Passed by reference, to keep
|
|
* track of found terms when recursing the hierarchy. The array of located ancestors is used
|
|
* to prevent infinite recursion loops. For performance, `term_ids` are used as array keys,
|
|
* with 1 as value. Default empty array.
|
|
* @return array|WP_Error The subset of $terms that are descendants of $term_id.
|
|
*/
|
|
function _get_term_children( $term_id, $terms, $taxonomy, &$ancestors = array() ) {
|
|
$empty_array = array();
|
|
if ( empty($terms) )
|
|
return $empty_array;
|
|
|
|
$term_list = array();
|
|
$has_children = _get_term_hierarchy($taxonomy);
|
|
|
|
if ( ( 0 != $term_id ) && ! isset($has_children[$term_id]) )
|
|
return $empty_array;
|
|
|
|
// Include the term itself in the ancestors array, so we can properly detect when a loop has occurred.
|
|
if ( empty( $ancestors ) ) {
|
|
$ancestors[ $term_id ] = 1;
|
|
}
|
|
|
|
foreach ( (array) $terms as $term ) {
|
|
$use_id = false;
|
|
if ( !is_object($term) ) {
|
|
$term = get_term($term, $taxonomy);
|
|
if ( is_wp_error( $term ) )
|
|
return $term;
|
|
$use_id = true;
|
|
}
|
|
|
|
// Don't recurse if we've already identified the term as a child - this indicates a loop.
|
|
if ( isset( $ancestors[ $term->term_id ] ) ) {
|
|
continue;
|
|
}
|
|
|
|
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;
|
|
|
|
$ancestors[ $term->term_id ] = 1;
|
|
|
|
if ( $children = _get_term_children( $term->term_id, $terms, $taxonomy, $ancestors) )
|
|
$term_list = array_merge($term_list, $children);
|
|
}
|
|
}
|
|
|
|
return $term_list;
|
|
}
|
|
|
|
/**
|
|
* Add count of children to parent count.
|
|
*
|
|
* Recalculates term counts by including items from child terms. Assumes all
|
|
* relevant children are already in the $terms argument.
|
|
*
|
|
* @access private
|
|
* @since 2.3.0
|
|
*
|
|
* @global wpdb $wpdb WordPress database abstraction object.
|
|
*
|
|
* @param array $terms List of term IDs, passed by reference.
|
|
* @param string $taxonomy Term context.
|
|
*/
|
|
function _pad_term_counts( &$terms, $taxonomy ) {
|
|
global $wpdb;
|
|
|
|
// This function only works for hierarchical taxonomies like post categories.
|
|
if ( !is_taxonomy_hierarchical( $taxonomy ) )
|
|
return;
|
|
|
|
$term_hier = _get_term_hierarchy($taxonomy);
|
|
|
|
if ( empty($term_hier) )
|
|
return;
|
|
|
|
$term_items = array();
|
|
$terms_by_id = array();
|
|
$term_ids = array();
|
|
|
|
foreach ( (array) $terms as $key => $term ) {
|
|
$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.
|
|
$tax_obj = get_taxonomy($taxonomy);
|
|
$object_types = esc_sql($tax_obj->object_type);
|
|
$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'");
|
|
foreach ( $results as $row ) {
|
|
$id = $term_ids[$row->term_taxonomy_id];
|
|
$term_items[$id][$row->object_id] = isset($term_items[$id][$row->object_id]) ? ++$term_items[$id][$row->object_id] : 1;
|
|
}
|
|
|
|
// Touch every ancestor's lookup row for each post in each term.
|
|
foreach ( $term_ids as $term_id ) {
|
|
$child = $term_id;
|
|
$ancestors = array();
|
|
while ( !empty( $terms_by_id[$child] ) && $parent = $terms_by_id[$child]->parent ) {
|
|
$ancestors[] = $child;
|
|
if ( !empty( $term_items[$term_id] ) )
|
|
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;
|
|
}
|
|
$child = $parent;
|
|
|
|
if ( in_array( $parent, $ancestors ) ) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Transfer the touched cells.
|
|
foreach ( (array) $term_items as $id => $items )
|
|
if ( isset($terms_by_id[$id]) )
|
|
$terms_by_id[$id]->count = count($items);
|
|
}
|
|
|
|
//
|
|
// Default callbacks
|
|
//
|
|
|
|
/**
|
|
* Will update term count based on object types of the current taxonomy.
|
|
*
|
|
* Private function for the default callback for post_tag and category
|
|
* taxonomies.
|
|
*
|
|
* @access private
|
|
* @since 2.3.0
|
|
*
|
|
* @global wpdb $wpdb WordPress database abstraction object.
|
|
*
|
|
* @param array $terms List of Term taxonomy IDs.
|
|
* @param object $taxonomy Current taxonomy object of terms.
|
|
*/
|
|
function _update_post_term_count( $terms, $taxonomy ) {
|
|
global $wpdb;
|
|
|
|
$object_types = (array) $taxonomy->object_type;
|
|
|
|
foreach ( $object_types as &$object_type )
|
|
list( $object_type ) = explode( ':', $object_type );
|
|
|
|
$object_types = array_unique( $object_types );
|
|
|
|
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' ) );
|
|
|
|
foreach ( (array) $terms as $term ) {
|
|
$count = 0;
|
|
|
|
// Attachments can be 'inherit' status, we need to base count off the parent's status if so.
|
|
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 ) );
|
|
|
|
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 ) );
|
|
|
|
/** This action is documented in wp-includes/taxonomy.php */
|
|
do_action( 'edit_term_taxonomy', $term, $taxonomy->name );
|
|
$wpdb->update( $wpdb->term_taxonomy, compact( 'count' ), array( 'term_taxonomy_id' => $term ) );
|
|
|
|
/** This action is documented in wp-includes/taxonomy.php */
|
|
do_action( 'edited_term_taxonomy', $term, $taxonomy->name );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Will update term count based on number of objects.
|
|
*
|
|
* Default callback for the 'link_category' taxonomy.
|
|
*
|
|
* @since 3.3.0
|
|
*
|
|
* @global wpdb $wpdb WordPress database abstraction object.
|
|
*
|
|
* @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 ) );
|
|
|
|
/** This action is documented in wp-includes/taxonomy.php */
|
|
do_action( 'edit_term_taxonomy', $term, $taxonomy->name );
|
|
$wpdb->update( $wpdb->term_taxonomy, compact( 'count' ), array( 'term_taxonomy_id' => $term ) );
|
|
|
|
/** This action is documented in wp-includes/taxonomy.php */
|
|
do_action( 'edited_term_taxonomy', $term, $taxonomy->name );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a new term for a term_taxonomy item that currently shares its term
|
|
* with another term_taxonomy.
|
|
*
|
|
* @ignore
|
|
* @since 4.2.0
|
|
* @since 4.3.0 Introduced `$record` parameter. Also, `$term_id` and
|
|
* `$term_taxonomy_id` can now accept objects.
|
|
*
|
|
* @global wpdb $wpdb
|
|
*
|
|
* @param int|object $term_id ID of the shared term, or the shared term object.
|
|
* @param int|object $term_taxonomy_id ID of the term_taxonomy item to receive a new term, or the term_taxonomy object
|
|
* (corresponding to a row from the term_taxonomy table).
|
|
* @param bool $record Whether to record data about the split term in the options table. The recording
|
|
* process has the potential to be resource-intensive, so during batch operations
|
|
* it can be beneficial to skip inline recording and do it just once, after the
|
|
* batch is processed. Only set this to `false` if you know what you are doing.
|
|
* Default: true.
|
|
* @return int|WP_Error When the current term does not need to be split (or cannot be split on the current
|
|
* database schema), `$term_id` is returned. When the term is successfully split, the
|
|
* new term_id is returned. A WP_Error is returned for miscellaneous errors.
|
|
*/
|
|
function _split_shared_term( $term_id, $term_taxonomy_id, $record = true ) {
|
|
global $wpdb;
|
|
|
|
if ( is_object( $term_id ) ) {
|
|
$shared_term = $term_id;
|
|
$term_id = intval( $shared_term->term_id );
|
|
}
|
|
|
|
if ( is_object( $term_taxonomy_id ) ) {
|
|
$term_taxonomy = $term_taxonomy_id;
|
|
$term_taxonomy_id = intval( $term_taxonomy->term_taxonomy_id );
|
|
}
|
|
|
|
// If there are no shared term_taxonomy rows, there's nothing to do here.
|
|
$shared_tt_count = $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->term_taxonomy tt WHERE tt.term_id = %d AND tt.term_taxonomy_id != %d", $term_id, $term_taxonomy_id ) );
|
|
|
|
if ( ! $shared_tt_count ) {
|
|
return $term_id;
|
|
}
|
|
|
|
/*
|
|
* Verify that the term_taxonomy_id passed to the function is actually associated with the term_id.
|
|
* If there's a mismatch, it may mean that the term is already split. Return the actual term_id from the db.
|
|
*/
|
|
$check_term_id = $wpdb->get_var( $wpdb->prepare( "SELECT term_id FROM $wpdb->term_taxonomy WHERE term_taxonomy_id = %d", $term_taxonomy_id ) );
|
|
if ( $check_term_id != $term_id ) {
|
|
return $check_term_id;
|
|
}
|
|
|
|
// Pull up data about the currently shared slug, which we'll use to populate the new one.
|
|
if ( empty( $shared_term ) ) {
|
|
$shared_term = $wpdb->get_row( $wpdb->prepare( "SELECT t.* FROM $wpdb->terms t WHERE t.term_id = %d", $term_id ) );
|
|
}
|
|
|
|
$new_term_data = array(
|
|
'name' => $shared_term->name,
|
|
'slug' => $shared_term->slug,
|
|
'term_group' => $shared_term->term_group,
|
|
);
|
|
|
|
if ( false === $wpdb->insert( $wpdb->terms, $new_term_data ) ) {
|
|
return new WP_Error( 'db_insert_error', __( 'Could not split shared term.' ), $wpdb->last_error );
|
|
}
|
|
|
|
$new_term_id = (int) $wpdb->insert_id;
|
|
|
|
// Update the existing term_taxonomy to point to the newly created term.
|
|
$wpdb->update( $wpdb->term_taxonomy,
|
|
array( 'term_id' => $new_term_id ),
|
|
array( 'term_taxonomy_id' => $term_taxonomy_id )
|
|
);
|
|
|
|
// Reassign child terms to the new parent.
|
|
if ( empty( $term_taxonomy ) ) {
|
|
$term_taxonomy = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM $wpdb->term_taxonomy WHERE term_taxonomy_id = %d", $term_taxonomy_id ) );
|
|
}
|
|
|
|
$children_tt_ids = $wpdb->get_col( $wpdb->prepare( "SELECT term_taxonomy_id FROM $wpdb->term_taxonomy WHERE parent = %d AND taxonomy = %s", $term_id, $term_taxonomy->taxonomy ) );
|
|
if ( ! empty( $children_tt_ids ) ) {
|
|
foreach ( $children_tt_ids as $child_tt_id ) {
|
|
$wpdb->update( $wpdb->term_taxonomy,
|
|
array( 'parent' => $new_term_id ),
|
|
array( 'term_taxonomy_id' => $child_tt_id )
|
|
);
|
|
clean_term_cache( $term_id, $term_taxonomy->taxonomy );
|
|
}
|
|
} else {
|
|
// If the term has no children, we must force its taxonomy cache to be rebuilt separately.
|
|
clean_term_cache( $new_term_id, $term_taxonomy->taxonomy );
|
|
}
|
|
|
|
// Clean the cache for term taxonomies formerly shared with the current term.
|
|
$shared_term_taxonomies = $wpdb->get_row( $wpdb->prepare( "SELECT taxonomy FROM $wpdb->term_taxonomy WHERE term_id = %d", $term_id ) );
|
|
if ( $shared_term_taxonomies ) {
|
|
foreach ( $shared_term_taxonomies as $shared_term_taxonomy ) {
|
|
clean_term_cache( $term_id, $shared_term_taxonomy );
|
|
}
|
|
}
|
|
|
|
// Keep a record of term_ids that have been split, keyed by old term_id. See {@see wp_get_split_term()}.
|
|
if ( $record ) {
|
|
$split_term_data = get_option( '_split_terms', array() );
|
|
if ( ! isset( $split_term_data[ $term_id ] ) ) {
|
|
$split_term_data[ $term_id ] = array();
|
|
}
|
|
|
|
$split_term_data[ $term_id ][ $term_taxonomy->taxonomy ] = $new_term_id;
|
|
update_option( '_split_terms', $split_term_data );
|
|
}
|
|
|
|
/**
|
|
* Fires after a previously shared taxonomy term is split into two separate terms.
|
|
*
|
|
* @since 4.2.0
|
|
*
|
|
* @param int $term_id ID of the formerly shared term.
|
|
* @param int $new_term_id ID of the new term created for the $term_taxonomy_id.
|
|
* @param int $term_taxonomy_id ID for the term_taxonomy row affected by the split.
|
|
* @param string $taxonomy Taxonomy for the split term.
|
|
*/
|
|
do_action( 'split_shared_term', $term_id, $new_term_id, $term_taxonomy_id, $term_taxonomy->taxonomy );
|
|
|
|
return $new_term_id;
|
|
}
|
|
|
|
/**
|
|
* Splits a batch of shared taxonomy terms.
|
|
*
|
|
* @since 4.3.0
|
|
*
|
|
* @global wpdb $wpdb WordPress database abstraction object.
|
|
*/
|
|
function _wp_batch_split_terms() {
|
|
global $wpdb;
|
|
|
|
$lock_name = 'term_split.lock';
|
|
|
|
// Try to lock.
|
|
$lock_result = $wpdb->query( $wpdb->prepare( "INSERT IGNORE INTO `$wpdb->options` ( `option_name`, `option_value`, `autoload` ) VALUES (%s, %s, 'no') /* LOCK */", $lock_name, time() ) );
|
|
|
|
if ( ! $lock_result ) {
|
|
$lock_result = get_option( $lock_name );
|
|
|
|
// Bail if we were unable to create a lock, or if the existing lock is still valid.
|
|
if ( ! $lock_result || ( $lock_result > ( time() - HOUR_IN_SECONDS ) ) ) {
|
|
wp_schedule_single_event( time() + ( 5 * MINUTE_IN_SECONDS ), 'wp_split_shared_term_batch' );
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Update the lock, as by this point we've definitely got a lock, just need to fire the actions.
|
|
update_option( $lock_name, time() );
|
|
|
|
// Get a list of shared terms (those with more than one associated row in term_taxonomy).
|
|
$shared_terms = $wpdb->get_results(
|
|
"SELECT tt.term_id, t.*, count(*) as term_tt_count FROM {$wpdb->term_taxonomy} tt
|
|
LEFT JOIN {$wpdb->terms} t ON t.term_id = tt.term_id
|
|
GROUP BY t.term_id
|
|
HAVING term_tt_count > 1
|
|
LIMIT 10"
|
|
);
|
|
|
|
// No more terms, we're done here.
|
|
if ( ! $shared_terms ) {
|
|
update_option( 'finished_splitting_shared_terms', true );
|
|
delete_option( $lock_name );
|
|
return;
|
|
}
|
|
|
|
// Shared terms found? We'll need to run this script again.
|
|
wp_schedule_single_event( time() + ( 2 * MINUTE_IN_SECONDS ), 'wp_split_shared_term_batch' );
|
|
|
|
// Rekey shared term array for faster lookups.
|
|
$_shared_terms = array();
|
|
foreach ( $shared_terms as $shared_term ) {
|
|
$term_id = intval( $shared_term->term_id );
|
|
$_shared_terms[ $term_id ] = $shared_term;
|
|
}
|
|
$shared_terms = $_shared_terms;
|
|
|
|
// Get term taxonomy data for all shared terms.
|
|
$shared_term_ids = implode( ',', array_keys( $shared_terms ) );
|
|
$shared_tts = $wpdb->get_results( "SELECT * FROM {$wpdb->term_taxonomy} WHERE `term_id` IN ({$shared_term_ids})" );
|
|
|
|
// Split term data recording is slow, so we do it just once, outside the loop.
|
|
$split_term_data = get_option( '_split_terms', array() );
|
|
$skipped_first_term = $taxonomies = array();
|
|
foreach ( $shared_tts as $shared_tt ) {
|
|
$term_id = intval( $shared_tt->term_id );
|
|
|
|
// Don't split the first tt belonging to a given term_id.
|
|
if ( ! isset( $skipped_first_term[ $term_id ] ) ) {
|
|
$skipped_first_term[ $term_id ] = 1;
|
|
continue;
|
|
}
|
|
|
|
if ( ! isset( $split_term_data[ $term_id ] ) ) {
|
|
$split_term_data[ $term_id ] = array();
|
|
}
|
|
|
|
// Keep track of taxonomies whose hierarchies need flushing.
|
|
if ( ! isset( $taxonomies[ $shared_tt->taxonomy ] ) ) {
|
|
$taxonomies[ $shared_tt->taxonomy ] = 1;
|
|
}
|
|
|
|
// Split the term.
|
|
$split_term_data[ $term_id ][ $shared_tt->taxonomy ] = _split_shared_term( $shared_terms[ $term_id ], $shared_tt, false );
|
|
}
|
|
|
|
// Rebuild the cached hierarchy for each affected taxonomy.
|
|
foreach ( array_keys( $taxonomies ) as $tax ) {
|
|
delete_option( "{$tax}_children" );
|
|
_get_term_hierarchy( $tax );
|
|
}
|
|
|
|
update_option( '_split_terms', $split_term_data );
|
|
|
|
delete_option( $lock_name );
|
|
}
|
|
|
|
/**
|
|
* In order to avoid the _wp_batch_split_terms() job being accidentally removed,
|
|
* check that it's still scheduled while we haven't finished splitting terms.
|
|
*
|
|
* @ignore
|
|
* @since 4.3.0
|
|
*/
|
|
function _wp_check_for_scheduled_split_terms() {
|
|
if ( ! get_option( 'finished_splitting_shared_terms' ) && ! wp_next_scheduled( 'wp_split_shared_term_batch' ) ) {
|
|
wp_schedule_single_event( time() + MINUTE_IN_SECONDS, 'wp_split_shared_term_batch' );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check default categories when a term gets split to see if any of them need to be updated.
|
|
*
|
|
* @ignore
|
|
* @since 4.2.0
|
|
*
|
|
* @param int $term_id ID of the formerly shared term.
|
|
* @param int $new_term_id ID of the new term created for the $term_taxonomy_id.
|
|
* @param int $term_taxonomy_id ID for the term_taxonomy row affected by the split.
|
|
* @param string $taxonomy Taxonomy for the split term.
|
|
*/
|
|
function _wp_check_split_default_terms( $term_id, $new_term_id, $term_taxonomy_id, $taxonomy ) {
|
|
if ( 'category' != $taxonomy ) {
|
|
return;
|
|
}
|
|
|
|
foreach ( array( 'default_category', 'default_link_category', 'default_email_category' ) as $option ) {
|
|
if ( $term_id == get_option( $option, -1 ) ) {
|
|
update_option( $option, $new_term_id );
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check menu items when a term gets split to see if any of them need to be updated.
|
|
*
|
|
* @ignore
|
|
* @since 4.2.0
|
|
*
|
|
* @global wpdb $wpdb
|
|
*
|
|
* @param int $term_id ID of the formerly shared term.
|
|
* @param int $new_term_id ID of the new term created for the $term_taxonomy_id.
|
|
* @param int $term_taxonomy_id ID for the term_taxonomy row affected by the split.
|
|
* @param string $taxonomy Taxonomy for the split term.
|
|
*/
|
|
function _wp_check_split_terms_in_menus( $term_id, $new_term_id, $term_taxonomy_id, $taxonomy ) {
|
|
global $wpdb;
|
|
$post_ids = $wpdb->get_col( $wpdb->prepare(
|
|
"SELECT m1.post_id
|
|
FROM {$wpdb->postmeta} AS m1
|
|
INNER JOIN {$wpdb->postmeta} AS m2 ON ( m2.post_id = m1.post_id )
|
|
INNER JOIN {$wpdb->postmeta} AS m3 ON ( m3.post_id = m1.post_id )
|
|
WHERE ( m1.meta_key = '_menu_item_type' AND m1.meta_value = 'taxonomy' )
|
|
AND ( m2.meta_key = '_menu_item_object' AND m2.meta_value = '%s' )
|
|
AND ( m3.meta_key = '_menu_item_object_id' AND m3.meta_value = %d )",
|
|
$taxonomy,
|
|
$term_id
|
|
) );
|
|
|
|
if ( $post_ids ) {
|
|
foreach ( $post_ids as $post_id ) {
|
|
update_post_meta( $post_id, '_menu_item_object_id', $new_term_id, $term_id );
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* If the term being split is a nav_menu, change associations.
|
|
*
|
|
* @ignore
|
|
* @since 4.3.0
|
|
*
|
|
* @global wpdb $wpdb
|
|
*
|
|
* @param int $term_id ID of the formerly shared term.
|
|
* @param int $new_term_id ID of the new term created for the $term_taxonomy_id.
|
|
* @param int $term_taxonomy_id ID for the term_taxonomy row affected by the split.
|
|
* @param string $taxonomy Taxonomy for the split term.
|
|
*/
|
|
function _wp_check_split_nav_menu_terms( $term_id, $new_term_id, $term_taxonomy_id, $taxonomy ) {
|
|
if ( 'nav_menu' !== $taxonomy ) {
|
|
return;
|
|
}
|
|
|
|
// Update menu locations.
|
|
$locations = get_nav_menu_locations();
|
|
foreach ( $locations as $location => $menu_id ) {
|
|
if ( $term_id == $menu_id ) {
|
|
$locations[ $location ] = $new_term_id;
|
|
}
|
|
}
|
|
set_theme_mod( 'nav_menu_locations', $locations );
|
|
}
|
|
|
|
/**
|
|
* Get data about terms that previously shared a single term_id, but have since been split.
|
|
*
|
|
* @since 4.2.0
|
|
*
|
|
* @param int $old_term_id Term ID. This is the old, pre-split term ID.
|
|
* @return array Array of new term IDs, keyed by taxonomy.
|
|
*/
|
|
function wp_get_split_terms( $old_term_id ) {
|
|
$split_terms = get_option( '_split_terms', array() );
|
|
|
|
$terms = array();
|
|
if ( isset( $split_terms[ $old_term_id ] ) ) {
|
|
$terms = $split_terms[ $old_term_id ];
|
|
}
|
|
|
|
return $terms;
|
|
}
|
|
|
|
/**
|
|
* Get the new term ID corresponding to a previously split term.
|
|
*
|
|
* @since 4.2.0
|
|
*
|
|
* @param int $old_term_id Term ID. This is the old, pre-split term ID.
|
|
* @param string $taxonomy Taxonomy that the term belongs to.
|
|
* @return int|false If a previously split term is found corresponding to the old term_id and taxonomy,
|
|
* the new term_id will be returned. If no previously split term is found matching
|
|
* the parameters, returns false.
|
|
*/
|
|
function wp_get_split_term( $old_term_id, $taxonomy ) {
|
|
$split_terms = wp_get_split_terms( $old_term_id );
|
|
|
|
$term_id = false;
|
|
if ( isset( $split_terms[ $taxonomy ] ) ) {
|
|
$term_id = (int) $split_terms[ $taxonomy ];
|
|
}
|
|
|
|
return $term_id;
|
|
}
|
|
|
|
/**
|
|
* Generate a permalink for a taxonomy term archive.
|
|
*
|
|
* @since 2.5.0
|
|
*
|
|
* @global WP_Rewrite $wp_rewrite
|
|
*
|
|
* @param object|int|string $term The term object, ID, or slug whose link will be retrieved.
|
|
* @param string $taxonomy Optional. Taxonomy. Default empty.
|
|
* @return string|WP_Error HTML link to taxonomy term archive on success, WP_Error if term does not exist.
|
|
*/
|
|
function get_term_link( $term, $taxonomy = '' ) {
|
|
global $wp_rewrite;
|
|
|
|
if ( !is_object($term) ) {
|
|
if ( is_int( $term ) ) {
|
|
$term = get_term( $term, $taxonomy );
|
|
} else {
|
|
$term = get_term_by( 'slug', $term, $taxonomy );
|
|
}
|
|
}
|
|
|
|
if ( !is_object($term) )
|
|
$term = new WP_Error('invalid_term', __('Empty Term'));
|
|
|
|
if ( is_wp_error( $term ) )
|
|
return $term;
|
|
|
|
$taxonomy = $term->taxonomy;
|
|
|
|
$termlink = $wp_rewrite->get_extra_permastruct($taxonomy);
|
|
|
|
$slug = $term->slug;
|
|
$t = get_taxonomy($taxonomy);
|
|
|
|
if ( empty($termlink) ) {
|
|
if ( 'category' == $taxonomy )
|
|
$termlink = '?cat=' . $term->term_id;
|
|
elseif ( $t->query_var )
|
|
$termlink = "?$t->query_var=$slug";
|
|
else
|
|
$termlink = "?taxonomy=$taxonomy&term=$slug";
|
|
$termlink = home_url($termlink);
|
|
} else {
|
|
if ( $t->rewrite['hierarchical'] ) {
|
|
$hierarchical_slugs = array();
|
|
$ancestors = get_ancestors( $term->term_id, $taxonomy, '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);
|
|
}
|
|
$termlink = home_url( user_trailingslashit($termlink, 'category') );
|
|
}
|
|
// Back Compat filters.
|
|
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.
|
|
*/
|
|
$termlink = apply_filters( 'tag_link', $termlink, $term->term_id );
|
|
} 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.
|
|
*/
|
|
$termlink = apply_filters( 'category_link', $termlink, $term->term_id );
|
|
}
|
|
|
|
/**
|
|
* 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 );
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* @since 2.5.0
|
|
*
|
|
* @param array $args {
|
|
* Arguments about which post to use and how to format the output. Shares all of the arguments
|
|
* supported by get_the_taxonomies(), in addition to the following.
|
|
*
|
|
* @type int|WP_Post $post Post ID or object to get taxonomies of. Default current post.
|
|
* @type string $before Displays before the taxonomies. Default empty string.
|
|
* @type string $sep Separates each taxonomy. Default is a space.
|
|
* @type string $after Displays after the taxonomies. Default empty string.
|
|
* }
|
|
* @param array $args See {@link get_the_taxonomies()} for a description of arguments and their defaults.
|
|
*/
|
|
function the_taxonomies( $args = array() ) {
|
|
$defaults = array(
|
|
'post' => 0,
|
|
'before' => '',
|
|
'sep' => ' ',
|
|
'after' => '',
|
|
);
|
|
|
|
$r = wp_parse_args( $args, $defaults );
|
|
|
|
echo $r['before'] . join( $r['sep'], get_the_taxonomies( $r['post'], $r ) ) . $r['after'];
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* @since 2.5.0
|
|
*
|
|
* @param int|WP_Post $post Optional. Post ID or WP_Post object. Default is global $post.
|
|
* @param array $args {
|
|
* Optional. Arguments about how to format the list of taxonomies. Default empty array.
|
|
*
|
|
* @type string $template Template for displaying a taxonomy label and list of terms.
|
|
* Default is "Label: Terms."
|
|
* @type string $term_template Template for displaying a single term in the list. Default is the term name
|
|
* linked to its archive.
|
|
* }
|
|
* @return array List of taxonomies.
|
|
*/
|
|
function get_the_taxonomies( $post = 0, $args = array() ) {
|
|
$post = get_post( $post );
|
|
|
|
$args = wp_parse_args( $args, array(
|
|
/* translators: %s: taxonomy label, %l: list of terms formatted as per $term_template */
|
|
'template' => __( '%s: %l.' ),
|
|
'term_template' => '<a href="%1$s">%2$s</a>',
|
|
) );
|
|
|
|
$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'] ) ) {
|
|
$t['template'] = $args['template'];
|
|
}
|
|
if ( empty( $t['term_template'] ) ) {
|
|
$t['term_template'] = $args['term_template'];
|
|
}
|
|
|
|
$terms = get_object_term_cache( $post->ID, $taxonomy );
|
|
if ( false === $terms ) {
|
|
$terms = wp_get_object_terms( $post->ID, $taxonomy, $t['args'] );
|
|
}
|
|
$links = array();
|
|
|
|
foreach ( $terms as $term ) {
|
|
$links[] = wp_sprintf( $t['term_template'], esc_attr( get_term_link( $term ) ), $term->name );
|
|
}
|
|
if ( $links ) {
|
|
$taxonomies[$taxonomy] = wp_sprintf( $t['template'], $t['label'], $links, $terms );
|
|
}
|
|
}
|
|
return $taxonomies;
|
|
}
|
|
|
|
/**
|
|
* Retrieve all taxonomies of a post with just the names.
|
|
*
|
|
* @since 2.5.0
|
|
*
|
|
* @param int|WP_Post $post Optional. Post ID or WP_Post object. Default is global $post.
|
|
* @return array
|
|
*/
|
|
function get_post_taxonomies( $post = 0 ) {
|
|
$post = get_post( $post );
|
|
|
|
return get_object_taxonomies($post);
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
*
|
|
* @param int $object_id ID of the object (post ID, link ID, ...).
|
|
* @param string $taxonomy Single taxonomy name.
|
|
* @param int|string|array $terms Optional. Term term_id, name, slug or array of said. Default null.
|
|
* @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 );
|
|
if ( false === $object_terms )
|
|
$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 term is an int, check against term_ids only.
|
|
if ( $ints && in_array( $object_term->term_id, $ints ) ) {
|
|
return true;
|
|
}
|
|
|
|
if ( $strs ) {
|
|
// Only check numeric strings against term_id, to avoid false matches due to type juggling.
|
|
$numeric_strs = array_map( 'intval', array_filter( $strs, 'is_numeric' ) );
|
|
if ( in_array( $object_term->term_id, $numeric_strs, true ) ) {
|
|
return true;
|
|
}
|
|
|
|
if ( in_array( $object_term->name, $strs ) ) return true;
|
|
if ( in_array( $object_term->slug, $strs ) ) return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Determine if the given object type is associated with the given taxonomy.
|
|
*
|
|
* @since 3.0.0
|
|
*
|
|
* @param string $object_type Object type string.
|
|
* @param string $taxonomy Single taxonomy name.
|
|
* @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;
|
|
}
|
|
return in_array( $taxonomy, $taxonomies );
|
|
}
|
|
|
|
/**
|
|
* Get an array of ancestor IDs for a given object.
|
|
*
|
|
* @since 3.1.0
|
|
* @since 4.1.0 Introduced the `$resource_type` argument.
|
|
*
|
|
* @param int $object_id Optional. The ID of the object. Default 0.
|
|
* @param string $object_type Optional. The type of object for which we'll be retrieving
|
|
* ancestors. Accepts a post type or a taxonomy name. Default empty.
|
|
* @param string $resource_type Optional. Type of resource $object_type is. Accepts 'post_type'
|
|
* or 'taxonomy'. Default empty.
|
|
* @return array An array of ancestors from lowest to highest in the hierarchy.
|
|
*/
|
|
function get_ancestors( $object_id = 0, $object_type = '', $resource_type = '' ) {
|
|
$object_id = (int) $object_id;
|
|
|
|
$ancestors = array();
|
|
|
|
if ( empty( $object_id ) ) {
|
|
|
|
/** This filter is documented in wp-includes/taxonomy.php */
|
|
return apply_filters( 'get_ancestors', $ancestors, $object_id, $object_type, $resource_type );
|
|
}
|
|
|
|
if ( ! $resource_type ) {
|
|
if ( is_taxonomy_hierarchical( $object_type ) ) {
|
|
$resource_type = 'taxonomy';
|
|
} elseif ( post_type_exists( $object_type ) ) {
|
|
$resource_type = 'post_type';
|
|
}
|
|
}
|
|
|
|
if ( 'taxonomy' === $resource_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);
|
|
}
|
|
} elseif ( 'post_type' === $resource_type ) {
|
|
$ancestors = get_post_ancestors($object_id);
|
|
}
|
|
|
|
/**
|
|
* Filter a given object's ancestors.
|
|
*
|
|
* @since 3.1.0
|
|
* @since 4.1.1 Introduced the `$resource_type` parameter.
|
|
*
|
|
* @param array $ancestors An array of object ancestors.
|
|
* @param int $object_id Object ID.
|
|
* @param string $object_type Type of object.
|
|
* @param string $resource_type Type of resource $object_type is.
|
|
*/
|
|
return apply_filters( 'get_ancestors', $ancestors, $object_id, $object_type, $resource_type );
|
|
}
|
|
|
|
/**
|
|
* Returns the term's parent's term_ID.
|
|
*
|
|
* @since 3.1.0
|
|
*
|
|
* @param int $term_id Term ID.
|
|
* @param string $taxonomy Taxonomy name.
|
|
* @return int|false 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 {@see 'wp_update_term_parent'} filter.
|
|
*
|
|
* @since 3.1.0
|
|
*
|
|
* @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;
|
|
|
|
// There's a loop, but it doesn't contain $term_id. Break the loop.
|
|
foreach ( array_keys( $loop ) as $loop_member )
|
|
wp_update_term( $loop_member, $taxonomy, array( 'parent' => 0 ) );
|
|
|
|
return $parent;
|
|
}
|