comment.module

Same filename in other branches
  1. 7.x modules/comment/comment.module
  2. 9 core/modules/comment/comment.module
  3. 8.9.x core/modules/comment/comment.module
  4. 11.x core/modules/comment/comment.module

Enables users to comment on published content.

When installed, the Comment module creates a field that facilitates a discussion board for each Drupal entity to which a comment field is attached. Users can post comments to discuss a story, user etc.

File

core/modules/comment/comment.module

View source
<?php


/**
 * @file
 * Enables users to comment on published content.
 *
 * When installed, the Comment module creates a field that facilitates a
 * discussion board for each Drupal entity to which a comment field is attached.
 * Users can post comments to discuss a story, user etc.
 */
use Drupal\comment\CommentInterface;
use Drupal\comment\Entity\CommentType;
use Drupal\Core\Entity\FieldableEntityInterface;
use Drupal\comment\Plugin\Field\FieldType\CommentItemInterface;
use Drupal\Core\Entity\Entity\EntityViewMode;
use Drupal\Core\Entity\EntityInterface;
use Drupal\Core\Field\FieldTypeCategoryManagerInterface;
use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Routing\RouteMatchInterface;
use Drupal\Core\Entity\Display\EntityViewDisplayInterface;
use Drupal\Core\Render\Element;
use Drupal\Core\Link;
use Drupal\Core\Url;
use Drupal\field\FieldConfigInterface;
use Drupal\field\FieldStorageConfigInterface;
use Drupal\node\NodeInterface;
use Drupal\user\RoleInterface;
use Drupal\user\UserInterface;

/**
 * The time cutoff for comments marked as read for entity types other node.
 *
 * Comments changed before this time are always marked as read.
 * Comments changed after this time may be marked new, updated, or read,
 * depending on their state for the current user. Defaults to 30 days ago.
 *
 * @todo Remove when https://www.drupal.org/node/2006632 lands.
 */
define('COMMENT_NEW_LIMIT', (int) $_SERVER['REQUEST_TIME'] - 30 * 24 * 60 * 60);

/**
 * Implements hook_help().
 */
function comment_help($route_name, RouteMatchInterface $route_match) {
    switch ($route_name) {
        case 'help.page.comment':
            $output = '<h2>' . t('About') . '</h2>';
            $output .= '<p>' . t('The Comment module allows users to comment on site content, set commenting defaults and permissions, and moderate comments. For more information, see the <a href=":comment">online documentation for the Comment module</a>.', [
                ':comment' => 'https://www.drupal.org/documentation/modules/comment',
            ]) . '</p>';
            $output .= '<h2>' . t('Uses') . '</h2>';
            $output .= '<dl>';
            $output .= '<dt>' . t('Enabling commenting') . '</dt>';
            $output .= '<dd>' . t('Comment functionality can be enabled for any entity sub-type (for example, a <a href=":content-type">content type</a>) by adding a <em>Comments</em> field on its <em>Manage fields page</em>. Adding or removing commenting for an entity through the user interface requires the <a href=":field_ui">Field UI</a> module to be installed, even though the commenting functionality works without it. For more information on fields and entities, see the <a href=":field">Field module help page</a>.', [
                ':content-type' => \Drupal::moduleHandler()->moduleExists('node') ? Url::fromRoute('entity.node_type.collection')->toString() : '#',
                ':field' => Url::fromRoute('help.page', [
                    'name' => 'field',
                ])->toString(),
                ':field_ui' => \Drupal::moduleHandler()->moduleExists('field_ui') ? Url::fromRoute('help.page', [
                    'name' => 'field_ui',
                ])->toString() : '#',
            ]) . '</dd>';
            $output .= '<dt>' . t('Configuring commenting settings') . '</dt>';
            $output .= '<dd>' . t('Commenting settings can be configured by editing the <em>Comments</em> field on the <em>Manage fields page</em> of an entity type if the <em>Field UI module</em> is installed. Configuration includes the label of the comments field, the number of comments to be displayed, and whether they are shown in threaded list. Commenting can be configured as: <em>Open</em> to allow new comments, <em>Closed</em> to view existing comments, but prevent new comments, or <em>Hidden</em> to hide existing comments and prevent new comments. Changing this configuration for an entity type will not change existing entity items.') . '</dd>';
            $output .= '<dt>' . t('Overriding default settings') . '</dt>';
            $output .= '<dd>' . t('Users with the appropriate permissions can override the default commenting settings of an entity type when they create an item of that type.') . '</dd>';
            $output .= '<dt>' . t('Adding comment types') . '</dt>';
            $output .= '<dd>' . t('Additional <em>comment types</em> can be created per entity sub-type and added on the <a href=":field">Comment types page</a>. If there are multiple comment types available you can select the appropriate one after adding a <em>Comments field</em>.', [
                ':field' => Url::fromRoute('entity.comment_type.collection')->toString(),
            ]) . '</dd>';
            $output .= '<dt>' . t('Approving and managing comments') . '</dt>';
            $output .= '<dd>' . t('Comments from users who have the <em>Skip comment approval</em> permission are published immediately. All other comments are placed in the <a href=":comment-approval">Unapproved comments</a> queue, until a user who has permission to <em>Administer comments and comment settings</em> publishes or deletes them. Published comments can be bulk managed on the <a href=":admin-comment">Published comments</a> administration page. When a comment has no replies, it remains editable by its author, as long as the author has <em>Edit own comments</em> permission.', [
                ':comment-approval' => Url::fromRoute('comment.admin_approval')->toString(),
                ':admin-comment' => Url::fromRoute('comment.admin')->toString(),
            ]) . '</dd>';
            $output .= '</dl>';
            return $output;
        case 'entity.comment_type.collection':
            $output = '<p>' . t('This page provides a list of all comment types on the site and allows you to manage the fields, form and display settings for each.') . '</p>';
            return $output;
    }
}

