' . t('The Taxonomy module allows users who have permission to create and edit content to categorize (tag) content of that type. Users who have the Administer vocabularies and terms permission can add vocabularies that contain a set of related terms. The terms in a vocabulary can either be pre-set by an administrator or built gradually as content is added and edited. Terms may be organized hierarchically if desired.', [':permissions' => Url::fromRoute('user.admin_permissions', [], ['fragment' => 'module-taxonomy'])->toString()]) . '
'; $output .= '' . t('For more information, see the online documentation for the Taxonomy module.', [':taxonomy' => 'https://www.drupal.org/documentation/modules/taxonomy/']) . '
'; $output .= '' . t('Taxonomy is for categorizing content. Terms are grouped into vocabularies. For example, a vocabulary called "Fruit" would contain the terms "Apple" and "Banana".') . '
'; return $output; } } /** * Implements hook_entity_type_alter(). */ function taxonomy_entity_type_alter(array &$entity_types) { // @todo Moderation is disabled for taxonomy terms until integration is // enabled for them. // @see https://www.drupal.org/project/drupal/issues/3047110 $entity_types['taxonomy_term']->setHandlerClass('moderation', ''); } /** * Entity URI callback. */ function taxonomy_term_uri($term) { return new Url('entity.taxonomy_term.canonical', [ 'taxonomy_term' => $term->id(), ]); } /** * Implements hook_page_attachments_alter(). */ function taxonomy_page_attachments_alter(array &$page) { $route_match = \Drupal::routeMatch(); if ($route_match->getRouteName() == 'entity.taxonomy_term.canonical' && ($term = $route_match->getParameter('taxonomy_term')) && $term instanceof TermInterface) { foreach ($term->uriRelationships() as $rel) { // Set the URI relationships, like canonical. $page['#attached']['html_head_link'][] = [ [ 'rel' => $rel, 'href' => $term->toUrl($rel)->toString(), ], TRUE, ]; // Set the term path as the canonical URL to prevent duplicate content. if ($rel == 'canonical') { // Set the non-aliased canonical path as a default shortlink. $page['#attached']['html_head_link'][] = [ [ 'rel' => 'shortlink', 'href' => $term->toUrl($rel, ['alias' => TRUE])->toString(), ], TRUE, ]; } } } } /** * Implements hook_theme(). */ function taxonomy_theme() { return [ 'taxonomy_term' => [ 'render element' => 'elements', ], ]; } /** * Checks the hierarchy flag of a vocabulary. * * Checks the current parents of all terms in a vocabulary. If no term has * parent terms then the vocabulary will be given a hierarchy of * VocabularyInterface::HIERARCHY_DISABLED. If any term has a single parent then * the vocabulary will be given a hierarchy of * VocabularyInterface::HIERARCHY_SINGLE. If any term has multiple parents then * the vocabulary will be given a hierarchy of * VocabularyInterface::HIERARCHY_MULTIPLE. * * @param \Drupal\taxonomy\VocabularyInterface $vocabulary * A taxonomy vocabulary entity. * @param $changed_term * An array of the term structure that was updated. * * @return int * An integer that represents the level of the vocabulary's hierarchy. * * @deprecated in drupal:8.7.0 and is removed from drupal:9.0.0. Use * \Drupal\taxonomy\TermStorage::getVocabularyHierarchyType() instead. */ function taxonomy_check_vocabulary_hierarchy(VocabularyInterface $vocabulary, $changed_term) { @trigger_error('taxonomy_check_vocabulary_hierarchy() is deprecated in Drupal 8.7.x and will be removed before Drupal 9.0.x. Use \Drupal\taxonomy\TermStorage::getVocabularyHierarchyType() instead.', E_USER_DEPRECATED); return \Drupal::entityTypeManager()->getStorage('taxonomy_term')->getVocabularyHierarchyType($vocabulary->id()); } /** * Generates an array which displays a term detail page. * * @param \Drupal\taxonomy\Entity\Term $term * A taxonomy term object. * @param string $view_mode * View mode; e.g., 'full', 'teaser', etc. * @param string $langcode * (optional) A language code to use for rendering. Defaults to the global * content language of the current request. * * @return array * A $page element suitable for use by * \Drupal\Core\Render\RendererInterface::render(). * * @deprecated in drupal:8.7.0 and is removed from drupal:9.0.0. Use * \Drupal::entityTypeManager()->getViewBuilder('taxonomy_term')->view() * instead. * * @see https://www.drupal.org/node/3033656 */ function taxonomy_term_view(Term $term, $view_mode = 'full', $langcode = NULL) { @trigger_error("taxonomy_term_view() is deprecated in Drupal 8.7.0 and will be removed before Drupal 9.0.0. Use \Drupal::entityTypeManager()->getViewBuilder('taxonomy_term')->view() instead. See https://www.drupal.org/node/3033656", E_USER_DEPRECATED); return \Drupal::entityTypeManager() ->getViewBuilder('taxonomy_term') ->view($term, $view_mode, $langcode); } /** * Constructs a drupal_render() style array from an array of loaded terms. * * @param array $terms * An array of taxonomy terms as returned by Term::loadMultiple(). * @param string $view_mode * View mode; e.g., 'full', 'teaser', etc. * @param string $langcode * (optional) A language code to use for rendering. Defaults to the global * content language of the current request. * * @return array * An array in the format expected by * \Drupal\Core\Render\RendererInterface::render(). * * @deprecated in drupal:8.7.0 and is removed from drupal:9.0.0. Use * \Drupal::entityTypeManager()->getViewBuilder('taxonomy_term')->viewMultiple() * instead. * * @see https://www.drupal.org/node/3033656 */ function taxonomy_term_view_multiple(array $terms, $view_mode = 'full', $langcode = NULL) { @trigger_error("taxonomy_term_view_multiple() is deprecated in Drupal 8.7.0 and will be removed before Drupal 9.0.0. Use \Drupal::entityTypeManager()->getViewBuilder('taxonomy_term')->viewMultiple() instead. See https://www.drupal.org/node/3033656", E_USER_DEPRECATED); return \Drupal::entityTypeManager() ->getViewBuilder('taxonomy_term') ->viewMultiple($terms, $view_mode, $langcode); } /** * Implements hook_theme_suggestions_HOOK(). */ function taxonomy_theme_suggestions_taxonomy_term(array $variables) { $suggestions = []; /** @var \Drupal\taxonomy\TermInterface $term */ $term = $variables['elements']['#taxonomy_term']; $suggestions[] = 'taxonomy_term__' . $term->bundle(); $suggestions[] = 'taxonomy_term__' . $term->id(); return $suggestions; } /** * Prepares variables for taxonomy term templates. * * Default template: taxonomy-term.html.twig. * * By default this function performs special preprocessing to move the name * base field out of the elements array into a separate variable. This * preprocessing is skipped if: * - a module makes the field's display configurable via the field UI by means * of BaseFieldDefinition::setDisplayConfigurable() * - AND the additional entity type property * 'enable_base_field_custom_preprocess_skipping' has been set using * hook_entity_type_build(). * * @param array $variables * An associative array containing: * - elements: An associative array containing the taxonomy term and any * fields attached to the term. Properties used: * - #taxonomy_term: A \Drupal\taxonomy\TermInterface object. * - #view_mode: The current view mode for this taxonomy term, e.g. * 'full' or 'teaser'. * - attributes: HTML attributes for the containing element. */ function template_preprocess_taxonomy_term(&$variables) { $variables['view_mode'] = $variables['elements']['#view_mode']; $variables['term'] = $variables['elements']['#taxonomy_term']; /** @var \Drupal\taxonomy\TermInterface $term */ $term = $variables['term']; $variables['url'] = !$term->isNew() ? $term->toUrl()->toString() : NULL; // Make name field available separately. Skip this custom preprocessing if // the field display is configurable and skipping has been enabled. // @todo https://www.drupal.org/project/drupal/issues/3015623 // Eventually delete this code and matching template lines. Using // $variables['content'] is more flexible and consistent. $skip_custom_preprocessing = $term->getEntityType()->get('enable_base_field_custom_preprocess_skipping'); if (!$skip_custom_preprocessing || !$term->getFieldDefinition('name')->isDisplayConfigurable('view')) { // We use name here because that is what appears in the UI. $variables['name'] = $variables['elements']['name']; unset($variables['elements']['name']); } $variables['page'] = $variables['view_mode'] == 'full' && taxonomy_term_is_page($term); // Helpful $content variable for templates. $variables['content'] = []; foreach (Element::children($variables['elements']) as $key) { $variables['content'][$key] = $variables['elements'][$key]; } } /** * Returns whether the current page is the page of the passed-in term. * * @param \Drupal\taxonomy\Entity\Term $term * A taxonomy term entity. */ function taxonomy_term_is_page(Term $term) { if (\Drupal::routeMatch()->getRouteName() == 'entity.taxonomy_term.canonical' && $page_term_id = \Drupal::routeMatch()->getRawParameter('taxonomy_term')) { return $page_term_id == $term->id(); } return FALSE; } /** * Clear all static cache variables for terms. */ function taxonomy_terms_static_reset() { \Drupal::entityTypeManager()->getStorage('taxonomy_term')->resetCache(); } /** * Clear all static cache variables for vocabularies. * * @param $ids * An array of ids to reset in the entity cache. */ function taxonomy_vocabulary_static_reset(array $ids = NULL) { \Drupal::entityTypeManager()->getStorage('taxonomy_vocabulary')->resetCache($ids); } /** * Get names for all taxonomy vocabularies. * * @return array * A list of existing vocabulary IDs. */ function taxonomy_vocabulary_get_names() { $names = &drupal_static(__FUNCTION__); if (!isset($names)) { $names = []; $config_names = \Drupal::configFactory()->listAll('taxonomy.vocabulary.'); foreach ($config_names as $config_name) { $id = substr($config_name, strlen('taxonomy.vocabulary.')); $names[$id] = $id; } } return $names; } /** * Try to map a string to an existing term, as for glossary use. * * Provides a case-insensitive and trimmed mapping, to maximize the * likelihood of a successful match. * * @param $name * Name of the term to search for. * @param $vocabulary * (optional) Vocabulary machine name to limit the search. Defaults to NULL. * * @return * An array of matching term objects. */ function taxonomy_term_load_multiple_by_name($name, $vocabulary = NULL) { $values = ['name' => trim($name)]; if (isset($vocabulary)) { $vocabularies = taxonomy_vocabulary_get_names(); if (isset($vocabularies[$vocabulary])) { $values['vid'] = $vocabulary; } else { // Return an empty array when filtering by a non-existing vocabulary. return []; } } return \Drupal::entityTypeManager()->getStorage('taxonomy_term')->loadByProperties($values); } /** * Load multiple taxonomy terms based on certain conditions. * * This function should be used whenever you need to load more than one term * from the database. Terms are loaded into memory and will not require * database access if loaded again during the same page request. * * @param array $tids * (optional) An array of entity IDs. If omitted, all entities are loaded. * * @return array * An array of taxonomy term entities, indexed by tid. When no results are * found, an empty array is returned. * * @deprecated in drupal:8.0.0 and is removed from drupal:9.0.0. Use * \Drupal\taxonomy\Entity\Term::loadMultiple(). * * @see https://www.drupal.org/node/2266845 */ function taxonomy_term_load_multiple(array $tids = NULL) { @trigger_error('taxonomy_term_load_multiple() is deprecated in Drupal 8.0.0 and will be removed before Drupal 9.0.0. Use \Drupal\taxonomy\Entity\Term::loadMultiple(). See https://www.drupal.org/node/2266845', E_USER_DEPRECATED); return Term::loadMultiple($tids); } /** * Loads multiple taxonomy vocabularies based on certain conditions. * * This function should be used whenever you need to load more than one * vocabulary from the database. Terms are loaded into memory and will not * require database access if loaded again during the same page request. * * @param array $vids * (optional) An array of entity IDs. If omitted, all entities are loaded. * * @return array * An array of vocabulary objects, indexed by vid. * * @deprecated in drupal:8.0.0 and is removed from drupal:9.0.0. Use * \Drupal\taxonomy\Entity\Vocabulary::loadMultiple(). * * @see https://www.drupal.org/node/2266845 */ function taxonomy_vocabulary_load_multiple(array $vids = NULL) { @trigger_error('taxonomy_vocabulary_load_multiple() is deprecated in Drupal 8.0.0 and will be removed before Drupal 9.0.0. Use \Drupal\taxonomy\Entity\Vocabulary::loadMultiple(). See https://www.drupal.org/node/2266845', E_USER_DEPRECATED); return Vocabulary::loadMultiple($vids); } /** * Return the taxonomy vocabulary entity matching a vocabulary ID. * * @param int $vid * The vocabulary's ID. * * @return \Drupal\taxonomy\Entity\Vocabulary|null * The taxonomy vocabulary entity, if exists, NULL otherwise. Results are * statically cached. * * @deprecated in drupal:8.0.0 and is removed from drupal:9.0.0. Use * \Drupal\taxonomy\Entity\Vocabulary::load(). * * @see https://www.drupal.org/node/2266845 */ function taxonomy_vocabulary_load($vid) { @trigger_error('taxonomy_vocabulary_load() is deprecated in Drupal 8.0.0 and will be removed before Drupal 9.0.0. Use \Drupal\taxonomy\Entity\Vocabulary::load(). See https://www.drupal.org/node/2266845', E_USER_DEPRECATED); return Vocabulary::load($vid); } /** * Return the taxonomy term entity matching a term ID. * * @param $tid * A term's ID * * @return \Drupal\taxonomy\Entity\Term|null * A taxonomy term entity, or NULL if the term was not found. Results are * statically cached. * * @deprecated in drupal:8.0.0 and is removed from drupal:9.0.0. Use * Drupal\taxonomy\Entity\Term::load(). * * @see https://www.drupal.org/node/2266845 */ function taxonomy_term_load($tid) { @trigger_error('taxonomy_term_load() is deprecated in Drupal 8.0.0 and will be removed before Drupal 9.0.0. Use \Drupal\taxonomy\Entity\Term::load(). See https://www.drupal.org/node/2266845', E_USER_DEPRECATED); if (!is_numeric($tid)) { return NULL; } return Term::load($tid); } /** * Implodes a list of tags of a certain vocabulary into a string. * * @see \Drupal\Component\Utility\Tags::explode() */ function taxonomy_implode_tags($tags, $vid = NULL) { $typed_tags = []; foreach ($tags as $tag) { // Extract terms belonging to the vocabulary in question. if (!isset($vid) || $tag->bundle() == $vid) { // Make sure we have a completed loaded taxonomy term. if ($tag instanceof EntityInterface && $label = $tag->label()) { // Commas and quotes in tag names are special cases, so encode 'em. $typed_tags[] = Tags::encode($label); } } } return implode(', ', $typed_tags); } /** * Title callback for term pages. * * @param \Drupal\taxonomy\Entity\Term $term * A taxonomy term entity. * * @return * The term name to be used as the page title. */ function taxonomy_term_title(Term $term) { return $term->getName(); } /** * @defgroup taxonomy_index Taxonomy indexing * @{ * Functions to maintain taxonomy indexing. * * Taxonomy uses default field storage to store canonical relationships * between terms and fieldable entities. However its most common use case * requires listing all content associated with a term or group of terms * sorted by creation date. To avoid slow queries due to joining across * multiple node and field tables with various conditions and order by criteria, * we maintain a denormalized table with all relationships between terms, * published nodes and common sort criteria such as status, sticky and created. * When using other field storage engines or alternative methods of * denormalizing this data you should set the * taxonomy.settings:maintain_index_table to '0' to avoid unnecessary writes in * SQL. */ /** * Implements hook_ENTITY_TYPE_insert() for node entities. */ function taxonomy_node_insert(EntityInterface $node) { // Add taxonomy index entries for the node. taxonomy_build_node_index($node); } /** * Builds and inserts taxonomy index entries for a given node. * * The index lists all terms that are related to a given node entity, and is * therefore maintained at the entity level. * * @param \Drupal\node\Entity\Node $node * The node entity. */ function taxonomy_build_node_index($node) { // We maintain a denormalized table of term/node relationships, containing // only data for current, published nodes. if (!\Drupal::config('taxonomy.settings')->get('maintain_index_table') || !(\Drupal::entityTypeManager()->getStorage('node') instanceof SqlContentEntityStorage)) { return; } $status = $node->isPublished(); $sticky = (int) $node->isSticky(); // We only maintain the taxonomy index for published nodes. if ($status && $node->isDefaultRevision()) { // Collect a unique list of all the term IDs from all node fields. $tid_all = []; $entity_reference_class = 'Drupal\Core\Field\Plugin\Field\FieldType\EntityReferenceItem'; foreach ($node->getFieldDefinitions() as $field) { $field_name = $field->getName(); $class = $field->getItemDefinition()->getClass(); $is_entity_reference_class = ($class === $entity_reference_class) || is_subclass_of($class, $entity_reference_class); if ($is_entity_reference_class && $field->getSetting('target_type') == 'taxonomy_term') { foreach ($node->getTranslationLanguages() as $language) { foreach ($node->getTranslation($language->getId())->$field_name as $item) { if (!$item->isEmpty()) { $tid_all[$item->target_id] = $item->target_id; } } } } } // Insert index entries for all the node's terms. if (!empty($tid_all)) { $connection = \Drupal::database(); foreach ($tid_all as $tid) { $connection->merge('taxonomy_index') ->key(['nid' => $node->id(), 'tid' => $tid, 'status' => $node->isPublished()]) ->fields(['sticky' => $sticky, 'created' => $node->getCreatedTime()]) ->execute(); } } } } /** * Implements hook_ENTITY_TYPE_update() for node entities. */ function taxonomy_node_update(EntityInterface $node) { // If we're not dealing with the default revision of the node, do not make any // change to the taxonomy index. if (!$node->isDefaultRevision()) { return; } taxonomy_delete_node_index($node); taxonomy_build_node_index($node); } /** * Implements hook_ENTITY_TYPE_predelete() for node entities. */ function taxonomy_node_predelete(EntityInterface $node) { // Clean up the {taxonomy_index} table when nodes are deleted. taxonomy_delete_node_index($node); } /** * Deletes taxonomy index entries for a given node. * * @param \Drupal\Core\Entity\EntityInterface $node * The node entity. */ function taxonomy_delete_node_index(EntityInterface $node) { if (\Drupal::config('taxonomy.settings')->get('maintain_index_table')) { \Drupal::database()->delete('taxonomy_index')->condition('nid', $node->id())->execute(); } } /** * Implements hook_ENTITY_TYPE_delete() for taxonomy_term entities. */ function taxonomy_taxonomy_term_delete(Term $term) { if (\Drupal::config('taxonomy.settings')->get('maintain_index_table')) { // Clean up the {taxonomy_index} table when terms are deleted. \Drupal::database()->delete('taxonomy_index')->condition('tid', $term->id())->execute(); } } /** * @} End of "defgroup taxonomy_index". */