/**

* A simple flag to stop infinite recursion in various places.

*

* @var boolean

**/

protected $no_recursion;

/**

* The current version for purposes of rewrite rules, any

* DB updates, cache busting, etc

*

* @var int

**/

protected $version = 1;

/**

* The shadow taxonomies created to handle the translated terms.

*

* @var array

**/

protected $taxonomies;

/**

* The languages represented by each of the shadow taxonomies.

*

* @var array

**/

protected $lang_map;

/**

* Setup any add_action or add_filter calls. Initiate properties.

*

* @return void

**/

public function __construct() {

$this->setup( 'babble-taxonomy', 'plugin' );

$this->add_action( 'bbl_created_new_shadow_post', 'created_new_shadow_post', null, 2 );

$this->add_action( 'bbl_registered_shadow_post_types', 'registered_shadow_post_types' );

$this->add_action( 'init', 'init_early', 0 );

$this->add_action( 'parse_request' );

$this->add_action( 'registered_taxonomy', null, null, 3 );

$this->add_action( 'save_post', null, null, 2 );

$this->add_action( 'set_object_terms', null, null, 5 );

$this->add_filter( 'get_terms' );

$this->add_filter( 'term_link', null, null, 3 );

$this->add_filter( 'bbl_translated_taxonomy', null, null, 2 );

$this->add_filter( 'body_class', null, null, 2 );

$this->add_filter( 'taxonomy_template' );

$this->add_filter( 'admin_body_class' );

}

// WP HOOKS

// ========

/**

* Hooks the WP init action early

*

* @return void

**/

public function init_early() {

// This translation will connect each term with it's translated equivalents

register_taxonomy( 'term_translation', array(), array(

'rewrite' => false,

'public' => false,

'show_ui' => false,

'show_in_nav_menus' => false,

'label' => __( 'Term Translation ID', 'babble' ),

) );

}

/**

* Hooks the WP registered_taxonomy action

*

* @param string $taxonomy The name of the newly registered taxonomy

* @param string|array $args The object_type(s)

* @param array $args The args passed to register the taxonomy

* @return void

**/

public function registered_taxonomy( $taxonomy, $object_type, $args ) {

if ( in_array( $taxonomy, $this->ignored_taxonomies() ) ) {

return;

}

if ( $this->no_recursion ) {

return;

}

$this->no_recursion = true;

if ( ! is_array( $object_type ) ) {

$object_type = array_unique( (array) $object_type );

}

// Use the Babble term counting function, unless the taxonomy registrant

// has defined their own – in which case we'll just have to hope against

// hope that it's Babble aware :S

// FIXME: Setting this in the following fashion seems hacky… I feel uncomfortable.

if ( empty( $GLOBALS[ 'wp_taxonomies' ][ $taxonomy ]->update_count_callback ) ) {

$GLOBALS[ 'wp_taxonomies' ][ $taxonomy ]->update_count_callback = array( $this, 'update_post_term_count' );

}

// Untranslated taxonomies do not have shadow equivalents in each language,

// but do apply to the bast post_type and all it's shadow post_types.

if ( ! $this->is_taxonomy_translated( $taxonomy ) ) {

// Apply this taxonomy to all the shadow post types

// of all of the base post_types it applies to.

foreach ( $object_type as $ot ) {

if ( ! ( $base_post_type = bbl_get_base_post_type( $ot ) ) ) {

continue;

}

$shadow_post_types = bbl_get_shadow_post_types( $base_post_type );

foreach ( $shadow_post_types as $shadow_post_type ) {

register_taxonomy_for_object_type( $taxonomy, $shadow_post_type );

}

}

$this->no_recursion = false;

return;

}

// @FIXME: Not sure this is the best way to specify languages

$langs = bbl_get_active_langs();

// Lose the default language as any existing taxonomies are in that language

unset( $langs[ bbl_get_default_lang_url_prefix() ] );

// @FIXME: Is it reckless to convert ALL object instances in $args to an array?

foreach ( $args as $key => & $arg ) {

if ( is_object( $arg ) )

$arg = get_object_vars( $arg );

// Don't set any args reserved for built-in post_types

if ( '_' == substr( $key, 0, 1 ) )

unset( $args[ $key ] );

}

#$args[ 'rewrite' ] = false;

unset( $args[ 'name' ] );

unset( $args[ 'object_type' ] );

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

foreach ( $langs as $lang ) {

$new_args = $args;

$new_object_type = array();

// N.B. Here we assume that the taxonomy is on a post type

foreach( $object_type as $ot )

$new_object_type[] = bbl_get_post_type_in_lang( $ot, $lang->code );

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

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

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

// Do I not need to add this query_var into the query_vars filter? It seems not.

$new_args[ 'query_var' ] = $new_args[ 'rewrite' ][ 'slug' ] = $this->get_slug_in_lang( $slug, $lang->code );

}

// @FIXME: Note currently we are in danger of a taxonomy name being longer than 32 chars

// Perhaps we need to create some kind of map like (taxonomy) + (lang) => (shadow translated taxonomy)

$new_taxonomy = strtolower( "{$taxonomy}_{$lang->code}" );

$this->taxonomies[ $new_taxonomy ] = $taxonomy;

if ( ! isset( $this->lang_map[ $lang->code ] ) || ! is_array( $this->lang_map[ $lang->code ] ) )

$this->lang_map[ $lang->code ] = array();

$this->lang_map[ $lang->code ][ $taxonomy ] = $new_taxonomy;

register_taxonomy( $new_taxonomy, $new_object_type, $new_args );

}