/**
 * Entity URI callback.
 */
function comment_uri(CommentInterface $comment) {
    return new Url('entity.comment.canonical', [
        'comment' => $comment->id(),
    ], [
        'fragment' => 'comment-' . $comment->id(),
    ]);
}

/**
 * Implements hook_entity_extra_field_info().
 */
function comment_entity_extra_field_info() {
    $return = [];
    foreach (CommentType::loadMultiple() as $comment_type) {
        $return['comment'][$comment_type->id()] = [
            'form' => [
                'author' => [
                    'label' => t('Author'),
                    'description' => t('Author textfield'),
                    'weight' => -2,
                ],
            ],
        ];
        $return['comment'][$comment_type->id()]['display']['links'] = [
            'label' => t('Links'),
            'description' => t('Comment operation links'),
            'weight' => 100,
            'visible' => TRUE,
        ];
    }
    return $return;
}

/**
 * Implements hook_theme().
 */
function comment_theme() {
    return [
        'comment' => [
            'render element' => 'elements',
        ],
        'field__comment' => [
            'base hook' => 'field',
        ],
    ];
}

/**
 * Implements hook_ENTITY_TYPE_create() for 'field_config'.
 */
function comment_field_config_create(FieldConfigInterface $field) {
    if ($field->getType() == 'comment' && !$field->isSyncing()) {
        // Assign default values for the field.
        $default_value = $field->getDefaultValueLiteral();
        $default_value += [
            [],
        ];
        $default_value[0] += [
            'status' => CommentItemInterface::OPEN,
            'cid' => 0,
            'last_comment_timestamp' => 0,
            'last_comment_name' => '',
            'last_comment_uid' => 0,
            'comment_count' => 0,
        ];
        $field->setDefaultValue($default_value);
    }
}

/**
 * Implements hook_ENTITY_TYPE_update() for 'field_config'.
 */
function comment_field_config_update(FieldConfigInterface $field) {
    if ($field->getType() == 'comment') {
        // Comment field settings also affects the rendering of *comment* entities,
        // not only the *commented* entities.
        \Drupal::entityTypeManager()->getViewBuilder('comment')
            ->resetCache();
    }
}

/**
 * Implements hook_ENTITY_TYPE_insert() for 'field_storage_config'.
 */
function comment_field_storage_config_insert(FieldStorageConfigInterface $field_storage) {
    if ($field_storage->getType() == 'comment') {
        // Check that the target entity type uses an integer ID.
        $entity_type_id = $field_storage->getTargetEntityTypeId();
        if (!_comment_entity_uses_integer_id($entity_type_id)) {
            throw new \UnexpectedValueException('You cannot attach a comment field to an entity with a non-integer ID field');
        }
    }
}

/**
 * Implements hook_ENTITY_TYPE_delete() for 'field_config'.
 */
function comment_field_config_delete(FieldConfigInterface $field) {
    if ($field->getType() == 'comment') {
        // Delete all comments that used by the entity bundle.
        $entity_query = \Drupal::entityQuery('comment')->accessCheck(FALSE);
        $entity_query->condition('entity_type', $field->getEntityTypeId());
        $entity_query->condition('field_name', $field->getName());
        $cids = $entity_query->execute();
        $comment_storage = \Drupal::entityTypeManager()->getStorage('comment');
        $comments = $comment_storage->loadMultiple($cids);
        $comment_storage->delete($comments);
    }
}

