<?php

/**

 * @file

 * Enables the organization of content into categories.

 */

/**

 * Users can create new terms in a free-tagging vocabulary when

 * submitting a taxonomy_autocomplete_widget. We store a term object

 * whose tid is 'autocreate' as a field data item during widget

 * validation and then actually create the term if/when that field

 * data item makes it to taxonomy_field_insert/update().

 */

/**

 * Implements hook_help().

 */

function taxonomy_help($path, $arg) {

  switch ($path) {

    case 'admin/help#taxonomy':

      $output = '';

      $output .= '<h3>' . t('About') . '</h3>';

      $output .= '<p>' . t('The Taxonomy module allows you to classify the content of your website. To classify content, you define <em>vocabularies</em> that contain related <em>terms</em>, and then assign the vocabularies to content types. For more information, see the online handbook entry for the <a href="@taxonomy">Taxonomy module</a>.', array('@taxonomy' => 'http://drupal.org/documentation/modules/taxonomy/')) . '</p>';

      $output .= '<h3>' . t('Uses') . '</h3>';

      $output .= '<dl>';

      $output .= '<dt>' . t('Creating vocabularies') . '</dt>';

      $output .= '<dd>' . t('Users with sufficient <a href="@perm">permissions</a> can create <em>vocabularies</em> and <em>terms</em> through the <a href="@taxo">Taxonomy page</a>. The page listing the terms provides a drag-and-drop interface for controlling the order of the terms and sub-terms within a vocabulary, in a hierarchical fashion. A <em>controlled vocabulary</em> classifying music by genre with terms and sub-terms could look as follows:', array('@taxo' => url('admin/structure/taxonomy'), '@perm' => url('admin/people/permissions', array('fragment' => 'module-taxonomy'))));

      $output .= '<ul><li>' . t('<em>vocabulary</em>: Music') . '</li>';

      $output .= '<ul><li>' . t('<em>term</em>: Jazz') . '</li>';

      $output .= '<ul><li>' . t('<em>sub-term</em>: Swing') . '</li>';

      $output .= '<li>' . t('<em>sub-term</em>: Fusion') . '</li></ul></ul>';

      $output .= '<ul><li>' . t('<em>term</em>: Rock') . '</li>';

      $output .= '<ul><li>' . t('<em>sub-term</em>: Country rock') . '</li>';

      $output .= '<li>' . t('<em>sub-term</em>: Hard rock') . '</li></ul></ul></ul>';

      $output .= t('You can assign a sub-term to multiple parent terms. For example, <em>fusion</em> can be assigned to both <em>rock</em> and <em>jazz</em>.') . '</dd>';

      $output .= '<dd>' . t('Terms in a <em>free-tagging vocabulary</em> can be built gradually as you create or edit content. This is often done used for blogs or photo management applications.') . '</dd>';

      $output .= '<dt>' . t('Assigning vocabularies to content types') . '</dt>';

      $output .= '<dd>' . t('Before you can use a new vocabulary to classify your content, a new Taxonomy term field must be added to a <a href="@ctedit">content type</a> on its <em>manage fields</em> page. When adding a taxonomy field, you choose a <em>widget</em> to use to enter the taxonomy information on the content editing page: a select list, checkboxes, radio buttons, or an auto-complete field (to build a free-tagging vocabulary). After choosing the field type and widget, on the subsequent <em>field settings</em> page you can choose the desired vocabulary, whether one or multiple terms can be chosen from the vocabulary, and other settings. The same vocabulary can be added to multiple content types, by using the "Add existing field" section on the manage fields page.', array('@ctedit' => url('admin/structure/types'))) . '</dd>';

      $output .= '<dt>' . t('Classifying content') . '</dt>';

      $output .= '<dd>' . t('After the vocabulary is assigned to the content type, you can start classifying content. The field with terms will appear on the content editing screen when you edit or <a href="@addnode">add new content</a>.', array('@addnode' => url('node/add'))) . '</dd>';

      $output .= '<dt>' . t('Viewing listings and RSS feeds by term') . '</dt>';

      $output .= '<dd>' . t("Each taxonomy term automatically provides a page listing content that has its classification, and a corresponding RSS feed. For example, if the taxonomy term <em>country rock</em> has the ID 123 (you can see this by looking at the URL when hovering on the linked term, which you can click to navigate to the listing page), then you will find this list at the path <em>taxonomy/term/123</em>. The RSS feed will use the path <em>taxonomy/term/123/feed</em> (the RSS icon for this term's listing will automatically display in your browser's address bar when viewing the listing page).") . '</dd>';

      $output .= '<dt>' . t('Extending Taxonomy module') . '</dt>';

      $output .= '<dd>' . t('There are <a href="@taxcontrib">many contributed modules</a> that extend the behavior of the Taxonomy module for both display and organization of terms.', array('@taxcontrib' => 'http://drupal.org/project/modules?filters=tid:71&solrsort=sis_project_release_usage%20desc'));

      $output .= '</dl>';

      return $output;

    case 'admin/structure/taxonomy':

      $output = '<p>' . t('Taxonomy is for categorizing content. Terms are grouped into vocabularies. For example, a vocabulary called "Fruit" would contain the terms "Apple" and "Banana".') . '</p>';

      return $output;

    case 'admin/structure/taxonomy/%':

      $vocabulary = taxonomy_vocabulary_machine_name_load($arg[3]);

      switch ($vocabulary->hierarchy) {

        case 0:

          return '<p>' . t('You can reorganize the terms in %capital_name using their drag-and-drop handles, and group terms under a parent term by sliding them under and to the right of the parent.', array('%capital_name' => drupal_ucfirst($vocabulary->name), '%name' => $vocabulary->name)) . '</p>';

        case 1:

          return '<p>' . t('%capital_name contains terms grouped under parent terms. You can reorganize the terms in %capital_name using their drag-and-drop handles.', array('%capital_name' => drupal_ucfirst($vocabulary->name), '%name' => $vocabulary->name)) . '</p>';

        case 2:

          return '<p>' . t('%capital_name contains terms with multiple parents. Drag and drop of terms with multiple parents is not supported, but you can re-enable drag-and-drop support by editing each term to include only a single parent.', array('%capital_name' => drupal_ucfirst($vocabulary->name))) . '</p>';

      }

  }

}

