<?php

// $Id: taxonomy.module,v 1.414.2.11 2009/05/13 19:38:33 goba Exp $

/**

 * @file

 * Enables the organization of content into categories.

 */

/**

 * Implementation of hook_perm().

 */

function taxonomy_perm() {

  return array('administer taxonomy');

}

/**

 * Implementation of hook_theme()

 */

function taxonomy_theme() {

  return array(

    'taxonomy_term_select' => array(

      'arguments' => array('element' => NULL),

    ),

    'taxonomy_term_page' => array(

      'arguments' => array('tids' => array(), 'result' => NULL),

    ),

    'taxonomy_overview_vocabularies' => array(

      'arguments' => array('form' => array()),

    ),

    'taxonomy_overview_terms' => array(

      'arguments' => array('form' => array()),

    ),

  );

}

/**

 * Implementation of hook_link().

 *

 * This hook is extended with $type = 'taxonomy terms' to allow themes to

 * print lists of terms associated with a node. Themes can print taxonomy

 * links with:

 *

 * if (module_exists('taxonomy')) {

 *   $terms = taxonomy_link('taxonomy terms', $node);

 *   print theme('links', $terms);

 * }

 */

function taxonomy_link($type, $node = NULL) {

  if ($type == 'taxonomy terms' && $node != NULL) {

    $links = array();

    // If previewing, the terms must be converted to objects first.

    if (isset($node->build_mode) && $node->build_mode == NODE_BUILD_PREVIEW) {

      $node->taxonomy = taxonomy_preview_terms($node);

    }

    if (!empty($node->taxonomy)) {

      foreach ($node->taxonomy as $term) {

        // During preview the free tagging terms are in an array unlike the

        // other terms which are objects. So we have to check if a $term

        // is an object or not.

        if (is_object($term)) {

          $links['taxonomy_term_'. $term->tid] = array(

            'title' => $term->name,

            'href' => taxonomy_term_path($term),

            'attributes' => array('rel' => 'tag', 'title' => strip_tags($term->description))

          );

        }

        // Previewing free tagging terms; we don't link them because the

        // term-page might not exist yet.

        else {

          foreach ($term as $free_typed) {

            $typed_terms = drupal_explode_tags($free_typed);

            foreach ($typed_terms as $typed_term) {

              $links['taxonomy_preview_term_'. $typed_term] = array(

                'title' => $typed_term,

              );

            }

          }

        }

      }

    }

    // We call this hook again because some modules and themes

    // call taxonomy_link('taxonomy terms') directly.

    drupal_alter('link', $links, $node);

    return $links;

  }

}

/**

 * For vocabularies not maintained by taxonomy.module, give the maintaining

 * module a chance to provide a path for terms in that vocabulary.

 *

 * @param $term

 *   A term object.

 * @return

 *   An internal Drupal path.

 */

function taxonomy_term_path($term) {

  $vocabulary = taxonomy_vocabulary_load($term->vid);

  if ($vocabulary->module != 'taxonomy' && $path = module_invoke($vocabulary->module, 'term_path', $term)) {

    return $path;

  }

  return 'taxonomy/term/'. $term->tid;

}

/**

 * Implementation of hook_menu().

 */

function taxonomy_menu() {

  $items['admin/content/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/content/taxonomy/list'] = array(

    'title' => 'List',

    'type' => MENU_DEFAULT_LOCAL_TASK,

    'weight' => -10,

  );

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

    'title' => 'Add vocabulary',

    'page callback' => 'drupal_get_form',

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

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

    'type' => MENU_LOCAL_TASK,

    'parent' => 'admin/content/taxonomy',

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

  );

  $items['admin/content/taxonomy/edit/vocabulary/%taxonomy_vocabulary'] = array(

    'title' => 'Edit vocabulary',

    'page callback' => 'taxonomy_admin_vocabulary_edit',

    'page arguments' => array(5),

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

    'type' => MENU_CALLBACK,

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

  );

  $items['admin/content/taxonomy/edit/term'] = array(

    'title' => 'Edit term',

    'page callback' => 'taxonomy_admin_term_edit',

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

    'type' => MENU_CALLBACK,

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

  );

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

    'title' => 'Taxonomy term',

    'page callback' => 'taxonomy_term_page',

    '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/content/taxonomy/%taxonomy_vocabulary'] = array(

    'title' => 'List terms',

    'page callback' => 'drupal_get_form',

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

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

    'type' => MENU_CALLBACK,

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

  );

  $items['admin/content/taxonomy/%taxonomy_vocabulary/list'] = array(

    'title' => 'List',

    'type' => MENU_DEFAULT_LOCAL_TASK,

    'weight' => -10,

  );

  $items['admin/content/taxonomy/%taxonomy_vocabulary/add/term'] = array(

    'title' => 'Add term',

    'page callback' => 'taxonomy_add_term_page',

    'page arguments' => array(3),

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

    'type' => MENU_LOCAL_TASK,

    'parent' => 'admin/content/taxonomy/%taxonomy_vocabulary',

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

  );

  return $items;

}