/**
 * Implements hook_node_links_alter().
 */
function comment_node_links_alter(array &$links, NodeInterface $node, array &$context) {
    // Comment links are only added to node entity type for backwards
    // compatibility. Should you require comment links for other entity types you
    // can do so by implementing a new field formatter.
    // @todo Make this configurable from the formatter. See
    //   https://www.drupal.org/node/1901110.
    $comment_links = \Drupal::service('comment.link_builder')->buildCommentedEntityLinks($node, $context);
    $links += $comment_links;
}

/**
 * Implements hook_entity_view().
 */
function comment_entity_view(array &$build, EntityInterface $entity, EntityViewDisplayInterface $display, $view_mode) {
    if ($entity instanceof FieldableEntityInterface && $view_mode == 'rss' && $display->getComponent('links')) {
        
        /** @var \Drupal\comment\CommentManagerInterface $comment_manager */
        $comment_manager = \Drupal::service('comment.manager');
        $fields = $comment_manager->getFields($entity->getEntityTypeId());
        foreach ($fields as $field_name => $detail) {
            if ($entity->hasField($field_name) && $entity->get($field_name)->status != CommentItemInterface::HIDDEN) {
                // Add a comments RSS element which is a URL to the comments of this
                // entity.
                $options = [
                    'fragment' => 'comments',
                    'absolute' => TRUE,
                ];
                $entity->rss_elements[] = [
                    'key' => 'comments',
                    'value' => $entity->toUrl('canonical', $options)
                        ->toString(),
                ];
            }
        }
    }
}

/**
 * Implements hook_ENTITY_TYPE_view_alter() for node entities.
 */
function comment_node_view_alter(array &$build, EntityInterface $node, EntityViewDisplayInterface $display) {
    if (\Drupal::moduleHandler()->moduleExists('history')) {
        $build['#attributes']['data-history-node-id'] = $node->id();
    }
}

/**
 * Implements hook_form_FORM_ID_alter() for field_ui_field_storage_add_form.
 */
function comment_form_field_ui_field_storage_add_form_alter(&$form, FormStateInterface $form_state) {
    $route_match = \Drupal::routeMatch();
    if ($form_state->get('entity_type_id') == 'comment' && $route_match->getParameter('commented_entity_type')) {
        $form['#title'] = \Drupal::service('comment.manager')->getFieldUIPageTitle($route_match->getParameter('commented_entity_type'), $route_match->getParameter('field_name'));
    }
}

/**
 * Implements hook_field_info_entity_type_ui_definitions_alter().
 */
function comment_field_info_entity_type_ui_definitions_alter(array &$ui_definitions, string $entity_type_id) {
    if (!_comment_entity_uses_integer_id($entity_type_id)) {
        unset($ui_definitions['comment']);
    }
}

/**
 * Implements hook_form_FORM_ID_alter().
 */
function comment_form_field_ui_form_display_overview_form_alter(&$form, FormStateInterface $form_state) {
    $route_match = \Drupal::routeMatch();
    if ($form['#entity_type'] == 'comment' && $route_match->getParameter('commented_entity_type')) {
        $form['#title'] = \Drupal::service('comment.manager')->getFieldUIPageTitle($route_match->getParameter('commented_entity_type'), $route_match->getParameter('field_name'));
    }
}

/**
 * Implements hook_form_FORM_ID_alter().
 */
function comment_form_field_ui_display_overview_form_alter(&$form, FormStateInterface $form_state) {
    $route_match = \Drupal::routeMatch();
    if ($form['#entity_type'] == 'comment' && $route_match->getParameter('commented_entity_type')) {
        $form['#title'] = \Drupal::service('comment.manager')->getFieldUIPageTitle($route_match->getParameter('commented_entity_type'), $route_match->getParameter('field_name'));
    }
}

/**
 * Implements hook_entity_storage_load().
 *
 * @see \Drupal\comment\Plugin\Field\FieldType\CommentItem::propertyDefinitions()
 */