// bbl_stop_logging();

$this->no_recursion = false;

}

public function ignored_taxonomies() {

return array( 'post_translation', 'term_translation' );

}

public function is_taxonomy_translated( $taxonomy ) {

if( in_array( $taxonomy, $this->ignored_taxonomies() ) ) {

return false;

}

// @FIXME: Remove this when menu's are translatable

if( 'nav_menu' == $taxonomy ) {

return false;

}

return apply_filters( 'bbl_translated_taxonomy', true, $taxonomy );

}

/**

* Hooks the WP bbl_registered_shadow_post_types action to check that we've applied

* all untranslated taxonomies to the shadow post types created for this base

* post type.

*

* @param string $post_type The post type for which the shadow post types have been registered.

* @return void

**/

public function registered_shadow_post_types( $post_type ) {

$taxonomies = get_object_taxonomies( $post_type );

$object_type = (array) $post_type;

foreach ( $taxonomies as $taxonomy ) {

// Untranslated taxonomies do not have shadow equivalents in each language,

// but do apply to the bast post_type and all it's shadow post_types.

if ( ! $this->is_taxonomy_translated( $taxonomy ) ) {

// Apply this taxonomy to all the shadow post types

// of all of the base post_types it applies to.

foreach ( $object_type as $ot ) {

if ( ! ( $base_post_type = bbl_get_base_post_type( $ot ) ) ) {

continue;

}

$shadow_post_types = bbl_get_shadow_post_types( $base_post_type );

foreach ( $shadow_post_types as $shadow_post_type ) {

register_taxonomy_for_object_type( $taxonomy, $shadow_post_type );

}

}

}

}

}

/**

* Hooks the Babble action bbl_created_new_shadow_post, which is fired

* when a new translation post is created, to sync any existing untranslated

* taxonomy terms.

*

* @param int $new_post_id The ID of the new post (to sync to)

* @param int $origin_post_id The ID of the originating post (to sync from)

* @return void

**/