/**

 * Implements hook_permission().

 */

function taxonomy_permission() {

  $permissions = array(

    'administer taxonomy' => array(

      'title' => t('Administer vocabularies and terms'),

    ),

  );

  foreach (taxonomy_get_vocabularies() as $vocabulary) {

    $permissions += array(

      'edit terms in ' . $vocabulary->vid => array(

        'title' => t('Edit terms in %vocabulary', array('%vocabulary' => $vocabulary->name)),

      ),

    );

    $permissions += array(

       'delete terms in ' . $vocabulary->vid => array(

         'title' => t('Delete terms from %vocabulary', array('%vocabulary' => $vocabulary->name)),

      ),

    );

  }

  return $permissions;

}

/**

 * Implements hook_entity_info().

 */

function taxonomy_entity_info() {

  $return = array(

    'taxonomy_term' => array(

      'label' => t('Taxonomy term'),

      'controller class' => 'TaxonomyTermController',

      'base table' => 'taxonomy_term_data',

      'uri callback' => 'taxonomy_term_uri',

      'fieldable' => TRUE,

      'entity keys' => array(

        'id' => 'tid',

        'bundle' => 'vocabulary_machine_name',

        'label' => 'name',

      ),

      'bundle keys' => array(

        'bundle' => 'machine_name',

      ),

      'bundles' => array(),

      'view modes' => array(

        // @todo View mode for display as a field (when attached to nodes etc).

        'full' => array(

          'label' => t('Taxonomy term page'),

          'custom settings' => FALSE,

        ),

      ),

    ),

  );

  foreach (taxonomy_vocabulary_get_names() as $machine_name => $vocabulary) {

    $return['taxonomy_term']['bundles'][$machine_name] = array(

      'label' => $vocabulary->name,

      'admin' => array(

        'path' => 'admin/structure/taxonomy/%taxonomy_vocabulary_machine_name',

        'real path' => 'admin/structure/taxonomy/' . $machine_name,

        'bundle argument' => 3,

        'access arguments' => array('administer taxonomy'),

      ),

    );

  }

  $return['taxonomy_vocabulary'] = array(

    'label' => t('Taxonomy vocabulary'),

    'controller class' => 'TaxonomyVocabularyController',

    'base table' => 'taxonomy_vocabulary',

    'entity keys' => array(

      'id' => 'vid',

      'label' => 'name',

    ),

    'fieldable' => FALSE,

  );

  return $return;

}

/**

 * Implements callback_entity_info_uri().

 */

function taxonomy_term_uri($term) {

  return array(

    'path' => 'taxonomy/term/' . $term->tid,

  );

}

/**

 * Implements hook_field_extra_fields().

 */

