entity_share_taxonomy.module in Entity Share 7

Entity Share Taxonomy .module file.

File

modules/entity_share_taxonomy/entity_share_taxonomy.module

<?php

/**
 * @file
 * Entity Share Taxonomy .module file.
 */

/**
 * Implements hook_es_export_field_data_alter().
 */
function entity_share_taxonomy_es_export_field_data_alter(&$field_data, $context) {
  $field_name = $context['field_name'];
  $field_type = $context['field_type'];
  $entity = $context['entity'];
  $field_info = $context['field_info'];
  $lang = $context['lang'];
  $delta = $context['delta'];
  $entity_share_entity = $context['entity_share_entity'];

  // Alter the field_data.
  $est = new EntityShareTaxonomyExport($field_data, $field_name, $field_type, $entity, $field_info, $lang, $delta, $entity_share_entity);
  $est
    ->exportDatas();
}

/**
 * Implements hook_es_import_field_data_before_alter().
 */
function entity_share_taxonomy_es_import_field_data_alter(&$field_data, $context) {
  $field_name = $context['field_name'];
  $field_type = $context['field_type'];
  $entity = $context['entity'];
  $field_info = $context['field_info'];
  $lang = $context['lang'];
  $delta = $context['delta'];
  $entity_share_entity = $context['entity_share_entity'];

  // Import the taxonomy and alter the field_data.
  $est = new EntityShareTaxonomyImport($field_data, $field_name, $field_type, $entity, $field_info, $lang, $delta, $entity_share_entity);
  $est
    ->importDatas();
}

/**
 * Implements hook_es_import_local_entities_alter().
 */
function entity_share_taxonomy_es_import_local_entities_alter(&$entity, $context) {
  if ($entity->entity_type == 'taxonomy_term') {
    EntityShareTaxonomyImport::setLocalVocabularyId($entity);
  }
}

/**
 * Rewrite taxonomy_get_tree() function to not be language dependent.
 *
 * Create a hierarchical representation of a vocabulary.
 *
 * @param int $vid
 *   Which vocabulary to generate the tree for.
 * @param int $parent
 *   The term ID under which to generate the tree. If 0, generate the tree
 *   for the entire vocabulary.
 * @param int $max_depth
 *   The number of levels of the tree to return.
 *   Leave NULL to return all levels.
 * @param bool $load_entities
 *   If TRUE, a full entity load will occur on the term objects. Otherwise they
 *   are partial objects queried directly from the {taxonomy_term_data} table to
 *   save execution time and memory consumption when listing large numbers of
 *   terms. Defaults to FALSE.
 *
 * @return array
 *   An array of all term objects in the tree. Each term object is extended
 *   to have "depth" and "parents" attributes in addition to its normal ones.
 *   Results are statically cached. Term objects will be partial or complete
 *   depending on the $load_entities parameter.
 */
function entity_share_taxonomy_get_tree_all_language($vid, $parent = 0, $max_depth = NULL, $load_entities = FALSE) {
  $children =& drupal_static(__FUNCTION__, array());
  $parents =& drupal_static(__FUNCTION__ . ':parents', array());
  $terms =& drupal_static(__FUNCTION__ . ':terms', array());

  // We cache trees, so it's not CPU-intensive to call taxonomy_get_tree() on a
  // term and its children, too.
  if (!isset($children[$vid])) {
    $children[$vid] = array();
    $parents[$vid] = array();
    $terms[$vid] = array();
    $query = db_select('taxonomy_term_data', 't');
    $query
      ->join('taxonomy_term_hierarchy', 'h', 'h.tid = t.tid');
    $result = $query
      ->addTag('translatable')
      ->fields('t')
      ->fields('h', array(
      'parent',
    ))
      ->condition('t.vid', $vid)
      ->orderBy('t.weight')
      ->orderBy('t.name')
      ->execute();
    foreach ($result as $term) {
      $children[$vid][$term->parent][] = $term->tid;
      $parents[$vid][$term->tid][] = $term->parent;
      $terms[$vid][$term->tid] = $term;
    }
  }

  // Load full entities, if necessary. The entity controller statically
  // caches the results.
  if ($load_entities) {
    $term_entities = taxonomy_term_load_multiple(array_keys($terms[$vid]));
  }
  $max_depth = !isset($max_depth) ? count($children[$vid]) : $max_depth;
  $tree = array();

  // Keeps track of the parents we have to process, the last entry is used
  // for the next processing step.
  $process_parents = array();
  $process_parents[] = $parent;

  // Loops over the parent terms and adds its children to the tree array.
  // Uses a loop instead of a recursion, because it's more efficient.
  while (count($process_parents)) {
    $parent = array_pop($process_parents);

    // The number of parents determines the current depth.
    $depth = count($process_parents);
    if ($max_depth > $depth && !empty($children[$vid][$parent])) {
      $has_children = FALSE;
      $child = current($children[$vid][$parent]);
      do {
        if (empty($child)) {
          break;
        }
        $term = $load_entities ? $term_entities[$child] : $terms[$vid][$child];
        if (isset($parents[$vid][$term->tid])) {

          // Clone the term so that the depth attribute remains correct
          // in the event of multiple parents.
          $term = clone $term;
        }
        $term->depth = $depth;
        unset($term->parent);
        $term->parents = $parents[$vid][$term->tid];
        $tree[] = $term;
        if (!empty($children[$vid][$term->tid])) {
          $has_children = TRUE;

          // We have to continue with this parent later.
          $process_parents[] = $parent;

          // Use the current term as parent for the next iteration.
          $process_parents[] = $term->tid;

          // Reset pointers for child lists because we step in there more often
          // with multi parents.
          reset($children[$vid][$term->tid]);

          // Move pointer so that we get the correct term the next time.
          next($children[$vid][$parent]);
          break;
        }
      } while ($child = next($children[$vid][$parent]));
      if (!$has_children) {

        // We processed all terms in this hierarchy-level, reset pointer
        // so that this function works the next time it gets called.
        reset($children[$vid][$parent]);
      }
    }
  }
  return $tree;
}

Functions

Name	Description
entity_share_taxonomy_es_export_field_data_alter	Implements hook_es_export_field_data_alter().
entity_share_taxonomy_es_import_field_data_alter	Implements hook_es_import_field_data_before_alter().
entity_share_taxonomy_es_import_local_entities_alter	Implements hook_es_import_local_entities_alter().
entity_share_taxonomy_get_tree_all_language	Rewrite taxonomy_get_tree() function to not be language dependent.