public function created_new_shadow_post( $new_post_id, $origin_post_id ) {

$new_post = get_post( $new_post_id );

if ( ! ( $origin_post = get_post( $origin_post_id ) ) ) {

return;

}

if ( $this->no_recursion ) {

return;

}

$this->no_recursion = true;

$taxonomies = get_object_taxonomies( $origin_post->post_type );

foreach ( $taxonomies as $taxonomy ) {

if ( ! $this->is_taxonomy_translated( $taxonomy ) ) {

$term_ids = wp_get_object_terms( $origin_post->ID, $taxonomy, array( 'fields' => 'ids' ) );

$term_ids = array_map( 'absint', $term_ids );

wp_set_object_terms( $new_post->ID, $term_ids, $taxonomy );

}

}

$this->no_recursion = false;

}

/**

* Hooks the WP save_post action to resync data

* when requested.

*

* @param int $post_id The ID of the WP post

* @param object $post The WP Post object

* @return void

**/

public function save_post( $post_id, $post ) {

$this->maybe_resync_terms( $post_id, $post );

}

/**

* Hooks the WordPress term_link filter to provide functions to provide

* appropriate links for the shadow taxonomies.

*

* @see get_term_link from whence much of this was copied

*

* @param string $termlink The currently generated term URL

* @param object $term The WordPress term object we're generating a link for

* @param string $taxonomy The

* @return string The term link

**/

public function term_link( $termlink, $term, $taxonomy ) {

$taxonomy = strtolower( $taxonomy );

// No need to worry about the built in taxonomies

if ( 'post_tag' == $taxonomy || 'category' == $taxonomy || ! isset( $this->taxonomies[ $taxonomy ] ) ) {

return $termlink;

}

// Deal with our shadow taxonomies

if ( ! ( $base_taxonomy = $this->get_base_taxonomy( $taxonomy ) ) ) {

return $termlink;

}

// START copying from get_term_link, replacing $taxonomy with $base_taxonomy

global $wp_rewrite;

if ( !is_object($term) ) {

if ( is_int($term) ) {

$term = &get_term($term, $base_taxonomy);

} else {

$term = &get_term_by('slug', $term, $base_taxonomy);

}

}

if ( !is_object($term) ) {

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

}

if ( is_wp_error( $term ) ) {

return $term;

}

$termlink = $wp_rewrite->get_extra_permastruct($base_taxonomy);

$slug = $term->slug;

$t = get_taxonomy($base_taxonomy);

if ( empty($termlink) ) {

if ( 'category' == $base_taxonomy ) {

$termlink = '?cat=' . $term->term_id;

} elseif ( $t->query_var ) {

$termlink = "?$t->query_var=$slug";

} else {

$termlink = "?taxonomy=$base_taxonomy&term=$slug";

}

$termlink = home_url($termlink);

} else {

if ( $t->rewrite['hierarchical'] ) {

$hierarchical_slugs = array();

$ancestors = get_ancestors($term->term_id, $base_taxonomy);

foreach ( (array)$ancestors as $ancestor ) {

$ancestor_term = get_term($ancestor, $base_taxonomy);

$hierarchical_slugs[] = $ancestor_term->slug;

}

$hierarchical_slugs = array_reverse($hierarchical_slugs);

$hierarchical_slugs[] = $slug;

$termlink = str_replace("%$base_taxonomy%", implode('/', $hierarchical_slugs), $termlink);

} else {

$termlink = str_replace("%$base_taxonomy%", $slug, $termlink);

}

$termlink = home_url( user_trailingslashit($termlink, 'category') );

}

// STOP copying from get_term_link

return $termlink;

}

/**

* Hooks the WP get_terms filter to ensure the terms all have transids.

*

* @param array $terms The terms which have been got

* @return array The terms which were got

**/

public function get_terms( $terms ) {

foreach ( $terms as $term ) {

if ( empty( $term ) ) {

continue;

}

if ( isset( $this->taxonomies ) ) {

continue;

}

if ( isset( $this->taxonomies[ $term->taxonomy ] ) ) {

if ( ! $this->get_transid( $term->term_id ) ) {

throw new exception( "ERROR: Translated term ID $term->term_id does not have a transid" );

} else {

continue;

}

}

if ( ! $this->get_transid( $term->term_id ) ) {

$this->set_transid( $term->term_id );

}

}

return $terms;

}