function taxonomy_field_extra_fields() {

  $return = array();

  $info = entity_get_info('taxonomy_term');

  foreach (array_keys($info['bundles']) as $bundle) {

    $return['taxonomy_term'][$bundle] = array(

      'form' => array(

        'name' => array(

          'label' => t('Name'),

          'description' => t('Term name textfield'),

          'weight' => -5,

        ),

        'description' => array(

          'label' => t('Description'),

          'description' => t('Term description textarea'),

          'weight' => 0,

        ),

      ),

      'display' => array(

        'description' => array(

          'label' => t('Description'),

          'description' => t('Term description'),

          'weight' => 0,

        ),

      ),

    );

  }

  return $return;

}

/**

 * Return nodes attached to a term across all field instances.

 *

 * This function requires taxonomy module to be maintaining its own tables,

 * and will return an empty array if it is not. If using other field storage

 * methods alternatives methods for listing terms will need to be used.

 *

 * @param $tid

 *   The term ID.

 * @param $pager

 *   Boolean to indicate whether a pager should be used.

 * @param $limit

 *   Integer. The maximum number of nodes to find.

 *   Set to FALSE for no limit.

 * @param $order

 *   An array of fields and directions.

 *

 * @return

 *   An array of nids matching the query.

 */

function taxonomy_select_nodes($tid, $pager = TRUE, $limit = FALSE, $order = array('t.sticky' => 'DESC', 't.created' => 'DESC')) {

  if (!variable_get('taxonomy_maintain_index_table', TRUE)) {

    return array();

  }

  $query = db_select('taxonomy_index', 't');

  $query->addTag('node_access');

  $query->condition('tid', $tid);

  if ($pager) {

    $count_query = clone $query;

    $count_query->addExpression('COUNT(t.nid)');

    $query = $query->extend('PagerDefault');

    if ($limit !== FALSE) {

      $query = $query->limit($limit);

    }

    $query->setCountQuery($count_query);

  }

  else {

    if ($limit !== FALSE) {

      $query->range(0, $limit);

    }

  }

  $query->addField('t', 'nid');

  $query->addField('t', 'tid');

  foreach ($order as $field => $direction) {

    $query->orderBy($field, $direction);

    // ORDER BY fields need to be loaded too, assume they are in the form

    // table_alias.name

    list($table_alias, $name) = explode('.', $field);

    $query->addField($table_alias, $name);

  }

  return $query->execute()->fetchCol();

}

/**

 * Implements hook_theme().

 */

function taxonomy_theme() {

  return array(

    'taxonomy_overview_vocabularies' => array(

      'render element' => 'form',

    ),

    'taxonomy_overview_terms' => array(

      'render element' => 'form',

    ),

    'taxonomy_term' => array(

      'render element' => 'elements',

      'template' => 'taxonomy-term',

    ),

  );

}

/**

 * Implements hook_menu().

 */