function comment_entity_storage_load($entities, $entity_type) {
    // Comments can only be attached to content entities, so skip others.
    if (!\Drupal::entityTypeManager()->getDefinition($entity_type)
        ->entityClassImplements(FieldableEntityInterface::class)) {
        return;
    }
    if (!\Drupal::service('comment.manager')->getFields($entity_type)) {
        // Do not query database when entity has no comment fields.
        return;
    }
    // Load comment information from the database and update the entity's
    // comment statistics properties, which are defined on each CommentItem field.
    $result = \Drupal::service('comment.statistics')->read($entities, $entity_type);
    foreach ($result as $record) {
        // Skip fields that entity does not have.
        if (!$entities[$record->entity_id]
            ->hasField($record->field_name)) {
            continue;
        }
        $comment_statistics = $entities[$record->entity_id]
            ->get($record->field_name);
        $comment_statistics->cid = $record->cid;
        $comment_statistics->last_comment_timestamp = $record->last_comment_timestamp;
        $comment_statistics->last_comment_name = $record->last_comment_name;
        $comment_statistics->last_comment_uid = $record->last_comment_uid;
        $comment_statistics->comment_count = $record->comment_count;
    }
}

/**
 * Implements hook_entity_insert().
 */
function comment_entity_insert(EntityInterface $entity) {
    // Allow bulk updates and inserts to temporarily disable the
    // maintenance of the {comment_entity_statistics} table.
    if (\Drupal::state()->get('comment.maintain_entity_statistics') && ($fields = \Drupal::service('comment.manager')->getFields($entity->getEntityTypeId()))) {
        \Drupal::service('comment.statistics')->create($entity, $fields);
    }
}

/**
 * Implements hook_entity_predelete().
 */
function comment_entity_predelete(EntityInterface $entity) {
    // Entities can have non-numeric IDs, but {comment} and
    // {comment_entity_statistics} tables have integer columns for entity ID, and
    // PostgreSQL throws exceptions if you attempt query conditions with
    // mismatched types. So, we need to verify that the ID is numeric (even for an
    // entity type that has an integer ID, $entity->id() might be a string
    // containing a number), and then cast it to an integer when querying.
    if ($entity instanceof FieldableEntityInterface && is_numeric($entity->id())) {
        $entity_query = \Drupal::entityQuery('comment')->accessCheck(FALSE);
        $entity_query->condition('entity_id', (int) $entity->id());
        $entity_query->condition('entity_type', $entity->getEntityTypeId());
        $cids = $entity_query->execute();
        $comment_storage = \Drupal::entityTypeManager()->getStorage('comment');
        $comments = $comment_storage->loadMultiple($cids);
        $comment_storage->delete($comments);
        \Drupal::service('comment.statistics')->delete($entity);
    }
}

/**
 * Determines if an entity type is using an integer-based ID definition.
 *
 * @param string $entity_type_id
 *   The ID the represents the entity type.
 *
 * @return bool
 *   Returns TRUE if the entity type has an integer-based ID definition and
 *   FALSE otherwise.
 */
function _comment_entity_uses_integer_id($entity_type_id) {
    $entity_type = \Drupal::entityTypeManager()->getDefinition($entity_type_id);
    $entity_type_id_key = $entity_type->getKey('id');
    if ($entity_type_id_key === FALSE) {
        return FALSE;
    }
    $field_definitions = \Drupal::service('entity_field.manager')->getBaseFieldDefinitions($entity_type->id());
    $entity_type_id_definition = $field_definitions[$entity_type_id_key];
    return $entity_type_id_definition->getType() === 'integer';
}

/**
 * Implements hook_node_update_index().
 */
function comment_node_update_index(EntityInterface $node) {
    $index_comments =& drupal_static(__FUNCTION__);
    if ($index_comments === NULL) {
        // Do not index in the following three cases:
        // 1. 'Authenticated user' can search content but can't access comments.
        // 2. 'Anonymous user' can search content but can't access comments.
        // 3. Any role can search content but can't access comments and access
        // comments is not granted by the 'authenticated user' role. In this case
        // all users might have both permissions from various roles but it is also
        // possible to set up a user to have only search content and so a user
        // edit could change the security situation so it is not safe to index the
        // comments.
        $index_comments = TRUE;
        $roles = \Drupal::entityTypeManager()->getStorage('user_role')
            ->loadMultiple();
        $authenticated_can_access = $roles[RoleInterface::AUTHENTICATED_ID]->hasPermission('access comments');
        foreach ($roles as $rid => $role) {
            if ($role->hasPermission('search content') && !$role->hasPermission('access comments')) {
                if ($rid == RoleInterface::AUTHENTICATED_ID || $rid == RoleInterface::ANONYMOUS_ID || !$authenticated_can_access) {
                    $index_comments = FALSE;
                    break;
                }
            }
        }
    }
    $build = [];
    if ($index_comments) {
        foreach (\Drupal::service('comment.manager')->getFields('node') as $field_name => $info) {
            // Skip fields that entity does not have.
            if (!$node->hasField($field_name)) {
                continue;
            }
            $field_definition = $node->getFieldDefinition($field_name);
            $mode = $field_definition->getSetting('default_mode');
            $comments_per_page = $field_definition->getSetting('per_page');
            if ($node->get($field_name)->status) {
                $comments = \Drupal::entityTypeManager()->getStorage('comment')
                    ->loadThread($node, $field_name, $mode, $comments_per_page);
                if ($comments) {
                    $build[] = \Drupal::entityTypeManager()->getViewBuilder('comment')
                        ->viewMultiple($comments);
                }
            }
        }
    }
    return \Drupal::service('renderer')->renderInIsolation($build);
}