/**

* Hooks the WP parse_request action

*

* FIXME: Should I be extending and replacing the WP class?

*

* @param object $wp WP object, passed by reference (so no need to return)

* @return void

**/

public function parse_request( $wp ) {

if ( is_admin() ) {

return;

}

// Sequester the original query, in case we need it to get the default content later

if ( ! isset( $wp->query_vars[ 'bbl_tax_original_query' ] ) ) {

$wp->query_vars[ 'bbl_tax_original_query' ] = $wp->query_vars;

}

$taxonomy = false;

$terms = false;

$taxonomies = get_taxonomies( null, 'objects' );

$lang_taxonomies = array();

foreach ( $taxonomies as $taxonomy => $tax_obj ) {

$tax = $this->get_taxonomy_in_lang( $taxonomy, bbl_get_current_lang_code() );

$lang_taxonomies[ $tax_obj->rewrite[ 'slug' ] ] = $tax;

}

if ( isset( $wp->query_vars[ 'tag' ] ) ) {

$taxonomy = $this->get_taxonomy_in_lang( 'post_tag', $wp->query_vars[ 'lang' ] );

$terms = $wp->query_vars[ 'tag' ];

unset( $wp->query_vars[ 'tag' ] );

} else if ( isset( $wp->query_vars[ 'category_name' ] ) ) {

$taxonomy = $this->get_taxonomy_in_lang( 'category', $wp->query_vars[ 'lang' ] );

$terms = $wp->query_vars[ 'category_name' ];

unset( $wp->query_vars[ 'category_name' ] );

} else {

$taxonomies = array();

foreach ( $lang_taxonomies as $slug => $tax ) {

if ( isset( $wp->query_vars[ $slug ] ) ) {

$taxonomies[] = $tax;

break;

}

}

if ( $taxonomies ) {

$post_types = array();

foreach ( $taxonomies as $taxonomy ) {

$taxonomy = get_taxonomy( $taxonomy );

$post_types = array_merge( $post_types, $taxonomy->object_type );

// Filter out the post_types not in this language

foreach ( $post_types as & $post_type ) {

$post_type = bbl_get_post_type_in_lang( $post_type );

}

$post_types = array_unique( $post_types );

}

$wp->query_vars[ 'post_type' ] = $post_types;

}

}

if ( $taxonomy && $terms ) {

if ( ! isset( $wp->query_vars[ 'tax_query' ] ) || ! is_array( $wp->query_vars[ 'tax_query' ] ) ) {

$wp->query_vars[ 'tax_query' ] = array();

}

$wp->query_vars[ 'tax_query' ][] = array(

'taxonomy' => $taxonomy,

'field' => 'slug',

'terms' => $terms,

);

}

}

/**

* Hooks the WP set_object_terms action to sync any untranslated

* taxonomies across to the translations.

*

* @param int $object_id The object to relate to

* @param array $terms The slugs or ids of the terms

* @param array $tt_ids The term_taxonomy_ids

* @param string $taxonomy The name of the taxonomy for which terms are being set

* @param bool $append If false will delete difference of terms

* @return void

**/