function taxonomy_menu() {

  $items['admin/structure/taxonomy'] = array(

    'title' => 'Taxonomy',

    'description' => 'Manage tagging, categorization, and classification of your content.',

    'page callback' => 'drupal_get_form',

    'page arguments' => array('taxonomy_overview_vocabularies'),

    'access arguments' => array('administer taxonomy'),

    'file' => 'taxonomy.admin.inc',

  );

  $items['admin/structure/taxonomy/list'] = array(

    'title' => 'List',

    'type' => MENU_DEFAULT_LOCAL_TASK,

    'weight' => -10,

  );

  $items['admin/structure/taxonomy/add'] = array(

    'title' => 'Add vocabulary',

    'page callback' => 'drupal_get_form',

    'page arguments' => array('taxonomy_form_vocabulary'),

    'access arguments' => array('administer taxonomy'),

    'type' => MENU_LOCAL_ACTION,

    'file' => 'taxonomy.admin.inc',

  );

  $items['taxonomy/term/%taxonomy_term'] = array(

    'title' => 'Taxonomy term',

    'title callback' => 'taxonomy_term_title',

    'title arguments' => array(2),

    'page callback' => 'taxonomy_term_page',

    'page arguments' => array(2),

    'access arguments' => array('access content'),

    'file' => 'taxonomy.pages.inc',

  );

  $items['taxonomy/term/%taxonomy_term/view'] = array(

    'title' => 'View',

    'type' => MENU_DEFAULT_LOCAL_TASK,

  );

  $items['taxonomy/term/%taxonomy_term/edit'] = array(

    'title' => 'Edit',

    'page callback' => 'drupal_get_form',

    // Pass a NULL argument to ensure that additional path components are not

    // passed to taxonomy_form_term() as the vocabulary machine name argument.

    'page arguments' => array('taxonomy_form_term', 2, NULL),

    'access callback' => 'taxonomy_term_edit_access',

    'access arguments' => array(2),

    'type' => MENU_LOCAL_TASK,

    'weight' => 10,

    'file' => 'taxonomy.admin.inc',

  );

  $items['taxonomy/term/%taxonomy_term/feed'] = array(

    'title' => 'Taxonomy term',

    'title callback' => 'taxonomy_term_title',

    'title arguments' => array(2),

    'page callback' => 'taxonomy_term_feed',

    'page arguments' => array(2),

    'access arguments' => array('access content'),

    'type' => MENU_CALLBACK,

    'file' => 'taxonomy.pages.inc',

  );

  $items['taxonomy/autocomplete'] = array(

    'title' => 'Autocomplete taxonomy',

    'page callback' => 'taxonomy_autocomplete',

    'access arguments' => array('access content'),

    'type' => MENU_CALLBACK,

    'file' => 'taxonomy.pages.inc',

  );

  $items['admin/structure/taxonomy/%taxonomy_vocabulary_machine_name'] = array(

    'title callback' => 'entity_label',

    'title arguments' => array('taxonomy_vocabulary', 3),

    'page callback' => 'drupal_get_form',

    'page arguments' => array('taxonomy_overview_terms', 3),

    'access arguments' => array('administer taxonomy'),

    'file' => 'taxonomy.admin.inc',

  );

  $items['admin/structure/taxonomy/%taxonomy_vocabulary_machine_name/list'] = array(

    'title' => 'List',

    'type' => MENU_DEFAULT_LOCAL_TASK,

    'weight' => -20,

  );

  $items['admin/structure/taxonomy/%taxonomy_vocabulary_machine_name/edit'] = array(

    'title' => 'Edit',

    'page callback' => 'drupal_get_form',

    'page arguments' => array('taxonomy_form_vocabulary', 3),

    'access arguments' => array('administer taxonomy'),

    'type' => MENU_LOCAL_TASK,

    'weight' => -10,

    'file' => 'taxonomy.admin.inc',

  );

  $items['admin/structure/taxonomy/%taxonomy_vocabulary_machine_name/add'] = array(

    'title' => 'Add term',

    'page callback' => 'drupal_get_form',

    'page arguments' => array('taxonomy_form_term', array(), 3),

    'access arguments' => array('administer taxonomy'),

    'type' => MENU_LOCAL_ACTION,

    'file' => 'taxonomy.admin.inc',

  );

  return $items;

}

/**

 * Implements hook_admin_paths().

 */

function taxonomy_admin_paths() {

  $paths = array(

    'taxonomy/term/*/edit' => TRUE,

  );

  return $paths;

}

/**

 * Return edit access for a given term.

 */

function taxonomy_term_edit_access($term) {

  return user_access("edit terms in $term->vid") || user_access('administer taxonomy');

}

/**

 * Returns the sanitized name of a vocabulary.

 *

 * Deprecated. This function was previously used as a menu item title callback

 * but has been replaced by using entity_label() (which does not

 * sanitize the title, since the menu system does that automatically). In

 * Drupal 7, use that function for title callbacks, and call check_plain()

 * directly if you need a sanitized title.

 */

function taxonomy_admin_vocabulary_title_callback($vocabulary) {

  return check_plain($vocabulary->name);

}

/**

 * Saves a vocabulary.

 *

 * @param $vocabulary

 *   A vocabulary object with the following properties:

 *   - vid: (optional) The ID of the vocabulary (omit if creating a new

 *     vocabulary; only use to update an existing vocabulary).

 *   - name: The human-readable name of the vocabulary.

 *   - machine_name: The machine name of the vocabulary.

 *   - description: (optional) The vocabulary's description.

 *   - hierarchy: The hierarchy level of the vocabulary.

 *   - module: (optional) The module altering the vocabulary.

 *   - weight: (optional) The weight of this vocabulary in relation to other

 *     vocabularies.

 *   - original: (optional) The original vocabulary object before any changes

 *     are applied.

 *   - old_machine_name: (optional) The original machine name of the

 *     vocabulary.

 *

 * @return

 *   Status constant indicating whether the vocabulary was inserted (SAVED_NEW)

 *   or updated (SAVED_UPDATED).

 */

