View source
<?php
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>';
}
}
}
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;
}
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(
'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;
}
function taxonomy_term_uri($term) {
return array(
'path' => 'taxonomy/term/' . $term->tid,
);
}
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;
}
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);
list($table_alias, $name) = explode('.', $field);
$query
->addField($table_alias, $name);
}
return $query
->execute()
->fetchCol();
}
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',
),
);
}
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',
'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;
}
function taxonomy_admin_paths() {
$paths = array(
'taxonomy/term/*/edit' => TRUE,
);
return $paths;
}
function taxonomy_term_edit_access($term) {
return user_access("edit terms in {$term->vid}") || user_access('administer taxonomy');
}
function taxonomy_admin_vocabulary_title_callback($vocabulary) {
return check_plain($vocabulary->name);
}
function taxonomy_vocabulary_save($vocabulary) {
if (!empty($vocabulary->name)) {
$vocabulary->name = trim($vocabulary->name);
}
if (!empty($vocabulary->vid)) {
if (!isset($vocabulary->original)) {
$vocabulary->original = entity_load_unchanged('taxonomy_vocabulary', $vocabulary->vid);
}
$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;
}
function taxonomy_vocabulary_delete($vid) {
$vocabulary = taxonomy_vocabulary_load($vid);
$transaction = db_transaction();
try {
$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');
$taxonomy_fields = field_read_fields(array(
'module' => 'taxonomy',
));
foreach ($taxonomy_fields as $field_name => $taxonomy_field) {
$modified_field = FALSE;
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 {
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;
}
}
function taxonomy_taxonomy_vocabulary_update($vocabulary) {
if (!empty($vocabulary->old_machine_name) && $vocabulary->old_machine_name != $vocabulary->machine_name) {
$fields = field_read_fields();
foreach ($fields as $field_name => $field) {
$update = FALSE;
if ($field['type'] == 'taxonomy_term_reference') {
foreach ($field['settings']['allowed_values'] as $key => &$value) {
if ($value['vocabulary'] == $vocabulary->old_machine_name) {
$value['vocabulary'] = $vocabulary->machine_name;
$update = TRUE;
}
}
if ($update) {
field_update_field($field);
}
}
}
}
}
function taxonomy_check_vocabulary_hierarchy($vocabulary, $changed_term) {
$tree = taxonomy_get_tree($vocabulary->vid);
$hierarchy = 0;
foreach ($tree as $term) {
if ($term->tid == $changed_term['tid']) {
$term = (object) $changed_term;
$term->parents = $term->parent;
}
if (count($term->parents) > 1) {
$hierarchy = 2;
break;
}
elseif (count($term->parents) == 1 && !isset($term->parents[0])) {
$hierarchy = 1;
}
}
if ($hierarchy != $vocabulary->hierarchy) {
$vocabulary->hierarchy = $hierarchy;
taxonomy_vocabulary_save($vocabulary);
}
return $hierarchy;
}
function taxonomy_term_save($term) {
$term->name = trim($term->name);
if (!isset($term->vocabulary_machine_name)) {
$vocabulary = taxonomy_vocabulary_load($term->vid);
$term->vocabulary_machine_name = $vocabulary->machine_name;
}
if (!empty($term->tid) && !isset($term->original)) {
$term->original = entity_load_unchanged('taxonomy_term', $term->tid);
}
field_attach_presave('taxonomy_term', $term);
module_invoke_all('taxonomy_term_presave', $term);
module_invoke_all('entity_presave', $term, 'taxonomy_term');
if (empty($term->tid)) {
$op = 'insert';
$status = drupal_write_record('taxonomy_term_data', $term);
field_attach_insert('taxonomy_term', $term);
if (!isset($term->parent)) {
$term->parent = array(
0,
);
}
}
else {
$op = 'update';
$status = drupal_write_record('taxonomy_term_data', $term, 'tid');
field_attach_update('taxonomy_term', $term);
if (isset($term->parent)) {
db_delete('taxonomy_term_hierarchy')
->condition('tid', $term->tid)
->execute();
}
}
if (isset($term->parent)) {
if (!is_array($term->parent)) {
$term->parent = array(
$term->parent,
);
}
$query = db_insert('taxonomy_term_hierarchy')
->fields(array(
'tid',
'parent',
));
foreach ($term->parent as $parent) {
if (is_array($parent)) {
foreach ($parent as $tid) {
$query
->values(array(
'tid' => $term->tid,
'parent' => $tid,
));
}
}
else {
$query
->values(array(
'tid' => $term->tid,
'parent' => $parent,
));
}
}
$query
->execute();
}
taxonomy_terms_static_reset();
module_invoke_all("taxonomy_term_{$op}", $term);
module_invoke_all("entity_{$op}", $term, 'taxonomy_term');
unset($term->original);
return $status;
}
function taxonomy_term_delete($tid) {
$transaction = db_transaction();
try {
$tids = array(
$tid,
);
while ($tids) {
$children_tids = $orphans = array();
foreach ($tids as $tid) {
if ($children = taxonomy_get_children($tid)) {
foreach ($children as $child) {
$parents = taxonomy_get_parents($child->tid);
if (count($parents) == 1) {
$orphans[] = $child->tid;
}
}
}
if ($term = taxonomy_term_load($tid)) {
db_delete('taxonomy_term_data')
->condition('tid', $tid)
->execute();
db_delete('taxonomy_term_hierarchy')
->condition('tid', $tid)
->execute();
field_attach_delete('taxonomy_term', $term);
module_invoke_all('taxonomy_term_delete', $term);
module_invoke_all('entity_delete', $term, 'taxonomy_term');
taxonomy_terms_static_reset();
}
}
$tids = $orphans;
}
return SAVED_DELETED;
} catch (Exception $e) {
$transaction
->rollback();
watchdog_exception('taxonomy', $e);
throw $e;
}
}
function taxonomy_term_show($term) {
return taxonomy_term_view_multiple(array(
$term->tid => $term,
), 'full');
}
function taxonomy_term_view_multiple($terms, $view_mode = 'teaser', $weight = 0, $langcode = NULL) {
$build = array();
$entities_by_view_mode = entity_view_mode_prepare('taxonomy_term', $terms, $view_mode, $langcode);
foreach ($entities_by_view_mode as $entity_view_mode => $entities) {
field_attach_prepare_view('taxonomy_term', $entities, $entity_view_mode, $langcode);
entity_prepare_view('taxonomy_term', $entities, $langcode);
foreach ($entities as $entity) {
$build['taxonomy_terms'][$entity->tid] = taxonomy_term_view($entity, $entity_view_mode, $langcode);
}
}
foreach ($terms as $term) {
$build['taxonomy_terms'][$term->tid]['#weight'] = $weight;
$weight++;
}
uasort($build['taxonomy_terms'], 'element_sort');
$build['taxonomy_terms']['#sorted'] = TRUE;
return $build;
}
function taxonomy_term_build_content($term, $view_mode = 'full', $langcode = NULL) {
if (!isset($langcode)) {
$langcode = $GLOBALS['language_content']->language;
}
$term->content = array();
$view_mode = key(entity_view_mode_prepare('taxonomy_term', array(
$term->tid => $term,
), $view_mode, $langcode));
$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>',
);
}
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);
module_invoke_all('taxonomy_term_view', $term, $view_mode, $langcode);
module_invoke_all('entity_view', $term, 'taxonomy_term', $view_mode, $langcode);
$term->content += array(
'#view_mode' => $view_mode,
);
}
function taxonomy_term_view($term, $view_mode = 'full', $langcode = NULL) {
if (!isset($langcode)) {
$langcode = $GLOBALS['language_content']->language;
}
taxonomy_term_build_content($term, $view_mode, $langcode);
$build = $term->content;
unset($term->content);
$build += array(
'#theme' => 'taxonomy_term',
'#term' => $term,
'#view_mode' => $view_mode,
'#language' => $langcode,
);
$build['#attached']['css'][] = drupal_get_path('module', 'taxonomy') . '/taxonomy.css';
$type = 'taxonomy_term';
drupal_alter(array(
'taxonomy_term_view',
'entity_view',
), $build, $type);
return $build;
}
function template_preprocess_taxonomy_term(&$variables) {
$variables['view_mode'] = $variables['elements']['#view_mode'];
$variables['term'] = $variables['elements']['#term'];
$term = $variables['term'];
$uri = entity_uri('taxonomy_term', $term);
$variables['term_url'] = url($uri['path'], $uri['options']);
$variables['term_name'] = check_plain($term->name);
$variables['page'] = $variables['view_mode'] == 'full' && taxonomy_term_is_page($term);
$variables = array_merge((array) $term, $variables);
$variables['content'] = array();
foreach (element_children($variables['elements']) as $key) {
$variables['content'][$key] = $variables['elements'][$key];
}
field_attach_preprocess('taxonomy_term', $term, $variables['content'], $variables);
$vocabulary_name_css = str_replace('_', '-', $term->vocabulary_machine_name);
$variables['classes_array'][] = 'vocabulary-' . $vocabulary_name_css;
$variables['theme_hook_suggestions'][] = 'taxonomy_term__' . $term->vocabulary_machine_name;
$variables['theme_hook_suggestions'][] = 'taxonomy_term__' . $term->tid;
}
function taxonomy_term_is_page($term) {
$page_term = menu_get_object('taxonomy_term', 2);
return !empty($page_term) ? $page_term->tid == $term->tid : FALSE;
}
function taxonomy_terms_static_reset() {
drupal_static_reset('taxonomy_term_count_nodes');
drupal_static_reset('taxonomy_get_tree');
drupal_static_reset('taxonomy_get_tree:parents');
drupal_static_reset('taxonomy_get_tree:terms');
drupal_static_reset('taxonomy_get_parents');
drupal_static_reset('taxonomy_get_parents_all');
drupal_static_reset('taxonomy_get_children');
entity_get_controller('taxonomy_term')
->resetCache();
}
function taxonomy_vocabulary_static_reset($ids = NULL) {
drupal_static_reset('taxonomy_vocabulary_get_names');
entity_get_controller('taxonomy_vocabulary')
->resetCache($ids);
}
function taxonomy_get_vocabularies() {
return taxonomy_vocabulary_load_multiple(FALSE, array());
}
function taxonomy_vocabulary_get_names() {
$names =& drupal_static(__FUNCTION__);
if (!isset($names)) {
$names = db_query('SELECT name, machine_name, vid FROM {taxonomy_vocabulary}')
->fetchAllAssoc('machine_name');
}
return $names;
}
function taxonomy_get_parents($tid) {
$parents =& drupal_static(__FUNCTION__, array());
if ($tid && !isset($parents[$tid])) {
$query = db_select('taxonomy_term_data', 't');
$query
->join('taxonomy_term_hierarchy', 'h', 'h.parent = t.tid');
$query
->addField('t', 'tid');
$query
->condition('h.tid', $tid);
$query
->addTag('taxonomy_term_access');
$query
->orderBy('t.weight');
$query
->orderBy('t.name');
$tids = $query
->execute()
->fetchCol();
$parents[$tid] = taxonomy_term_load_multiple($tids);
}
return isset($parents[$tid]) ? $parents[$tid] : array();
}
function taxonomy_get_parents_all($tid) {
$cache =& drupal_static(__FUNCTION__, array());
if (isset($cache[$tid])) {
return $cache[$tid];
}
$parents = array();
if ($term = taxonomy_term_load($tid)) {
$parents[] = $term;
$n = 0;
while ($parent = taxonomy_get_parents($parents[$n]->tid)) {
$parents = array_merge($parents, $parent);
$n++;
}
}
$cache[$tid] = $parents;
return $parents;
}
function taxonomy_get_children($tid, $vid = 0) {
$children =& drupal_static(__FUNCTION__, array());
if ($tid && !isset($children[$tid])) {
$query = db_select('taxonomy_term_data', 't');
$query
->join('taxonomy_term_hierarchy', 'h', 'h.tid = t.tid');
$query
->addField('t', 'tid');
$query
->condition('h.parent', $tid);
if ($vid) {
$query
->condition('t.vid', $vid);
}
$query
->addTag('taxonomy_term_access');
$query
->orderBy('t.weight');
$query
->orderBy('t.name');
$tids = $query
->execute()
->fetchCol();
$children[$tid] = taxonomy_term_load_multiple($tids);
}
return isset($children[$tid]) ? $children[$tid] : array();
}
function taxonomy_get_tree($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());
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')
->addTag('taxonomy_term_access')
->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;
}
}
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();
$process_parents = array();
$process_parents[] = $parent;
while (count($process_parents)) {
$parent = array_pop($process_parents);
$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])) {
$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;
$process_parents[] = $parent;
$process_parents[] = $term->tid;
reset($children[$vid][$term->tid]);
next($children[$vid][$parent]);
break;
}
} while ($child = next($children[$vid][$parent]));
if (!$has_children) {
reset($children[$vid][$parent]);
}
}
}
return $tree;
}
function taxonomy_get_term_by_name($name, $vocabulary = NULL) {
$conditions = array(
'name' => trim($name),
);
if (isset($vocabulary)) {
$vocabularies = taxonomy_vocabulary_get_names();
if (isset($vocabularies[$vocabulary])) {
$conditions['vid'] = $vocabularies[$vocabulary]->vid;
}
else {
return array();
}
}
return taxonomy_term_load_multiple(array(), $conditions);
}
class TaxonomyTermController extends DrupalDefaultEntityController {
protected function buildQuery($ids, $conditions = array(), $revision_id = FALSE) {
$query = parent::buildQuery($ids, $conditions, $revision_id);
$query
->addTag('translatable');
$query
->addTag('taxonomy_term_access');
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']);
}
}
}
$query
->innerJoin('taxonomy_vocabulary', 'v', 'base.vid = v.vid');
$query
->addField('v', 'machine_name', 'vocabulary_machine_name');
return $query;
}
protected function cacheGet($ids, $conditions = array()) {
$terms = parent::cacheGet($ids, $conditions);
foreach ($terms as $term) {
$term_values = (array) $term;
if (isset($conditions['name']) && drupal_strtolower($conditions['name'] != drupal_strtolower($term_values['name']))) {
unset($terms[$term->tid]);
}
}
return $terms;
}
}
class TaxonomyVocabularyController extends DrupalDefaultEntityController {
protected function buildQuery($ids, $conditions = array(), $revision_id = FALSE) {
$query = parent::buildQuery($ids, $conditions, $revision_id);
$query
->addTag('translatable');
$query
->orderBy('base.weight');
$query
->orderBy('base.name');
return $query;
}
}
function taxonomy_term_load_multiple($tids = array(), $conditions = array()) {
return entity_load('taxonomy_term', $tids, $conditions);
}
function taxonomy_vocabulary_load_multiple($vids = array(), $conditions = array()) {
return entity_load('taxonomy_vocabulary', $vids, $conditions);
}
function taxonomy_vocabulary_load($vid) {
$vocabularies = taxonomy_vocabulary_load_multiple(array(
$vid,
));
return reset($vocabularies);
}
function taxonomy_vocabulary_machine_name_load($name) {
$vocabularies = taxonomy_vocabulary_load_multiple(NULL, array(
'machine_name' => $name,
));
return reset($vocabularies);
}
function taxonomy_term_load($tid) {
if (!is_numeric($tid)) {
return FALSE;
}
$term = taxonomy_term_load_multiple(array(
$tid,
), array());
return $term ? $term[$tid] : FALSE;
}
function _taxonomy_get_tid_from_term($term) {
return $term->tid;
}
function taxonomy_implode_tags($tags, $vid = NULL) {
$typed_tags = array();
foreach ($tags as $tag) {
if (!isset($vid) || $tag->vid == $vid) {
if (isset($tag->name)) {
if (strpos($tag->name, ',') !== FALSE || strpos($tag->name, '"') !== FALSE) {
$typed_tags[] = '"' . str_replace('"', '""', $tag->name) . '"';
}
else {
$typed_tags[] = $tag->name;
}
}
}
}
return implode(', ', $typed_tags);
}
function taxonomy_field_info() {
return array(
'taxonomy_term_reference' => array(
'label' => t('Term reference'),
'description' => t('This field stores a reference to a taxonomy term.'),
'default_widget' => 'options_select',
'default_formatter' => 'taxonomy_term_reference_link',
'settings' => array(
'allowed_values' => array(
array(
'vocabulary' => '',
'parent' => '0',
),
),
),
),
);
}
function taxonomy_field_widget_info() {
return array(
'taxonomy_autocomplete' => array(
'label' => t('Autocomplete term widget (tagging)'),
'field types' => array(
'taxonomy_term_reference',
),
'settings' => array(
'size' => 60,
'autocomplete_path' => 'taxonomy/autocomplete',
),
'behaviors' => array(
'multiple values' => FIELD_BEHAVIOR_CUSTOM,
),
),
);
}
function taxonomy_field_widget_info_alter(&$info) {
$info['options_select']['field types'][] = 'taxonomy_term_reference';
$info['options_buttons']['field types'][] = 'taxonomy_term_reference';
}
function taxonomy_options_list($field, $instance, $entity_type, $entity) {
$function = !empty($field['settings']['options_list_callback']) ? $field['settings']['options_list_callback'] : 'taxonomy_allowed_values';
return $function($field);
}
function taxonomy_field_validate($entity_type, $entity, $field, $instance, $langcode, $items, &$errors) {
foreach ($items as $delta => $item) {
if (!empty($item['tid']) && $item['tid'] != 'autocreate') {
$tids[] = $item['tid'];
}
}
if (!empty($tids)) {
$terms = taxonomy_term_load_multiple($tids);
foreach ($items as $delta => $item) {
$validate = TRUE;
if (!empty($item['tid']) && $item['tid'] != 'autocreate') {
$validate = FALSE;
foreach ($field['settings']['allowed_values'] as $settings) {
if (isset($settings['vocabulary']) && empty($settings['parent'])) {
if ($settings['vocabulary'] == $terms[$item['tid']]->vocabulary_machine_name) {
$validate = TRUE;
break;
}
}
elseif (!empty($settings['parent'])) {
$ancestors = taxonomy_get_parents_all($item['tid']);
foreach ($ancestors as $ancestor) {
if ($ancestor->tid == $settings['parent']) {
$validate = TRUE;
break 2;
}
}
}
}
}
if (!$validate) {
$errors[$field['field_name']][$langcode][$delta][] = array(
'error' => 'taxonomy_term_reference_illegal_value',
'message' => t('%name: illegal value.', array(
'%name' => $instance['label'],
)),
);
}
}
}
}
function taxonomy_field_is_empty($item, $field) {
if (!is_array($item) || empty($item['tid']) && (string) $item['tid'] !== '0') {
return TRUE;
}
return FALSE;
}
function taxonomy_field_formatter_info() {
return array(
'taxonomy_term_reference_link' => array(
'label' => t('Link'),
'field types' => array(
'taxonomy_term_reference',
),
),
'taxonomy_term_reference_plain' => array(
'label' => t('Plain text'),
'field types' => array(
'taxonomy_term_reference',
),
),
'taxonomy_term_reference_rss_category' => array(
'label' => t('RSS category'),
'field types' => array(
'taxonomy_term_reference',
),
),
);
}
function taxonomy_field_formatter_view($entity_type, $entity, $field, $instance, $langcode, $items, $display) {
$element = array();
switch ($display['type']) {
case 'taxonomy_term_reference_link':
foreach ($items as $delta => $item) {
if ($item['tid'] == 'autocreate') {
$element[$delta] = array(
'#markup' => check_plain($item['name']),
);
}
else {
$term = $item['taxonomy_term'];
$uri = entity_uri('taxonomy_term', $term);
$element[$delta] = array(
'#type' => 'link',
'#title' => $term->name,
'#href' => $uri['path'],
'#options' => $uri['options'],
);
}
}
break;
case 'taxonomy_term_reference_plain':
foreach ($items as $delta => $item) {
$name = $item['tid'] != 'autocreate' ? $item['taxonomy_term']->name : $item['name'];
$element[$delta] = array(
'#markup' => check_plain($name),
);
}
break;
case 'taxonomy_term_reference_rss_category':
foreach ($items as $delta => $item) {
$entity->rss_elements[] = array(
'key' => 'category',
'value' => $item['tid'] != 'autocreate' ? $item['taxonomy_term']->name : $item['name'],
'attributes' => array(
'domain' => $item['tid'] != 'autocreate' ? url('taxonomy/term/' . $item['tid'], array(
'absolute' => TRUE,
)) : '',
),
);
}
break;
}
return $element;
}
function taxonomy_allowed_values($field) {
$options = array();
foreach ($field['settings']['allowed_values'] as $tree) {
if ($vocabulary = taxonomy_vocabulary_machine_name_load($tree['vocabulary'])) {
if ($terms = taxonomy_get_tree($vocabulary->vid, $tree['parent'])) {
foreach ($terms as $term) {
$options[$term->tid] = str_repeat('-', $term->depth) . $term->name;
}
}
}
}
return $options;
}
function taxonomy_field_formatter_prepare_view($entity_type, $entities, $field, $instances, $langcode, &$items, $displays) {
$tids = array();
foreach ($entities as $id => $entity) {
foreach ($items[$id] as $delta => $item) {
if ($item['tid'] != 'autocreate') {
$tids[$item['tid']] = $item['tid'];
}
}
}
if ($tids) {
$terms = taxonomy_term_load_multiple($tids);
foreach ($entities as $id => $entity) {
$rekey = FALSE;
foreach ($items[$id] as $delta => $item) {
if (isset($terms[$item['tid']])) {
$items[$id][$delta]['taxonomy_term'] = $terms[$item['tid']];
}
elseif ($item['tid'] == 'autocreate') {
}
else {
unset($items[$id][$delta]);
$rekey = TRUE;
}
}
if ($rekey) {
$items[$id] = array_values($items[$id]);
}
}
}
}
function taxonomy_term_title($term) {
return $term->name;
}
function taxonomy_field_widget_form(&$form, &$form_state, $field, $instance, $langcode, $items, $delta, $element) {
$tags = array();
foreach ($items as $item) {
$tags[$item['tid']] = isset($item['taxonomy_term']) ? $item['taxonomy_term'] : taxonomy_term_load($item['tid']);
}
$element += array(
'#type' => 'textfield',
'#default_value' => taxonomy_implode_tags($tags),
'#autocomplete_path' => $instance['widget']['settings']['autocomplete_path'] . '/' . $field['field_name'],
'#size' => $instance['widget']['settings']['size'],
'#maxlength' => 1024,
'#element_validate' => array(
'taxonomy_autocomplete_validate',
),
);
return $element;
}
function taxonomy_autocomplete_validate($element, &$form_state) {
$value = array();
if ($tags = $element['#value']) {
$field = field_widget_field($element, $form_state);
$vocabularies = array();
foreach ($field['settings']['allowed_values'] as $tree) {
if ($vocabulary = taxonomy_vocabulary_machine_name_load($tree['vocabulary'])) {
$vocabularies[$vocabulary->vid] = $vocabulary;
}
}
$typed_terms = drupal_explode_tags($tags);
foreach ($typed_terms as $typed_term) {
if ($possibilities = taxonomy_term_load_multiple(array(), array(
'name' => trim($typed_term),
'vid' => array_keys($vocabularies),
))) {
$term = array_pop($possibilities);
}
else {
$vocabulary = reset($vocabularies);
$term = array(
'tid' => 'autocreate',
'vid' => $vocabulary->vid,
'name' => $typed_term,
'vocabulary_machine_name' => $vocabulary->machine_name,
);
}
$value[] = (array) $term;
}
}
form_set_value($element, $value, $form_state);
}
function taxonomy_field_widget_error($element, $error, $form, &$form_state) {
form_error($element, $error['message']);
}
function taxonomy_field_settings_form($field, $instance, $has_data) {
$vocabularies = taxonomy_get_vocabularies();
$options = array();
foreach ($vocabularies as $vocabulary) {
$options[$vocabulary->machine_name] = $vocabulary->name;
}
$form['allowed_values'] = array(
'#tree' => TRUE,
);
foreach ($field['settings']['allowed_values'] as $delta => $tree) {
$form['allowed_values'][$delta]['vocabulary'] = array(
'#type' => 'select',
'#title' => t('Vocabulary'),
'#default_value' => $tree['vocabulary'],
'#options' => $options,
'#required' => TRUE,
'#description' => t('The vocabulary which supplies the options for this field.'),
'#disabled' => $has_data,
);
$form['allowed_values'][$delta]['parent'] = array(
'#type' => 'value',
'#value' => $tree['parent'],
);
}
return $form;
}
function taxonomy_rdf_mapping() {
return array(
array(
'type' => 'taxonomy_term',
'bundle' => RDF_DEFAULT_BUNDLE,
'mapping' => array(
'rdftype' => array(
'skos:Concept',
),
'name' => array(
'predicates' => array(
'rdfs:label',
'skos:prefLabel',
),
),
'description' => array(
'predicates' => array(
'skos:definition',
),
),
'vid' => array(
'predicates' => array(
'skos:inScheme',
),
'type' => 'rel',
),
'parent' => array(
'predicates' => array(
'skos:broader',
),
'type' => 'rel',
),
),
),
array(
'type' => 'taxonomy_vocabulary',
'bundle' => RDF_DEFAULT_BUNDLE,
'mapping' => array(
'rdftype' => array(
'skos:ConceptScheme',
),
'name' => array(
'predicates' => array(
'dc:title',
),
),
'description' => array(
'predicates' => array(
'rdfs:comment',
),
),
),
),
);
}
function taxonomy_field_presave($entity_type, $entity, $field, $instance, $langcode, &$items) {
foreach ($items as $delta => $item) {
if ($item['tid'] == 'autocreate') {
$term = (object) $item;
unset($term->tid);
taxonomy_term_save($term);
$items[$delta]['tid'] = $term->tid;
}
}
}
function taxonomy_node_insert($node) {
taxonomy_build_node_index($node);
}
function taxonomy_build_node_index($node) {
$status = NULL;
if (variable_get('taxonomy_maintain_index_table', TRUE)) {
if (!empty($node->original)) {
$status = (int) (!empty($node->status) || !isset($node->status) && !empty($node->original->status));
$sticky = (int) (!empty($node->sticky) || !isset($node->sticky) && !empty($node->original->sticky));
}
else {
$status = (int) (!empty($node->status));
$sticky = (int) (!empty($node->sticky));
}
}
if ($status) {
$tid_all = array();
foreach (field_info_instances('node', $node->type) as $instance) {
$field_name = $instance['field_name'];
$field = field_info_field($field_name);
if ($field['module'] == 'taxonomy' && $field['storage']['type'] == 'field_sql_storage') {
if (isset($node->{$field_name})) {
$items = $node->{$field_name};
}
elseif (isset($node->original->{$field_name})) {
$items = $node->original->{$field_name};
}
else {
continue;
}
foreach (field_available_languages('node', $field) as $langcode) {
if (!empty($items[$langcode])) {
foreach ($items[$langcode] as $item) {
$tid_all[$item['tid']] = $item['tid'];
}
}
}
}
}
if (!empty($tid_all)) {
$query = db_insert('taxonomy_index')
->fields(array(
'nid',
'tid',
'sticky',
'created',
));
foreach ($tid_all as $tid) {
$query
->values(array(
'nid' => $node->nid,
'tid' => $tid,
'sticky' => $sticky,
'created' => $node->created,
));
}
$query
->execute();
}
}
}
function taxonomy_node_update($node) {
taxonomy_delete_node_index($node);
taxonomy_build_node_index($node);
}
function taxonomy_node_delete($node) {
taxonomy_delete_node_index($node);
}
function taxonomy_delete_node_index($node) {
if (variable_get('taxonomy_maintain_index_table', TRUE)) {
db_delete('taxonomy_index')
->condition('nid', $node->nid)
->execute();
}
}
function taxonomy_taxonomy_term_delete($term) {
if (variable_get('taxonomy_maintain_index_table', TRUE)) {
db_delete('taxonomy_index')
->condition('tid', $term->tid)
->execute();
}
}
function taxonomy_entity_query_alter($query) {
$conditions =& $query->entityConditions;
if (isset($conditions['entity_type']) && $conditions['entity_type']['value'] == 'taxonomy_term' && isset($conditions['bundle'])) {
$vocabulary_data = taxonomy_vocabulary_get_names();
$vids = array();
if (is_array($conditions['bundle']['value'])) {
foreach ($conditions['bundle']['value'] as $vocabulary_machine_name) {
$vids[] = $vocabulary_data[$vocabulary_machine_name]->vid;
}
}
else {
$vocabulary_machine_name = $conditions['bundle']['value'];
$vids = $vocabulary_data[$vocabulary_machine_name]->vid;
}
$query
->propertyCondition('vid', $vids, $conditions['bundle']['operator']);
unset($conditions['bundle']);
}
}