public function set_object_terms( $object_id, $terms, $tt_ids, $taxonomy, $append ) {

if ( $this->no_recursion ) {

return;

}

$this->no_recursion = true;

// DO NOT SYNC THE TRANSID TAXONOMIES!!

if ( in_array( $taxonomy, $this->ignored_taxonomies() ) ) {

$this->no_recursion = false;

return;

}

if ( $this->is_taxonomy_translated( $taxonomy ) ) {

// Here we assume that this taxonomy is on a post type

$translations = bbl_get_post_translations( $object_id );

foreach ( $translations as $lang_code => & $translation ) {

if ( bbl_get_post_lang_code( $object_id ) == $lang_code ) {

continue;

}

$translated_taxonomy = bbl_get_taxonomy_in_lang( $taxonomy, $lang_code );

$translated_terms = array();

foreach ( $terms as $term ) {

if ( is_int( $term ) ) {

$_term = get_term( $term, $taxonomy );

} else {

$_term = get_term_by( 'name', $term, $taxonomy );

}

if ( is_wp_error( $_term ) or empty( $_term ) ) {

continue;

}

$translated_term = $this->get_term_in_lang( $_term->term_id, $taxonomy, $lang_code, false );

$translated_terms[] = (int) $translated_term->term_id;

}

$result = wp_set_object_terms( $translation->ID, $translated_terms, $translated_taxonomy, $append );

}

} else {

// Here we assume that this taxonomy is on a post type

$translations = bbl_get_post_translations( $object_id );

foreach ( $translations as $lang_code => & $translation ) {

if ( bbl_get_post_lang_code( $object_id ) == $lang_code ) {

continue;

}

wp_set_object_terms( $translation->ID, $terms, $taxonomy, $append );

}

}

$this->no_recursion = false;

}

/**

* Hooks the WP body_class filter to add classes to the

* body element.

*

* @param array $classes An array of class strings, poss with some indexes containing more than one space separated class

* @param string|array $class One or more classes which have been added to the class list.

* @return array An array of class strings, poss with some indexes containing more than one space separated class

**/

public function body_class( array $classes, $class ) {

if ( is_tax() ) {

$taxonomy = get_queried_object();

$base_taxonomy = bbl_get_term_in_lang( get_queried_object(), $taxonomy->taxonomy, bbl_get_default_lang_code() );

if ( 'category' == $base_taxonomy->taxonomy ) {

$classes[] = 'category';

if ( isset( $base_taxonomy->term_id ) ) {

$classes[] = 'category-' . sanitize_html_class( $base_taxonomy->slug, $base_taxonomy->term_id );

$classes[] = 'category-' . $base_taxonomy->term_id;

}

} elseif ( 'post_tag' == $base_taxonomy->taxonomy ) {

$classes[] = 'tag';

if ( isset( $base_taxonomy->term_id ) ) {

$classes[] = 'tag-' . sanitize_html_class( $base_taxonomy->slug, $base_taxonomy->term_id );

$classes[] = 'tag-' . $base_taxonomy->term_id;

}

} else {

if ( isset( $base_taxonomy->term_id ) ) {

$classes[] = 'tax-' . sanitize_html_class( $base_taxonomy->taxonomy );

$classes[] = 'term-' . sanitize_html_class( $base_taxonomy->slug, $base_taxonomy->term_id );

$classes[] = 'term-' . $base_taxonomy->term_id;

}

}

}

return $classes;

}

/**

* Hooks the WP filter taxonomy_template to deal with the shadow terms,

* ensuring they use the right template.

*

* @param string $template Path to a template file

* @return Path to a template file

**/

public function taxonomy_template( $template ) {

if( bbl_is_default_lang() ) {

return $template;

}

$term = get_queried_object();

$base_taxonomy = $this->get_base_taxonomy( $term->taxonomy );

if ( 'category' == $base_taxonomy ) {

if ( ! empty( $term->slug ) ) {

$templates[] = "category-{$term->slug}.php";

$templates[] = "category-{$term->term_id}.php";

}

$templates[] = 'category.php';

}

else if ( 'post_tag' == $base_taxonomy ) {

if ( ! empty( $term->slug ) ) {

$templates[] = "tag-{$term->slug}.php";

$templates[] = "tag-{$term->term_id}.php";

}

$templates[] = 'tag.php';

}

else {

if ( ! empty( $term->slug ) ) {

$taxonomy = $term->taxonomy;

$templates[] = "taxonomy-$taxonomy-{$term->slug}.php";

$templates[] = "taxonomy-$taxonomy.php";

}

$templates[] = 'taxonomy.php';

}

$template = get_query_template( 'bbl-taxonomy', $templates );

return $template;

}