function taxonomy_vocabulary_save($vocabulary) {

  // Prevent leading and trailing spaces in vocabulary names.

  if (!empty($vocabulary->name)) {

    $vocabulary->name = trim($vocabulary->name);

  }

  // Load the stored entity, if any.

  if (!empty($vocabulary->vid)) {

    if (!isset($vocabulary->original)) {

      $vocabulary->original = entity_load_unchanged('taxonomy_vocabulary', $vocabulary->vid);

    }

    // Make sure machine name changes are easily detected.

    // @todo: Remove in Drupal 8, as it is deprecated by directly reading from

    // $vocabulary->original.

    $vocabulary->old_machine_name = $vocabulary->original->machine_name;

  }

  if (!isset($vocabulary->module)) {

    $vocabulary->module = 'taxonomy';

  }

  module_invoke_all('taxonomy_vocabulary_presave', $vocabulary);

  module_invoke_all('entity_presave', $vocabulary, 'taxonomy_vocabulary');

  if (!empty($vocabulary->vid) && !empty($vocabulary->name)) {

    $status = drupal_write_record('taxonomy_vocabulary', $vocabulary, 'vid');

    taxonomy_vocabulary_static_reset(array($vocabulary->vid));

    if ($vocabulary->old_machine_name != $vocabulary->machine_name) {

      field_attach_rename_bundle('taxonomy_term', $vocabulary->old_machine_name, $vocabulary->machine_name);

    }

    module_invoke_all('taxonomy_vocabulary_update', $vocabulary);

    module_invoke_all('entity_update', $vocabulary, 'taxonomy_vocabulary');

  }

  elseif (empty($vocabulary->vid)) {

    $status = drupal_write_record('taxonomy_vocabulary', $vocabulary);

    taxonomy_vocabulary_static_reset();

    field_attach_create_bundle('taxonomy_term', $vocabulary->machine_name);

    module_invoke_all('taxonomy_vocabulary_insert', $vocabulary);

    module_invoke_all('entity_insert', $vocabulary, 'taxonomy_vocabulary');

  }

  unset($vocabulary->original);

  cache_clear_all();

  return $status;

}

/**

 * Deletes a vocabulary.

 *

 * This will update all Taxonomy fields so that they don't reference the

 * deleted vocabulary. It also will delete fields that have no remaining

 * vocabulary references. All taxonomy terms of the deleted vocabulary

 * will be deleted as well.

 *

 * @param $vid

 *   A vocabulary ID.

 * @return

 *   Constant indicating items were deleted.

 */

function taxonomy_vocabulary_delete($vid) {

  $vocabulary = taxonomy_vocabulary_load($vid);

  $transaction = db_transaction();

  try {

    // Only load terms without a parent, child terms will get deleted too.

    $result = db_query('SELECT t.tid FROM {taxonomy_term_data} t INNER JOIN {taxonomy_term_hierarchy} th ON th.tid = t.tid WHERE t.vid = :vid AND th.parent = 0', array(':vid' => $vid))->fetchCol();

    foreach ($result as $tid) {

      taxonomy_term_delete($tid);

    }

    db_delete('taxonomy_vocabulary')

      ->condition('vid', $vid)

      ->execute();

    field_attach_delete_bundle('taxonomy_term', $vocabulary->machine_name);

    module_invoke_all('taxonomy_vocabulary_delete', $vocabulary);

    module_invoke_all('entity_delete', $vocabulary, 'taxonomy_vocabulary');

    // Load all Taxonomy module fields and delete those which use only this

    // vocabulary.

    $taxonomy_fields = field_read_fields(array('module' => 'taxonomy'));

    foreach ($taxonomy_fields as $field_name => $taxonomy_field) {

      $modified_field = FALSE;

      // Term reference fields may reference terms from more than one

      // vocabulary.

      foreach ($taxonomy_field['settings']['allowed_values'] as $key => $allowed_value) {

        if ($allowed_value['vocabulary'] == $vocabulary->machine_name) {

          unset($taxonomy_field['settings']['allowed_values'][$key]);

          $modified_field = TRUE;

        }

      }

      if ($modified_field) {

        if (empty($taxonomy_field['settings']['allowed_values'])) {

          field_delete_field($field_name);

        }

        else {

          // Update the field definition with the new allowed values.

          field_update_field($taxonomy_field);

        }

      }

    }

    cache_clear_all();

    taxonomy_vocabulary_static_reset();

    return SAVED_DELETED;

  }

  catch (Exception $e) {

    $transaction->rollback();

    watchdog_exception('taxonomy', $e);

    throw $e;

  }

}

/**

 * Implements hook_taxonomy_vocabulary_update().

 */

function taxonomy_taxonomy_vocabulary_update($vocabulary) {