class TaxonomyTermController

taxonomy_autoload_info in core/modules/taxonomy/taxonomy.module

Implements hook_autoload_info().

taxonomy_entity_info in core/modules/taxonomy/taxonomy.module

Implements hook_entity_info().

class TaxonomyTermController extends EntityDatabaseStorageController {

  /**
   * Overrides EntityDatabaseStorageController::create().
   *
   * @param array $values
   *   An array of values to set, keyed by property name. A value for the
   *   vocabulary ID ('vid') is required.
   */
  public function create(array $values) {
    $entity = parent::create($values);

    // Save new terms with no parents by default.
    if (!isset($entity->parent)) {
      $entity->parent = array(0);
    }
    return $entity;
  }

  /**
   * Overrides EntityDatabaseStorageController::buildQuery().
   */
  protected function buildQuery($ids, $conditions = array(), $revision_id = FALSE) {
    $query = parent::buildQuery($ids, $conditions, $revision_id);
    $query->addTag('translatable');
    $query->addTag('taxonomy_term_access');
    // When name is passed as a condition use LIKE.
    if (isset($conditions['name'])) {
      $query_conditions = &$query->conditions();
      foreach ($query_conditions as $key => $condition) {
        if (is_array($condition) && $condition['field'] == 'base.name') {
          $query_conditions[$key]['operator'] = 'LIKE';
          $query_conditions[$key]['value'] = db_like($query_conditions[$key]['value']);
        }
      }
    }
    return $query;
  }

  /**
   * Overrides EntityDatabaseStorageController::cacheGet().
   */
  protected function cacheGet($ids, $conditions = array()) {
    $terms = parent::cacheGet($ids, $conditions);
    // Name matching is case insensitive, note that with some collations
    // LOWER() and backdrop_strtolower() may return different results.
    foreach ($terms as $term) {
      if (isset($conditions['name']) && backdrop_strtolower($conditions['name'] != backdrop_strtolower($term->name))) {
        unset($terms[$term->tid]);
      }
    }
    return $terms;
  }

  /**
   * Overrides EntityDatabaseStorageController::postDelete().
   *
   * @param TaxonomyTerm[] $entities
   *   An array of term entities that were just deleted.
   */
  protected function postDelete($entities) {
    // See if any of the term's children are about to be become orphans.
    $orphans = array();
    foreach (array_keys($entities) as $tid) {
      if ($children = taxonomy_term_load_children($tid)) {
        foreach ($children as $child) {
          // If the term has multiple parents, we don't delete it.
          $parents = taxonomy_term_load_parents($child->tid);
          // Because the parent has already been deleted, the parent count might
          // be 0.
          if (count($parents) <= 1) {
            $orphans[] = $child->tid;
          }
        }
      }
    }

    // Delete term hierarchy information after looking up orphans but before
    // deleting them so that their children/parent information is consistent.
    db_delete('taxonomy_term_hierarchy')
      ->condition('tid', array_keys($entities))
      ->execute();

    if (!empty($orphans)) {
      taxonomy_term_delete_multiple($orphans);
    }
  }

  /**
   * Overrides EntityDatabaseStorageController::postSave().
   *
   * @param TaxonomyTerm $entity
   *   The term entity that was just saved.
   */
  protected function postSave(EntityInterface $entity, $update) {
    if (isset($entity->parent)) {
      db_delete('taxonomy_term_hierarchy')
        ->condition('tid', $entity->tid)
        ->execute();

      $query = db_insert('taxonomy_term_hierarchy')
        ->fields(array('tid', 'parent'));

      foreach ($entity->parent as $parent) {
        $query->values(array(
          'tid' => $entity->tid,
          'parent' => $parent
        ));
      }
      $query->execute();
    }
  }

  /**
   * Implements EntityControllerInterface::resetCache().
   */
  public function resetCache(array $ids = NULL) {
    backdrop_static_reset('taxonomy_term_count_nodes');
    backdrop_static_reset('taxonomy_get_tree');
    backdrop_static_reset('taxonomy_get_tree:parents');
    backdrop_static_reset('taxonomy_get_tree:terms');
    backdrop_static_reset('taxonomy_term_load_parents');
    backdrop_static_reset('taxonomy_term_load_parents_all');
    backdrop_static_reset('taxonomy_term_load_children');
    parent::resetCache($ids);
  }

  /**
   * Implements EntityControllerInterface::buildContent().
   */
  public function buildContent(EntityInterface $term, $view_mode = 'full', $langcode = NULL) {
    global $language_content;
    $langcode = $langcode ? $langcode : $language_content->langcode;

    // Remove previously built content, if exists.
    $term->content = array();

    // Allow modules to change the display mode.
    $view_mode = key(entity_view_mode_prepare('taxonomy_term', array($term->tid => $term), $view_mode, $langcode));

    // Add the term description if the term has one and it is visible.
    $type = 'taxonomy_term';
    $entity_ids = entity_extract_ids($type, $term);
    $settings = field_view_mode_settings($type, $entity_ids[2]);
    $fields = field_extra_fields_get_display($type, $entity_ids[2], $view_mode);
    if (!empty($term->description) && isset($fields['description']) && $fields['description']['visible']) {
      $term->content['description'] = array(
        '#markup' => check_markup($term->description, $term->format, '', TRUE),
        '#weight' => $fields['description']['weight'],
        '#prefix' => '<div class="taxonomy-term-description">',
        '#suffix' => '</div>',
      );
    }

    // Build fields content.
    // In case of a multiple view, taxonomy_term_view_multiple() already ran the
    // 'prepare_view' step. An internal flag prevents the operation from running
    // twice.
    field_attach_prepare_view('taxonomy_term', array($term->tid => $term), $view_mode, $langcode);
    entity_prepare_view('taxonomy_term', array($term->tid => $term), $langcode);
    $term->content += field_attach_view('taxonomy_term', $term, $view_mode, $langcode);

    // Allow modules to make their own additions to the taxonomy term.
    module_invoke_all('taxonomy_term_view', $term, $view_mode, $langcode);
    module_invoke_all('entity_view', $term, 'taxonomy_term', $view_mode, $langcode);

    // Make sure the current display mode is stored if no module has already
    // populated the related key.
    $term->content += array('#view_mode' => $view_mode);
  }

  /**
   * Overrides DefaultEntityController::view().
   */
  public function view($terms, $view_mode = 'full', $langcode = NULL, $page = NULL) {
    global $language_content;
    $langcode = $langcode ? $langcode : $language_content->langcode;

    $view = array();
    foreach ($terms as $term) {
      /* @var TaxonomyTerm $term */
      // Populate $term->content with a render() array.
      $this->buildContent($term, $view_mode, $langcode);
      $build = $term->content;

      // We don't need duplicate rendering info in $term->content.
      unset($term->content);

      $build += array(
        '#theme' => 'taxonomy_term',
        '#term' => $term,
        '#view_mode' => $view_mode,
        '#language' => $langcode,
        '#page' => $page,
      );

      $build['#attached']['css'][] = backdrop_get_path('module', 'taxonomy') . '/css/taxonomy.css';

      // Allow modules to modify the structured taxonomy term.
      $type = 'taxonomy_term';
      backdrop_alter(array('taxonomy_term_view', 'entity_view'), $build, $type);
      $view[$type][$term->id()] = $build;
    }

    return $view;
  }
}