/**
 * Implements hook_cron().
 */
function comment_cron() {
    // Store the maximum possible comments per thread (used for node search
    // ranking by reply count).
    \Drupal::state()->set('comment.node_comment_statistics_scale', 1.0 / max(1, \Drupal::service('comment.statistics')->getMaximumCount('node')));
}

/**
 * Implements hook_node_search_result().
 *
 * Formats a comment count string and returns it, for display with search
 * results.
 */
function comment_node_search_result(EntityInterface $node) {
    $comment_fields = \Drupal::service('comment.manager')->getFields('node');
    $comments = 0;
    $open = FALSE;
    foreach ($comment_fields as $field_name => $info) {
        // Skip fields that entity does not have.
        if (!$node->hasField($field_name)) {
            continue;
        }
        // Do not make a string if comments are hidden.
        $status = $node->get($field_name)->status;
        if (\Drupal::currentUser()->hasPermission('access comments') && $status != CommentItemInterface::HIDDEN) {
            if ($status == CommentItemInterface::OPEN) {
                // At least one comment field is open.
                $open = TRUE;
            }
            $comments += $node->get($field_name)->comment_count;
        }
    }
    // Do not make a string if there are no comment fields, or no comments exist
    // or all comment fields are hidden.
    if ($comments > 0 || $open) {
        return [
            'comment' => \Drupal::translation()->formatPlural($comments, '1 comment', '@count comments'),
        ];
    }
}

/**
 * Implements hook_user_cancel().
 */
function comment_user_cancel($edit, UserInterface $account, $method) {
    switch ($method) {
        case 'user_cancel_block_unpublish':
            $comments = \Drupal::entityTypeManager()->getStorage('comment')
                ->loadByProperties([
                'uid' => $account->id(),
            ]);
            foreach ($comments as $comment) {
                $comment->setUnpublished();
                $comment->save();
            }
            break;
        case 'user_cancel_reassign':
            
            /** @var \Drupal\comment\CommentInterface[] $comments */
            $comments = \Drupal::entityTypeManager()->getStorage('comment')
                ->loadByProperties([
                'uid' => $account->id(),
            ]);
            foreach ($comments as $comment) {
                $langcodes = array_keys($comment->getTranslationLanguages());
                // For efficiency manually save the original comment before applying any
                // changes.
                $comment->original = clone $comment;
                foreach ($langcodes as $langcode) {
                    $comment_translated = $comment->getTranslation($langcode);
                    $comment_translated->setOwnerId(0);
                    $comment_translated->setAuthorName(\Drupal::config('user.settings')->get('anonymous'));
                }
                $comment->save();
            }
            break;
    }
}

/**
 * Implements hook_ENTITY_TYPE_predelete() for user entities.
 */
function comment_user_predelete($account) {
    $entity_query = \Drupal::entityQuery('comment')->accessCheck(FALSE);
    $entity_query->condition('uid', $account->id());
    $cids = $entity_query->execute();
    $comment_storage = \Drupal::entityTypeManager()->getStorage('comment');
    $comments = $comment_storage->loadMultiple($cids);
    $comment_storage->delete($comments);
}

/**
 * Generates a comment preview.
 *
 * @param \Drupal\comment\CommentInterface $comment
 *   The comment entity to preview.
 * @param Drupal\Core\Form\FormStateInterface $form_state
 *   The current state of the form.
 *
 * @return array
 *   An array as expected by \Drupal\Core\Render\RendererInterface::render().
 */