// CALLBACKS

// =========

// PUBLIC METHODS

// ==============

public function admin_body_class( $class ) {

$taxonomy = get_current_screen() ? get_current_screen()->taxonomy : null;

if ( $taxonomy ) {

$class .= ' bbl-taxonomy-' . $taxonomy;

}

return $class;

}

public function bbl_translated_taxonomy( $translated, $taxonomy ) {

if ( 'term_translation' == $taxonomy ) {

return false;

}

if ( 'nav_menu' == $taxonomy ) {

return false;

}

if ( 'link_category' == $taxonomy ) {

return false;

}

if ( 'post_format' == $taxonomy ) {

return false;

}

return $translated;

}

/**

* Provided with a taxonomy name, e.g. `post_tag`, and a language

* code, will return the shadow taxonomy in that language.

*

* @param string $taxonomy The origin taxonomy

* @param string $lang_code The target language code

* @return string The taxonomy name in that language

**/

public function translated_taxonomy( $origin_taxonomy, $lang_code ) {

return strtolower( "{$origin_taxonomy}_{$lang_code}" );

}

/**

* Get the terms which are the translations for the provided

* term ID. N.B. The returned array of term objects (and false

* values) will include the term for the term ID passed.

*

* @FIXME: We should cache the translation groups, as we do for posts

*

* @param int|object $term Either a WP Term object, or a term_id

* @return array Either an array keyed by the site languages, each key containing false (if no translation) or a WP Term object

**/

public function get_term_translations( $term, $taxonomy ) {

$term = get_term( $term, $taxonomy );

$langs = bbl_get_active_langs();

$translations = array();

foreach ( $langs as $lang ) {

$translations[ $lang->code ] = false;

}

$transid = $this->get_transid( $term->term_id );

// I thought the fracking bug where the get_objects_in_term function returned integers

// as strings was fixed. Seems not. See #17646 for details. Argh.

$term_ids = array_map( 'absint', get_objects_in_term( $transid, 'term_translation' ) );

// We're dealing with terms across multiple taxonomies

$base_taxonomy = isset( $this->taxonomies[ $taxonomy ] ) ? $this->taxonomies[ $taxonomy ] : $taxonomy ;

$taxonomies = array();

$taxonomies[] = $base_taxonomy;

foreach ( $this->lang_map as $lang_taxes ) {

if ( $lang_taxes[ $base_taxonomy ] ) {

$taxonomies[] = $lang_taxes[ $base_taxonomy ];

}

}

// Get all the translations in one cached DB query

$existing_terms = get_terms( $taxonomies, array( 'include' => $term_ids, 'hide_empty' => false ) );

// Finally, we're ready to return the terms in this

// translation group.

$terms = array();

foreach ( $existing_terms as $t ) {

$terms[ $this->get_taxonomy_lang_code( $t->taxonomy ) ] = $t;

}

return $terms;

}

/**

* Returns the term in a particular language, or the fallback content

* if there's no term available.

*

* @param int|object $term Either a WP Term object, or a term_id

* @param string $lang_code The language code for the required language

* @param boolean $fallback If true: if a term is not available, fallback to the default language content (defaults to true)

* @return object|boolean The WP Term object, or if $fallback was false and no post then returns false

**/

public function get_term_in_lang( $term, $taxonomy, $lang_code, $fallback = true ) {

$translations = $this->get_term_translations( $term, $taxonomy );

if ( isset( $translations[ $lang_code ] ) ) {

return $translations[ $lang_code ];

}

if ( ! $fallback ) {

return false;

}

return $translations[ bbl_get_default_lang_code() ];

}