function taxonomy_save_vocabulary(&$edit) {

  $edit['nodes'] = empty($edit['nodes']) ? array() : $edit['nodes'];

  if (!isset($edit['module'])) {

    $edit['module'] = 'taxonomy';

  }

  if (!empty($edit['vid']) && !empty($edit['name'])) {

    drupal_write_record('vocabulary', $edit, 'vid');

    db_query("DELETE FROM {vocabulary_node_types} WHERE vid = %d", $edit['vid']);

    foreach ($edit['nodes'] as $type => $selected) {

      db_query("INSERT INTO {vocabulary_node_types} (vid, type) VALUES (%d, '%s')", $edit['vid'], $type);

    }

    module_invoke_all('taxonomy', 'update', 'vocabulary', $edit);

    $status = SAVED_UPDATED;

  }

  else if (!empty($edit['vid'])) {

    $status = taxonomy_del_vocabulary($edit['vid']);

  }

  else {

    drupal_write_record('vocabulary', $edit);

    foreach ($edit['nodes'] as $type => $selected) {

      db_query("INSERT INTO {vocabulary_node_types} (vid, type) VALUES (%d, '%s')", $edit['vid'], $type);

    }

    module_invoke_all('taxonomy', 'insert', 'vocabulary', $edit);

    $status = SAVED_NEW;

  }

  cache_clear_all();

  return $status;

}

/**

 * Delete a vocabulary.

 *

 * @param $vid

 *   A vocabulary ID.

 * @return

 *   Constant indicating items were deleted.

 */

function taxonomy_del_vocabulary($vid) {

  $vocabulary = (array) taxonomy_vocabulary_load($vid);

  db_query('DELETE FROM {vocabulary} WHERE vid = %d', $vid);

  db_query('DELETE FROM {vocabulary_node_types} WHERE vid = %d', $vid);

  $result = db_query('SELECT tid FROM {term_data} WHERE vid = %d', $vid);

  while ($term = db_fetch_object($result)) {

    taxonomy_del_term($term->tid);

  }

  module_invoke_all('taxonomy', 'delete', 'vocabulary', $vocabulary);

  cache_clear_all();

  return SAVED_DELETED;

}

/**

 * Dynamicly check and update the hierarachy flag of a vocabulary.

 *

 * Checks the current parents of all terms in a vocabulary and updates the

 * vocabularies hierarchy setting to the lowest possible level. A hierarchy with

 * no parents in any of its terms will be given a hierarchy of 0. If terms

 * contain at most a single parent, the vocabulary will be given a hierarchy of

 * 1. If any term contain multiple parents, the vocabulary will be given a

 * hieararchy of 2.

 *

 * @param $vocabulary

 *   An array of the vocabulary structure.

 * @param $changed_term

 *   An array of the term structure that was updated.

 */

function taxonomy_check_vocabulary_hierarchy($vocabulary, $changed_term) {

  $tree = taxonomy_get_tree($vocabulary['vid']);

  $hierarchy = 0;

  foreach ($tree as $term) {

    // Update the changed term with the new parent value before comparision.

    if ($term->tid == $changed_term['tid']) {

      $term = (object)$changed_term;

      $term->parents = $term->parent;

    }

    // Check this term's parent count.

    if (count($term->parents) > 1) {

      $hierarchy = 2;

      break;

    }

    elseif (count($term->parents) == 1 && 0 !== array_shift($term->parents)) {

      $hierarchy = 1;

    }

  }

  if ($hierarchy != $vocabulary['hierarchy']) {

    $vocabulary['hierarchy'] = $hierarchy;

    taxonomy_save_vocabulary($vocabulary);

  }

  return $hierarchy;

}

/**

 * Helper function for taxonomy_form_term_submit().

 *

 * @param $form_state['values']

 * @return

 *   Status constant indicating if term was inserted or updated.

 */