function comment_preview(CommentInterface $comment, FormStateInterface $form_state) {
    $preview_build = [];
    $entity = $comment->getCommentedEntity();
    if (!$form_state->getErrors()) {
        $comment->in_preview = TRUE;
        $comment_build = \Drupal::entityTypeManager()->getViewBuilder('comment')
            ->view($comment);
        $comment_build['#weight'] = -100;
        $preview_build['comment_preview'] = $comment_build;
    }
    if ($comment->hasParentComment()) {
        $build = [];
        $parent = $comment->getParentComment();
        if ($parent && $parent->isPublished()) {
            $build = \Drupal::entityTypeManager()->getViewBuilder('comment')
                ->view($parent);
        }
    }
    else {
        // The comment field output includes rendering the parent entity of the
        // thread to which the comment is a reply. The rendered entity output
        // includes the comment reply form, which contains the comment preview and
        // therefore the rendered parent entity. This results in an infinite loop of
        // parent entity output rendering the comment form and the comment form
        // rendering the parent entity. To prevent this infinite loop we temporarily
        // set the value of the comment field on a clone of the entity to hidden
        // before calling the entity view builder. That way when the output of
        // the commented entity is rendered, it excludes the comment field output.
        $field_name = $comment->getFieldName();
        $entity = clone $entity;
        $entity->{$field_name}->status = CommentItemInterface::HIDDEN;
        $build = \Drupal::entityTypeManager()->getViewBuilder($entity->getEntityTypeId())
            ->view($entity, 'full');
    }
    $preview_build['comment_output_below'] = $build;
    $preview_build['comment_output_below']['#weight'] = 200;
    return $preview_build;
}

/**
 * Implements hook_preprocess_HOOK() for block templates.
 */
function comment_preprocess_block(&$variables) {
    if ($variables['configuration']['provider'] == 'comment') {
        $variables['attributes']['role'] = 'navigation';
    }
}

/**
 * Prepares variables for comment templates.
 *
 * By default this function performs special preprocessing of some base fields
 * so they are available as variables in the template. For example 'subject'
 * appears as 'title'. 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().
 *
 * Default template: comment.html.twig.
 *
 * @param array $variables
 *   An associative array containing:
 *   - elements: An associative array containing the comment and entity objects.
 *     Array keys: #comment, #commented_entity.
 */