/**

* Return the admin URL to create a new translation for a term in a

* particular language.

*

* @param int|object $default_term The term in the default language to create a new translation for, either WP Post object or post ID

* @param string $lang The language code

* @return string The admin URL to create the new translation

* @access public

**/

public function get_new_term_translation_url( $default_term, $lang_code, $taxonomy = null ) {

if ( ! is_int( $default_term ) && is_null( $taxonomy ) ) {

throw new exception( 'get_new_term_translation_url: Cannot get term from term_id without taxonomy' );

}

if ( ! is_null( $taxonomy ) ) {

$default_term = get_term( $default_term, $taxonomy );

}

if ( is_wp_error( $default_term ) ) {

throw new exception( 'get_new_term_translation_url: Error getting term from term_id and taxonomy: ' . print_r( $default_term, true ) );

}

$url = admin_url( 'post-new.php' );

$args = array(

'bbl_origin_term' => $default_term->term_id,

'bbl_origin_taxonomy' => $default_term->taxonomy,

'lang' => $lang_code,

'post_type' => 'bbl_job',

);

$url = add_query_arg( $args, $url );

return $url;

}

/**

* Returns the language code associated with a particular taxonomy.

*

* @param string $taxonomy The taxonomy to get the language for

* @return string The lang code

**/

public function get_taxonomy_lang_code( $taxonomy ) {

if ( ! isset( $this->taxonomies[ $taxonomy ] ) ) {

return bbl_get_default_lang_code();

}

foreach ( $this->lang_map as $lang => $data ) {

foreach ( $data as $trans_tax ) {

if ( $taxonomy == $trans_tax ) {

return $lang;

}

}

}

return false;

}

/**

* Return the base taxonomy (in the default language) for a

* provided taxonomy.

*

* @param string $taxonomy The name of a taxonomy

* @return string The name of the base taxonomy

**/

public function get_base_taxonomy( $taxonomy ) {

if ( ! isset( $this->taxonomies[ $taxonomy ] ) ) {

return $taxonomy;

}

return $this->taxonomies[ $taxonomy ];

}

/**

* Returns the equivalent taxonomy in the specified language.

*

* @param string $taxonomy A taxonomy to return in a given language

* @param string $lang_code The language code for the required language (optional, defaults to current)

* @return boolean|string The taxonomy name, or false if no taxonomy was specified

**/

public function get_taxonomy_in_lang( $taxonomy, $lang_code = null ) {

// Some taxonomies are untranslated…

if ( ! $this->is_taxonomy_translated( $taxonomy ) ) {

return $taxonomy;

}

if ( ! $taxonomy ) {

return false; // @FIXME: Should I actually be throwing an error here?

}

if ( is_null( $lang_code ) ) {

$lang_code = bbl_get_current_lang_code();

}

$base_taxonomy = $this->get_base_taxonomy( $taxonomy );

if ( bbl_get_default_lang_code() == $lang_code ) {

return $base_taxonomy;

}

return $this->lang_map[ $lang_code ][ $base_taxonomy ];

}

/**

* Returns a slug translated into a particular language.

*

* @TODO: This is more or less the same method as Babble_Post_Public::get_taxonomy_lang_code, do I need to DRY that up?

*

* @param string $slug The slug to translate

* @param string $lang_code The language code for the required language (optional, defaults to current)

* @return string A translated slug

**/

public function get_slug_in_lang( $slug, $lang_code = null ) {

if ( is_null( $lang_code ) ) {

$lang_code = bbl_get_current_lang_code();

}

$_slug = mb_strtolower( apply_filters( 'bbl_translate_taxonomy_slug', $slug, $lang_code ) );

// @FIXME: For some languages the translation might be the same as the original

if ( $_slug && $_slug != $slug ) {

return $_slug;

}

// Do we need to check that the slug is unique at this point?

return mb_strtolower( "{$_slug}_{$lang_code}" );

}