function taxonomy_save_term(&$form_values) {

  $form_values += array(

    'description' => '',

    'weight' => 0

  );

  if (!empty($form_values['tid']) && $form_values['name']) {

    drupal_write_record('term_data', $form_values, 'tid');

    $hook = 'update';

    $status = SAVED_UPDATED;

  }

  else if (!empty($form_values['tid'])) {

    return taxonomy_del_term($form_values['tid']);

  }

  else {

    drupal_write_record('term_data', $form_values);

    $hook = 'insert';

    $status = SAVED_NEW;

  }

  db_query('DELETE FROM {term_relation} WHERE tid1 = %d OR tid2 = %d', $form_values['tid'], $form_values['tid']);

  if (!empty($form_values['relations'])) {

    foreach ($form_values['relations'] as $related_id) {

      if ($related_id != 0) {

        db_query('INSERT INTO {term_relation} (tid1, tid2) VALUES (%d, %d)', $form_values['tid'], $related_id);

      }

    }

  }

  db_query('DELETE FROM {term_hierarchy} WHERE tid = %d', $form_values['tid']);

  if (!isset($form_values['parent']) || empty($form_values['parent'])) {

    $form_values['parent'] = array(0);

  }

  if (is_array($form_values['parent'])) {

    foreach ($form_values['parent'] as $parent) {

      if (is_array($parent)) {

        foreach ($parent as $tid) {

          db_query('INSERT INTO {term_hierarchy} (tid, parent) VALUES (%d, %d)', $form_values['tid'], $tid);

        }

      }

      else {

        db_query('INSERT INTO {term_hierarchy} (tid, parent) VALUES (%d, %d)', $form_values['tid'], $parent);

      }

    }

  }

  else {

    db_query('INSERT INTO {term_hierarchy} (tid, parent) VALUES (%d, %d)', $form_values['tid'], $form_values['parent']);

  }

  db_query('DELETE FROM {term_synonym} WHERE tid = %d', $form_values['tid']);

  if (!empty($form_values['synonyms'])) {

    foreach (explode ("\n", str_replace("\r", '', $form_values['synonyms'])) as $synonym) {

      if ($synonym) {

        db_query("INSERT INTO {term_synonym} (tid, name) VALUES (%d, '%s')", $form_values['tid'], chop($synonym));

      }

    }

  }

  if (isset($hook)) {

    module_invoke_all('taxonomy', $hook, 'term', $form_values);

  }

  cache_clear_all();

  return $status;

}

/**

 * Delete a term.

 *

 * @param $tid

 *   The term ID.

 * @return

 *   Status constant indicating deletion.

 */

function taxonomy_del_term($tid) {

  $tids = array($tid);

  while ($tids) {

    $children_tids = $orphans = array();

    foreach ($tids as $tid) {

      // See if any of the term's children are about to be become orphans:

      if ($children = taxonomy_get_children($tid)) {

        foreach ($children as $child) {

          // If the term has multiple parents, we don't delete it.

          $parents = taxonomy_get_parents($child->tid);

          if (count($parents) == 1) {

            $orphans[] = $child->tid;

          }

        }

      }

      $term = (array) taxonomy_get_term($tid);

      db_query('DELETE FROM {term_data} WHERE tid = %d', $tid);

      db_query('DELETE FROM {term_hierarchy} WHERE tid = %d', $tid);

      db_query('DELETE FROM {term_relation} WHERE tid1 = %d OR tid2 = %d', $tid, $tid);

      db_query('DELETE FROM {term_synonym} WHERE tid = %d', $tid);

      db_query('DELETE FROM {term_node} WHERE tid = %d', $tid);

      module_invoke_all('taxonomy', 'delete', 'term', $term);

    }

    $tids = $orphans;

  }

  cache_clear_all();

  return SAVED_DELETED;

}

/**

 * Generate a form element for selecting terms from a vocabulary.

 */

function taxonomy_form($vid, $value = 0, $help = NULL, $name = 'taxonomy') {

  $vocabulary = taxonomy_vocabulary_load($vid);

  $help = ($help) ? $help : filter_xss_admin($vocabulary->help);

  if (!$vocabulary->multiple) {

    $blank = ($vocabulary->required) ? t('- Please choose -') : t('- None selected -');

  }

  else {

    $blank = ($vocabulary->required) ? 0 : t('- None -');

  }

  return _taxonomy_term_select(check_plain($vocabulary->name), $name, $value, $vid, $help, intval($vocabulary->multiple), $blank);

}

