comment.module

<?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';
}