function template_preprocess_comment(&$variables) {
    
    /** @var \Drupal\Core\Datetime\DateFormatterInterface $date_formatter */
    $date_formatter = \Drupal::service('date.formatter');
    
    /** @var \Drupal\comment\CommentInterface $comment */
    $comment = $variables['elements']['#comment'];
    $commented_entity = $comment->getCommentedEntity();
    $variables['comment'] = $comment;
    $variables['commented_entity'] = $commented_entity;
    $variables['threaded'] = $variables['elements']['#comment_threaded'];
    $skip_custom_preprocessing = $comment->getEntityType()
        ->get('enable_base_field_custom_preprocess_skipping');
    // Make created, uid, pid and subject fields 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.
    $submitted_configurable = $comment->getFieldDefinition('created')
        ->isDisplayConfigurable('view') || $comment->getFieldDefinition('uid')
        ->isDisplayConfigurable('view');
    if (!$skip_custom_preprocessing || !$submitted_configurable) {
        $account = $comment->getOwner();
        $username = [
            '#theme' => 'username',
            '#account' => $account,
        ];
        $variables['author'] = \Drupal::service('renderer')->render($username);
        $variables['author_id'] = $comment->getOwnerId();
        $variables['new_indicator_timestamp'] = $comment->getChangedTime();
        $variables['created'] = $date_formatter->format($comment->getCreatedTime());
        // Avoid calling DateFormatterInterface::format() twice on the same timestamp.
        if ($comment->getChangedTime() == $comment->getCreatedTime()) {
            $variables['changed'] = $variables['created'];
        }
        else {
            $variables['changed'] = $date_formatter->format($comment->getChangedTime());
        }
        if (theme_get_setting('features.comment_user_picture')) {
            // To change user picture settings (for instance, image style), edit the
            // 'compact' view mode on the User entity.
            $variables['user_picture'] = \Drupal::entityTypeManager()->getViewBuilder('user')
                ->view($account, 'compact');
        }
        else {
            $variables['user_picture'] = [];
        }
        $variables['submitted'] = t('Submitted by @username on @datetime', [
            '@username' => $variables['author'],
            '@datetime' => $variables['created'],
        ]);
    }
    if (isset($comment->in_preview)) {
        $variables['permalink'] = Link::fromTextAndUrl(t('Permalink'), Url::fromRoute('<front>'))->toString();
    }
    else {
        $variables['permalink'] = Link::fromTextAndUrl(t('Permalink'), $comment->permalink())
            ->toString();
    }
    if (($comment_parent = $comment->getParentComment()) && (!$skip_custom_preprocessing || !$comment->getFieldDefinition('pid')
        ->isDisplayConfigurable('view'))) {
        // Fetch and store the parent comment information for use in templates.
        $account_parent = $comment_parent->getOwner();
        $variables['parent_comment'] = $comment_parent;
        $username = [
            '#theme' => 'username',
            '#account' => $account_parent,
        ];
        $variables['parent_author'] = \Drupal::service('renderer')->render($username);
        $variables['parent_created'] = $date_formatter->format($comment_parent->getCreatedTime());
        // Avoid calling DateFormatterInterface::format() twice on same timestamp.
        if ($comment_parent->getChangedTime() == $comment_parent->getCreatedTime()) {
            $variables['parent_changed'] = $variables['parent_created'];
        }
        else {
            $variables['parent_changed'] = $date_formatter->format($comment_parent->getChangedTime());
        }
        $permalink_uri_parent = $comment_parent->permalink();
        $attributes = $permalink_uri_parent->getOption('attributes') ?: [];
        $attributes += [
            'class' => [
                'permalink',
            ],
            'rel' => 'bookmark',
        ];
        $permalink_uri_parent->setOption('attributes', $attributes);
        $variables['parent_title'] = Link::fromTextAndUrl($comment_parent->getSubject(), $permalink_uri_parent)
            ->toString();
        $variables['parent_permalink'] = Link::fromTextAndUrl(t('Parent permalink'), $permalink_uri_parent)->toString();
        $variables['parent'] = t('In reply to @parent_title by @parent_username', [
            '@parent_username' => $variables['parent_author'],
            '@parent_title' => $variables['parent_title'],
        ]);
    }
    else {
        $variables['parent_comment'] = '';
        $variables['parent_author'] = '';
        $variables['parent_created'] = '';
        $variables['parent_changed'] = '';
        $variables['parent_title'] = '';
        $variables['parent_permalink'] = '';
        $variables['parent'] = '';
    }
    if (!$skip_custom_preprocessing || !$comment->getFieldDefinition('subject')
        ->isDisplayConfigurable('view')) {
        if (isset($comment->in_preview)) {
            $variables['title'] = Link::fromTextAndUrl($comment->getSubject(), Url::fromRoute('<front>'))
                ->toString();
        }
        else {
            $uri = $comment->permalink();
            $attributes = $uri->getOption('attributes') ?: [];
            $attributes += [
                'class' => [
                    'permalink',
                ],
                'rel' => 'bookmark',
            ];
            $uri->setOption('attributes', $attributes);
            $variables['title'] = Link::fromTextAndUrl($comment->getSubject(), $uri)
                ->toString();
        }
    }
    // Helpful $content variable for templates.
    foreach (Element::children($variables['elements']) as $key) {
        $variables['content'][$key] = $variables['elements'][$key];
    }
    // Set status to a string representation of comment->status.
    if (isset($comment->in_preview)) {
        $variables['status'] = 'preview';
    }
    else {
        $variables['status'] = $comment->isPublished() ? 'published' : 'unpublished';
    }
    // Add comment author user ID. Necessary for the comment-by-viewer library.
    $variables['attributes']['data-comment-user-id'] = $comment->getOwnerId();
    // Add anchor for each comment.
    $variables['attributes']['id'] = 'comment-' . $comment->id();
}

/**
 * Prepares variables for comment field templates.
 *
 * Default template: field--comment.html.twig.
 *
 * @param array $variables
 *   An associative array containing:
 *   - element: An associative array containing render arrays for the list of
 *     comments, and the comment form. Array keys: comments, comment_form.
 *
 * @todo Rename to template_preprocess_field__comment() once
 *   https://www.drupal.org/node/939462 is resolved.
 */
function comment_preprocess_field(&$variables) {
    $element = $variables['element'];
    if ($element['#field_type'] == 'comment') {
        // Provide contextual information.
        $variables['comment_display_mode'] = $element[0]['#comment_display_mode'];
        $variables['comment_type'] = $element[0]['#comment_type'];
        // Append additional attributes from the first field item.
        $variables['attributes'] += $variables['items'][0]['attributes']->storage();
        // Create separate variables for the comments and comment form.
        $variables['comments'] = $element[0]['comments'];
        $variables['comment_form'] = $element[0]['comment_form'];
    }
}

/**
 * Implements hook_ranking().
 */
