protected function _get_term($_term)
{
if (!$_term) {
return false;
}
if ($_term->parent === $this->_parent_term_id) {
return $_term;
}
global $wpdb;
$query = "SELECT t.*, tt.*\n\t\t\t\tFROM {$wpdb->terms} AS t\n\t\t\t\tINNER JOIN {$wpdb->term_taxonomy} AS tt ON t.term_id = tt.term_id\n\t\t\t\tWHERE t.slug = %s\n\t\t\t\tAND tt.taxonomy = %s\n\t\t\t\tAND tt.parent = %d\n\t\t\t\tLIMIT 1";
$query = $wpdb->prepare($query, $this->_args['slug'], $this->_taxonomy, $this->_parent_term_id);
$terms = $wpdb->get_results($query);
if (!$terms) {
$query = "SELECT t.*, tt.*\n\t\t\t\t\tFROM {$wpdb->terms} AS t\n\t\t\t\t\tINNER JOIN {$wpdb->term_taxonomy} AS tt ON t.term_id = tt.term_id\n\t\t\t\t\tWHERE tt.term_id = %d\n\t\t\t\t\tAND tt.taxonomy = %s\n\t\t\t\t\tLIMIT 1";
$query = $wpdb->prepare($query, $this->_term_id, $this->_taxonomy);
$terms = $wpdb->get_results($query);
}
$term = $terms[0];
$term_obj = new WP_Term($term);
$term_obj->filter($term_obj->filter);
return $term_obj;
}
function save_term_handler($term_id, $tt_id, $taxonomy)
{
if (class_exists('WP_Term')) {
$term_object = WP_Term::get_instance($term_id, $taxonomy);
} else {
$term_object = get_term_by('id', $term_id, $taxonomy);
}
/**
* Fires when the client needs to sync a new term
*
* @since 4.2.0
*
* @param object the Term object
*/
do_action('jetpack_sync_save_term', $term_object);
}
/**
* 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
* @since 4.4.0 Converted to return a WP_Term object if `$output` is `OBJECT`.
* The `$taxonomy` parameter was made optional.
*
* @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|WP_Term|object $term If integer, term data will be fetched from the database, or from the cache if
* available. If stdClass object (as in the results of a database query), will apply
* filters and return a `WP_Term` object corresponding to the `$term` data. If `WP_Term`,
* will return `$term`.
* @param string $taxonomy Optional. Taxonomy name that $term is part of.
* @param string $output Constant OBJECT, ARRAY_A, or ARRAY_N
* @param string $filter Optional, default is raw or no WordPress defined filter will applied.
* @return mixed Type corresponding to `$output` on success or null on failure. When `$output` is `OBJECT`,
* a WP_Term instance is returned. If taxonomy does not exist then WP_Error will be returned.
*/
function get_term($term, $taxonomy = '', $output = OBJECT, $filter = 'raw')
{
if (empty($term)) {
return new WP_Error('invalid_term', __('Empty Term'));
}
if ($taxonomy && !taxonomy_exists($taxonomy)) {
return new WP_Error('invalid_taxonomy', __('Invalid taxonomy'));
}
if ($term instanceof WP_Term) {
$_term = $term;
} elseif (is_object($term)) {
if (empty($term->filter) || 'raw' === $term->filter) {
$_term = sanitize_term($term, $taxonomy, 'raw');
$_term = new WP_Term($_term);
} else {
$_term = WP_Term::get_instance($term->term_id);
}
} else {
$_term = WP_Term::get_instance($term);
}
// If `$taxonomy` was provided, make sure it matches the taxonomy of the located term.
if ($_term && $taxonomy && $taxonomy !== $_term->taxonomy) {
// If there are two terms with the same ID, split the other one to a new term.
$new_term_id = _split_shared_term($_term->term_id, $_term->term_taxonomy_id);
// If no split occurred, this is an invalid request. Return null (not WP_Error) for back compat.
if ($new_term_id === $_term->term_id) {
return null;
// The term has been split. Refetch the term from the proper taxonomy.
} else {
return get_term($_term->term_id, $taxonomy, $output, $filter);
}
}
if (!$_term) {
return null;
}
/**
* Filter a term.
*
* @since 2.3.0
* @since 4.4.0 `$_term` can now also be a WP_Term object.
*
* @param int|WP_Term $_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
* @since 4.4.0 `$_term` can now also be a WP_Term object.
*
* @param int|WP_Term $_term Term object or ID.
* @param string $taxonomy The taxonomy slug.
*/
$_term = apply_filters("get_{$taxonomy}", $_term, $taxonomy);
// Sanitize term, according to the specified filter.
$_term->filter($filter);
if ($output == ARRAY_A) {
return $_term->to_array();
} elseif ($output == ARRAY_N) {
return array_values($_term->to_array());
}
return $_term;
}
/**
* 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
* @since 4.4.0 Converted to return a WP_Term object if `$output` is `OBJECT`.
* The `$taxonomy` parameter was made optional.
*
* @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|WP_Term|object $term If integer, term data will be fetched from the database, or from the cache if
* available. If stdClass object (as in the results of a database query), will apply
* filters and return a `WP_Term` object corresponding to the `$term` data. If `WP_Term`,
* will return `$term`.
* @param string $taxonomy Optional. Taxonomy name that $term is part of.
* @param string $output Constant OBJECT, ARRAY_A, or ARRAY_N
* @param string $filter Optional, default is raw or no WordPress defined filter will applied.
* @return mixed Type corresponding to `$output` on success or null on failure. When `$output` is `OBJECT`,
* a WP_Term instance is returned. If taxonomy does not exist then WP_Error will be returned.
*/
function get_term($term, $taxonomy = '', $output = OBJECT, $filter = 'raw')
{
if (empty($term)) {
return new WP_Error('invalid_term', __('Empty Term'));
}
if ($taxonomy && !taxonomy_exists($taxonomy)) {
return new WP_Error('invalid_taxonomy', __('Invalid taxonomy'));
}
if ($term instanceof WP_Term) {
$_term = $term;
} elseif (is_object($term)) {
if (empty($term->filter) || 'raw' === $term->filter) {
$_term = sanitize_term($term, $taxonomy, 'raw');
$_term = new WP_Term($_term);
} else {
$_term = WP_Term::get_instance($term->term_id);
}
} else {
$_term = WP_Term::get_instance($term, $taxonomy);
}
if (is_wp_error($_term)) {
return $_term;
} elseif (!$_term) {
return null;
}
/**
* Filter a term.
*
* @since 2.3.0
* @since 4.4.0 `$_term` can now also be a WP_Term object.
*
* @param int|WP_Term $_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
* @since 4.4.0 `$_term` can now also be a WP_Term object.
*
* @param int|WP_Term $_term Term object or ID.
* @param string $taxonomy The taxonomy slug.
*/
$_term = apply_filters("get_{$taxonomy}", $_term, $taxonomy);
// Sanitize term, according to the specified filter.
$_term->filter($filter);
if ($output == ARRAY_A) {
return $_term->to_array();
} elseif ($output == ARRAY_N) {
return array_values($_term->to_array());
}
return $_term;
}
/**
* Retrieve WP_Term instance.
*
* @since 4.4.0
* @access public
* @static
*
* @global wpdb $wpdb WordPress database abstraction object.
*
* @param int $term_id Term ID.
* @param string $taxonomy Optional. Limit matched terms to those matching `$taxonomy`. Only used for
* disambiguating potentially shared terms.
* @return WP_Term|WP_Error|false Term object, if found. WP_Error if `$term_id` is shared between taxonomies and
* there's insufficient data to distinguish which term is intended.
* False for other failures.
*/
public static function get_instance($term_id, $taxonomy = null)
{
global $wpdb;
$term_id = (int) $term_id;
if (!$term_id) {
return false;
}
$_term = wp_cache_get($term_id, 'terms');
// If there isn't a cached version, hit the database.
if (!$_term || $taxonomy && $taxonomy !== $_term->taxonomy) {
// Grab all matching terms, in case any are shared between taxonomies.
$terms = $wpdb->get_results($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 t.term_id = %d", $term_id));
if (!$terms) {
return false;
}
// If a taxonomy was specified, find a match.
if ($taxonomy) {
foreach ($terms as $match) {
if ($taxonomy === $match->taxonomy) {
$_term = $match;
break;
}
}
// If only one match was found, it's the one we want.
} elseif (1 === count($terms)) {
$_term = reset($terms);
// Otherwise, the term must be shared between taxonomies.
} else {
// If the term is shared only with invalid taxonomies, return the one valid term.
foreach ($terms as $t) {
if (!taxonomy_exists($t->taxonomy)) {
continue;
}
// Only hit if we've already identified a term in a valid taxonomy.
if ($_term) {
return new WP_Error('ambiguous_term_id', __('Term ID is shared between multiple taxonomies'), $term_id);
}
$_term = $t;
}
}
if (!$_term) {
return false;
}
// Don't return terms from invalid taxonomies.
if (!taxonomy_exists($_term->taxonomy)) {
return new WP_Error('invalid_taxonomy', __('Invalid taxonomy'));
}
$_term = sanitize_term($_term, $_term->taxonomy, 'raw');
// Don't cache terms that are shared between taxonomies.
if (1 === count($terms)) {
wp_cache_add($term_id, $_term, 'terms');
}
}
$term_obj = new WP_Term($_term);
$term_obj->filter($term_obj->filter);
return $term_obj;
}
/**
* Retrieve WP_Term instance.
*
* @since 4.4.0
* @access public
* @static
*
* @global wpdb $wpdb WordPress database abstraction object.
*
* @param int $term_id Term ID.
* @return WP_Term|false Term object, false otherwise.
*/
public static function get_instance($term_id)
{
global $wpdb;
$term_id = (int) $term_id;
if (!$term_id) {
return false;
}
$_term = wp_cache_get($term_id, 'terms');
// If there isn't a cached version, hit the database.
if (!$_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 t.term_id = %d LIMIT 1", $term_id));
if (!$_term) {
return false;
}
$_term = sanitize_term($_term, $_term->taxonomy, 'raw');
wp_cache_add($term_id, $_term, 'terms');
}
$term_obj = new WP_Term($_term);
$term_obj->filter($term_obj->filter);
return $term_obj;
}
/**
* @ticket 37738
*/
public function test_get_instance_should_fail_for_class()
{
$class = new stdClass();
$found = WP_Term::get_instance($class);
$this->assertFalse($found);
}
/**
* Create new Instance of a Term Item
*
* @param WP_Term|int $term
* @param array $args {
*
* @type string $taxonomy
* @type string $instance_class
* @type string $list_owner
*
*}
* @return mixed
*
* @future Alias this with make_new_term() so it can be called as WPLib::make_new_term( $term_id )
*/
static function make_new_item($term, $args = array())
{
$args = wp_parse_args($args, array('instance_class' => false, 'taxonomy' => false, 'list_owner' => 'WPLib_Terms'));
if (is_numeric($term)) {
if ($args['taxonomy']) {
$term = WP_Term::get_instance($term, $args['taxonomy']);
} else {
global $wp_version;
if (version_compare($wp_version, '4.3', '<')) {
/**
* This only works in WordPress DBs created since 4.3+.
*
* @see https://make.wordpress.org/core/2015/06/09/eliminating-shared-taxonomy-terms-in-wordpress-4-3/
*/
$err_msg = __("Cannot call %s() without \$args['taxonomy'] set in WordPress version 4.2 or earlier.", 'wplib');
WPLib::trigger_error($err_msg, __METHOD__);
} else {
$term = WP_Term::get_instance($term);
}
}
}
if (!$args['instance_class']) {
$args['instance_class'] = WPLib::get_constant('INSTANCE_CLASS', $args['list_owner']);
}
if (!$args['instance_class']) {
$args['instance_class'] = self::get_taxonomy_class($term->taxonomy);
}
$instance_class = $args['instance_class'];
return $instance_class ? new $instance_class($term) : null;
}