public function initialise_translation( $origin_term, $taxonomy, $lang_code ) {

$new_taxonomy = $this->get_slug_in_lang( $taxonomy, $lang_code );

$transid = $this->get_transid( $origin_term->term_id );

// Insert translation:

$this->no_recursion = true;

$new_term_id = wp_insert_term( $origin_term->name . ' - ' . $lang_code, $new_taxonomy );

$this->no_recursion = false;

$new_term = get_term( $new_term_id['term_id'], $new_taxonomy );

// Assign transid to translation:

$this->set_transid( $new_term_id['term_id'], $transid );

return $new_term;

}

// PRIVATE/PROTECTED METHODS

// =========================

/**

* Will update term count based on object types of the current

* taxonomy. Will only count the post(s) in the default language.

*

* Private function for the default callback for post_tag and category

* taxonomies.

*

* @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 );

// Babble specific code, to only count in primary language

$object_type = bbl_get_post_type_in_lang( $object_type, bbl_get_default_lang_code() );

}

$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 ) );

}

do_action( 'edit_term_taxonomy', $term, $taxonomy );

$wpdb->update( $wpdb->term_taxonomy, compact( 'count' ), array( 'term_taxonomy_id' => $term ) );

do_action( 'edited_term_taxonomy', $term, $taxonomy );

}

}

/**

* Return the translation group ID (a term ID) that the given term ID

* belongs to.

*

* @param int $target_term_id The term ID to find the translation group for

* @return int The transID the target term belongs to

**/

public function get_transid( $target_term_id ) {

if ( $transid = wp_cache_get( $target_term_id, 'bbl_term_transids' ) ) {

return $transid;

}

if ( ! $target_term_id ) {

throw new exception( "Please specify a target term_id" );

}

$transids = wp_get_object_terms( $target_term_id, 'term_translation', array( 'fields' => 'ids' ) );

// "There can be only one" (so we'll just drop the others)

if ( isset( $transids[ 0 ] ) ) {

$transid = $transids[ 0 ];

} else {

$transid = $this->set_transid( $target_term_id );

}

wp_cache_add( $target_term_id, $transid, 'bbl_term_transids' );

return $transid;

}

/**

* Set the translation group ID (a term ID) that the given term ID

* belongs to.

*

* @param int $target_term_id The term ID to set the translation group for

* @param int $translation_group_id The ID of the translation group to add this

* @return int The transID the target term belongs to

**/

public function set_transid( $target_term_id, $transid = null ) {

if ( ! $target_term_id ) {

throw new exception( "Please specify a target term_id" );

}

if ( ! $transid ) {

$transid_name = 'term_transid_' . uniqid();

$result = wp_insert_term( $transid_name, 'term_translation', array() );

if ( is_wp_error( $result ) ) {

error_log( "Problem creating a new Term TransID: " . print_r( $result, true ) );

} else {

$transid = $result[ 'term_id' ];

}

}

$result = wp_set_object_terms( $target_term_id, absint( $transid ), 'term_translation' );

if ( is_wp_error( $result ) ) {

error_log( "Problem associating TransID with new posts: " . print_r( $result, true ) );

}

wp_cache_delete( $target_term_id, 'bbl_term_transids' );

return $transid;

}

/**

* Checks for the relevant POSTed field, then

* resyncs the terms.

*

* @param int $post_id The ID of the WP post

* @param object $post The WP Post object

* @return void

**/

protected function maybe_resync_terms( $post_id, $post ) {

// Check that the fields were included on the screen, we

// can do this by checking for the presence of the nonce.

$nonce = isset( $_POST[ '_bbl_metabox_resync' ] ) ? $_POST[ '_bbl_metabox_resync' ] : false;

if ( ! in_array( $post->post_status, array( 'draft', 'publish' ) ) ) {

return;

}

if ( ! $nonce ) {

return;

}

$posted_id = isset( $_POST[ 'post_ID' ] ) ? $_POST[ 'post_ID' ] : 0;

if ( $posted_id != $post_id ) {

return;

}