function comment_ranking() {
    return \Drupal::service('comment.statistics')->getRankingInfo();
}

/**
 * Implements hook_ENTITY_TYPE_presave() for entity_view_display entities.
 */
function comment_entity_view_display_presave(EntityViewDisplayInterface $display) {
    // Act only on comment view displays being disabled.
    if ($display->isNew() || $display->getTargetEntityTypeId() !== 'comment' || $display->status()) {
        return;
    }
    $storage = \Drupal::entityTypeManager()->getStorage('entity_view_display');
    if (!$storage->loadUnchanged($display->getOriginalId())
        ->status()) {
        return;
    }
    // Disable the comment field formatter when the used view display is disabled.
    foreach ($storage->loadMultiple() as $view_display) {
        $changed = FALSE;
        
        /** @var \Drupal\Core\Entity\Display\EntityViewDisplayInterface $view_display */
        foreach ($view_display->getComponents() as $field => $component) {
            if (isset($component['type']) && $component['type'] === 'comment_default') {
                if ($component['settings']['view_mode'] === $display->getMode()) {
                    $view_display->removeComponent($field);
                    
                    /** @var \Drupal\Core\Entity\EntityViewModeInterface $mode */
                    $mode = EntityViewMode::load($display->getTargetEntityTypeId() . '.' . $display->getMode());
                    $arguments = [
                        '@id' => $view_display->id(),
                        '@name' => $field,
                        '@display' => $mode->label(),
                        '@mode' => $display->getMode(),
                    ];
                    \Drupal::logger('system')->warning("View display '@id': Comment field formatter '@name' was disabled because it is using the comment view display '@display' (@mode) that was just disabled.", $arguments);
                    $changed = TRUE;
                }
            }
        }
        if ($changed) {
            $view_display->save();
        }
    }
}

/**
 * Implements hook_field_type_category_info_alter().
 */
function comment_field_type_category_info_alter(&$definitions) {
    // The `comment` field type belongs in the `general` category, so the
    // libraries need to be attached using an alter hook.
    $definitions[FieldTypeCategoryManagerInterface::FALLBACK_CATEGORY]['libraries'][] = 'comment/drupal.comment-icon';
}

Functions

Title Deprecated Summary
comment_cron Implements hook_cron().
comment_entity_extra_field_info Implements hook_entity_extra_field_info().
comment_entity_insert Implements hook_entity_insert().
comment_entity_predelete Implements hook_entity_predelete().
comment_entity_storage_load Implements hook_entity_storage_load().
comment_entity_view Implements hook_entity_view().
comment_entity_view_display_presave Implements hook_ENTITY_TYPE_presave() for entity_view_display entities.
comment_field_config_create Implements hook_ENTITY_TYPE_create() for 'field_config'.
comment_field_config_delete Implements hook_ENTITY_TYPE_delete() for 'field_config'.
comment_field_config_update Implements hook_ENTITY_TYPE_update() for 'field_config'.
comment_field_info_entity_type_ui_definitions_alter Implements hook_field_info_entity_type_ui_definitions_alter().
comment_field_storage_config_insert Implements hook_ENTITY_TYPE_insert() for 'field_storage_config'.
comment_field_type_category_info_alter Implements hook_field_type_category_info_alter().
comment_form_field_ui_display_overview_form_alter Implements hook_form_FORM_ID_alter().
comment_form_field_ui_field_storage_add_form_alter Implements hook_form_FORM_ID_alter() for field_ui_field_storage_add_form.
comment_form_field_ui_form_display_overview_form_alter Implements hook_form_FORM_ID_alter().
comment_help Implements hook_help().
comment_node_links_alter Implements hook_node_links_alter().
comment_node_search_result Implements hook_node_search_result().
comment_node_update_index Implements hook_node_update_index().
comment_node_view_alter Implements hook_ENTITY_TYPE_view_alter() for node entities.
comment_preprocess_block Implements hook_preprocess_HOOK() for block templates.
comment_preprocess_field Prepares variables for comment field templates.
comment_preview Generates a comment preview.
comment_ranking Implements hook_ranking().
comment_theme Implements hook_theme().
comment_uri Entity URI callback.
comment_user_cancel Implements hook_user_cancel().
comment_user_predelete Implements hook_ENTITY_TYPE_predelete() for user entities.
template_preprocess_comment Prepares variables for comment templates.
_comment_entity_uses_integer_id Determines if an entity type is using an integer-based ID definition.

Constants

Title Deprecated Summary
COMMENT_NEW_LIMIT The time cutoff for comments marked as read for entity types other node.

Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.