/**

 * Generate a set of options for selecting a term from all vocabularies.

 */

function taxonomy_form_all($free_tags = 0) {

  $vocabularies = taxonomy_get_vocabularies();

  $options = array();

  foreach ($vocabularies as $vid => $vocabulary) {

    if ($vocabulary->tags && !$free_tags) { continue; }

    $tree = taxonomy_get_tree($vid);

    if ($tree && (count($tree) > 0)) {

      $options[$vocabulary->name] = array();

      foreach ($tree as $term) {

        $options[$vocabulary->name][$term->tid] = str_repeat('-', $term->depth) . $term->name;

      }

    }

  }

  return $options;

}

/**

 * Return an array of all vocabulary objects.

 *

 * @param $type

 *   If set, return only those vocabularies associated with this node type.

 */

function taxonomy_get_vocabularies($type = NULL) {

  if ($type) {

    $result = db_query(db_rewrite_sql("SELECT v.vid, v.*, n.type FROM {vocabulary} v LEFT JOIN {vocabulary_node_types} n ON v.vid = n.vid WHERE n.type = '%s' ORDER BY v.weight, v.name", 'v', 'vid'), $type);

  }

  else {

    $result = db_query(db_rewrite_sql('SELECT v.*, n.type FROM {vocabulary} v LEFT JOIN {vocabulary_node_types} n ON v.vid = n.vid ORDER BY v.weight, v.name', 'v', 'vid'));

  }

  $vocabularies = array();

  $node_types = array();

  while ($voc = db_fetch_object($result)) {

    // If no node types are associated with a vocabulary, the LEFT JOIN will

    // return a NULL value for type.

    if (isset($voc->type)) {

      $node_types[$voc->vid][$voc->type] = $voc->type;

      unset($voc->type);

      $voc->nodes = $node_types[$voc->vid];

    }

    elseif (!isset($voc->nodes)) {

      $voc->nodes = array();

    }

    $vocabularies[$voc->vid] = $voc;

  }

  return $vocabularies;

}

/**

 * Implementation of hook_form_alter().

 * Generate a form for selecting terms to associate with a node.

 * We check for taxonomy_override_selector before loading the full

 * vocabulary, so contrib modules can intercept before hook_form_alter

 *  and provide scalable alternatives.

 */

function taxonomy_form_alter(&$form, $form_state, $form_id) {

  if (isset($form['type']) && isset($form['#node']) && (!variable_get('taxonomy_override_selector', FALSE)) && $form['type']['#value'] .'_node_form' == $form_id) {

    $node = $form['#node'];

    if (!isset($node->taxonomy)) {

      $terms = empty($node->nid) ? array() : taxonomy_node_get_terms($node);

    }

    else {

      // After preview the terms must be converted to objects.

      if (isset($form_state['node_preview'])) {

        $node->taxonomy = taxonomy_preview_terms($node);

      }

      $terms = $node->taxonomy;

    }

    $c = db_query(db_rewrite_sql("SELECT v.* FROM {vocabulary} v INNER JOIN {vocabulary_node_types} n ON v.vid = n.vid WHERE n.type = '%s' ORDER BY v.weight, v.name", 'v', 'vid'), $node->type);

    while ($vocabulary = db_fetch_object($c)) {

      if ($vocabulary->tags) {

        if (isset($form_state['node_preview'])) {

          // Typed string can be changed by the user before preview,

          // so we just insert the tags directly as provided in the form.

          $typed_string = $node->taxonomy['tags'][$vocabulary->vid];

        }

        else {

          $typed_string = taxonomy_implode_tags($terms, $vocabulary->vid) . (array_key_exists('tags', $terms) ? $terms['tags'][$vocabulary->vid] : NULL);

        }

        if ($vocabulary->help) {

          $help = filter_xss_admin($vocabulary->help);

        }

        else {

          $help = t('A comma-separated list of terms describing this content. Example: funny, bungee jumping, "Company, Inc.".');

        }

        $form['taxonomy']['tags'][$vocabulary->vid] = array('#type' => 'textfield',

          '#title' => $vocabulary->name,

          '#description' => $help,

          '#required' => $vocabulary->required,

          '#default_value' => $typed_string,

          '#autocomplete_path' => 'taxonomy/autocomplete/'. $vocabulary->vid,

          '#weight' => $vocabulary->weight,

          '#maxlength' => 1024,