Skip to content
Snippets Groups Projects
Select Git revision
  • 2da508579c6a30f8e51b1cbeaeea45f88cce4034
  • 11.x default protected
  • 11.2.x protected
  • 10.5.x protected
  • 10.6.x protected
  • 11.1.x protected
  • 10.4.x protected
  • 11.0.x protected
  • 10.3.x protected
  • 7.x protected
  • 10.2.x protected
  • 10.1.x protected
  • 9.5.x protected
  • 10.0.x protected
  • 9.4.x protected
  • 9.3.x protected
  • 9.2.x protected
  • 9.1.x protected
  • 8.9.x protected
  • 9.0.x protected
  • 8.8.x protected
  • 10.5.1 protected
  • 11.2.2 protected
  • 11.2.1 protected
  • 11.2.0 protected
  • 10.5.0 protected
  • 11.2.0-rc2 protected
  • 10.5.0-rc1 protected
  • 11.2.0-rc1 protected
  • 10.4.8 protected
  • 11.1.8 protected
  • 10.5.0-beta1 protected
  • 11.2.0-beta1 protected
  • 11.2.0-alpha1 protected
  • 10.4.7 protected
  • 11.1.7 protected
  • 10.4.6 protected
  • 11.1.6 protected
  • 10.3.14 protected
  • 10.4.5 protected
  • 11.0.13 protected
41 results

comment.module

Blame
  • Dries's avatar
    Issue #2285349 by olli: Fixed Fatal error: Call to a member function getType()...
    Dries Buytaert authored
    Issue #2285349 by olli: Fixed Fatal error: Call to a member function getType() on a non-object in comment.module on line 951.
    2da50857
    History
    Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    comment.module 53.31 KiB
    <?php
    
    /**
     * @file
     * Enables users to comment on published content.
     *
     * When enabled, 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 forum topic, story, collaborative
     * book page, user etc.
     */
    
    use Drupal\comment\CommentInterface;
    use Drupal\comment\Entity\Comment;
    use Drupal\comment\Entity\CommentType;
    use Drupal\comment\Plugin\Field\FieldType\CommentItemInterface;
    use Drupal\Component\Utility\String;
    use Drupal\Core\Entity\ContentEntityInterface;
    use Drupal\Core\Entity\EntityInterface;
    use Drupal\entity\Entity\EntityViewDisplay;
    use Drupal\Core\Entity\Display\EntityViewDisplayInterface;
    use Drupal\Core\Field\FieldDefinitionInterface;
    use Drupal\Core\Render\Element;
    use Drupal\Core\Url;
    use Drupal\field\Entity\FieldConfig;
    use Drupal\field\FieldInstanceConfigInterface;
    use Drupal\field\FieldConfigInterface;
    use Drupal\file\FileInterface;
    use Drupal\user\EntityOwnerInterface;
    use Drupal\node\NodeInterface;
    use Symfony\Component\HttpFoundation\Request;
    
    /**
     * Comments are displayed in a flat list - expanded.
     */
    const COMMENT_MODE_FLAT = 0;
    
    /**
     * Comments are displayed as a threaded list - expanded.
     */
    const COMMENT_MODE_THREADED = 1;
    
    /**
     * Anonymous posters cannot enter their contact information.
     */
    const COMMENT_ANONYMOUS_MAYNOT_CONTACT = 0;
    
    /**
     * Anonymous posters may leave their contact information.
     */
    const COMMENT_ANONYMOUS_MAY_CONTACT = 1;
    
    /**
     * Anonymous posters are required to leave their contact information.
     */
    const COMMENT_ANONYMOUS_MUST_CONTACT = 2;
    
    /**
     * Comment form should be displayed on a separate page.
     */
    const COMMENT_FORM_SEPARATE_PAGE = 0;
    
    /**
     * Comment form should be shown below post or list of comments.
     */
    const COMMENT_FORM_BELOW = 1;
    
    /**
     * 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 http://drupal.org/node/1029708 lands.
     */
    define('COMMENT_NEW_LIMIT', REQUEST_TIME - 30 * 24 * 60 * 60);
    
    /**
     * Implements hook_help().
     */
    function comment_help($route_name, Request $request) {
      switch ($route_name) {
        case 'help.page.comment':
          $output = '<h3>' . t('About') . '</h3>';
          $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>.', array('!comment' => 'https://drupal.org/documentation/modules/comment')) . '</p>';
          $output .= '<h3>' . t('Uses') . '</h3>';
          $output .= '<dl>';
          $output .= '<dt>' . t('Enabling commenting and configuring defaults') . '</dt>';
          $output .= '<dd>' . t('Comment functionality can be enabled for any <a href="!entity-help" title="Entity module help">entity sub-type</a> (for example, a <a href="!content-type">content type</a>). On the Manage fields page for each entity sub-type, you can enable commenting by adding a Comments field. The entity sub-types each have their own default comment settings 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.', array('!content-type' => \Drupal::url('node.overview_types'), '!entity-help' => \Drupal::url('help.page', array('name' => 'entity')))) . '</dd>';
          $output .= '<dt>' . t('Overriding default settings') . '</dt>';
          $output .= '<dd>' . t('When you create an entity item, you can override the default comment settings. Changing the entity sub-type defaults will not affect existing entity items, whether they used the default settings or had overrides.') . '</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.', array('!comment-approval' => \Drupal::url('comment.admin_approval'), '!admin-comment' => \Drupal::url('comment.admin'))) . '</dd>';
          $output .= '</dl>';
          return $output;
    
        case 'comment.type_list':
          $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(
        'comment.permalink',
        array(
          'comment' => $comment->id(),
        ),
        array('fragment' => 'comment-' . $comment->id())
      );
    }
    
    /**
     * Implements hook_entity_extra_field_info().
     */
    function comment_entity_extra_field_info() {
      $return = array();
      foreach (CommentType::loadMultiple() as $comment_type) {
        $return['comment'][$comment_type->id()] = array(
          'form' => array(
            'author' => array(
              'label' => t('Author'),
              'description' => t('Author textfield'),
              'weight' => -2,
            ),
            'subject' => array(
              'label' => t('Subject'),
              'description' => t('Subject textfield'),
              'weight' => -1,
            ),
          ),
        );
      }
    
      return $return;
    }
    
    /**
     * Implements hook_theme().
     */
    function comment_theme() {
      return array(
        'comment' => array(
          'render element' => 'elements',
          'template' => 'comment',
        ),
        'comment_wrapper' => array(
          'render element' => 'content',
          'template' => 'comment-wrapper',
        ),
      );
    }
    
    /**
     * Returns a menu title which includes the number of unapproved comments.
     *
     * @todo Move to the comment manager and replace by a entity query?
     */
    function comment_count_unpublished() {
      $count = db_query('SELECT COUNT(cid) FROM {comment} WHERE status = :status', array(
        ':status' => CommentInterface::NOT_PUBLISHED,
      ))->fetchField();
      return t('Unapproved comments (@count)', array('@count' => $count));
    }
    
    /**
     * Implements hook_ENTITY_TYPE_create() for 'field_instance_config'.
     */
    function comment_field_instance_config_create(FieldInstanceConfigInterface $instance) {
      if ($instance->getType() == 'comment' && !$instance->isSyncing()) {
        // Assign default values for the field instance.
        if (!isset($instance->default_value)) {
          $instance->default_value = array();
        }
        $instance->default_value += array(array());
        $instance->default_value[0] += array(
          'status' => CommentItemInterface::OPEN,
          'cid' => 0,
          'last_comment_timestamp' => 0,
          'last_comment_name' => '',
          'last_comment_uid' => 0,
          'comment_count' => 0,
        );
      }
    }
    
    /**
     * Implements hook_ENTITY_TYPE_update() for 'field_instance_config'.
     */
    function comment_field_instance_config_update(FieldInstanceConfigInterface $instance) {
      if ($instance->getType() == 'comment') {
        // Comment field settings also affects the rendering of *comment* entities,
        // not only the *commented* entities.
        \Drupal::entityManager()->getViewBuilder('comment')->resetCache();
      }
    }
    
    /**
     * Implements hook_ENTITY_TYPE_insert() for 'field_config'.
     */
    function comment_field_config_insert(FieldConfigInterface $field) {
      if ($field->getType() == 'comment') {
        // Check that the target entity type uses an integer ID.
        $entity_type_id = $field->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_instance_config'.
     */
    function comment_field_instance_config_delete(FieldInstanceConfigInterface $instance) {
      if ($instance->getType() == 'comment') {
        // Delete all comments that used by the entity bundle.
        $comments = db_query("SELECT cid FROM {comment} WHERE entity_type = :entity_type AND field_name = :field_name", array(
          ':entity_type' => $instance->getEntityTypeId(),
          ':field_name' => $instance->getName(),
        ))->fetchCol();
        entity_delete_multiple('comment', $comments);
      }
    }
    
    /**
     * Implements hook_permission().
     */
    function comment_permission() {
      return array(
        'administer comments' => array(
          'title' => t('Administer comments and comment settings'),
        ),
        'administer comment types' => array(
          'title' => t('Administer comment types and settings'),
          'restrict access' => TRUE,
        ),
        'access comments' => array(
          'title' => t('View comments'),
        ),
        'post comments' => array(
          'title' => t('Post comments'),
        ),
        'skip comment approval' => array(
          'title' => t('Skip comment approval'),
        ),
        'edit own comments' => array(
          'title' => t('Edit own comments'),
        ),
      );
    }
    
    /**
     * Calculates the page number for the first new comment.
     *
     * @param int $num_comments
     *   Number of comments.
     * @param int $new_replies
     *   Number of new replies.
     * @param \Drupal\Core\Entity\ContentEntityInterface $entity
     *   The first new comment entity.
     * @param string $field_name
     *   The field name on the entity to which comments are attached to.
     *
     * @return array|null
     *   An array "page=X" if the page number is greater than zero; NULL otherwise.
     */
    function comment_new_page_count($num_comments, $new_replies, ContentEntityInterface $entity, $field_name = 'comment') {
      $field_definition = $entity->getFieldDefinition($field_name);
      $mode = $field_definition->getSetting('default_mode');
      $comments_per_page = $field_definition->getSetting('per_page');
      $pagenum = NULL;
      $flat = $mode == COMMENT_MODE_FLAT ? TRUE : FALSE;
      if ($num_comments <= $comments_per_page) {
        // Only one page of comments.
        $pageno = 0;
      }
      elseif ($flat) {
        // Flat comments.
        $count = $num_comments - $new_replies;
        $pageno = $count / $comments_per_page;
      }
      else {
        // Threaded comments: we build a query with a subquery to find the first
        // thread with a new comment.
    
        // 1. Find all the threads with a new comment.
        $unread_threads_query = db_select('comment')
          ->fields('comment', array('thread'))
          ->condition('entity_id', $entity->id())
          ->condition('entity_type', $entity->getEntityTypeId())
          ->condition('field_name', $field_name)
          ->condition('status', CommentInterface::PUBLISHED)
          ->orderBy('created', 'DESC')
          ->orderBy('cid', 'DESC')
          ->range(0, $new_replies);
    
        // 2. Find the first thread.
        $first_thread_query = db_select($unread_threads_query, 'thread');
        $first_thread_query->addExpression('SUBSTRING(thread, 1, (LENGTH(thread) - 1))', 'torder');
        $first_thread = $first_thread_query
          ->fields('thread', array('thread'))
          ->orderBy('torder')
          ->range(0, 1)
          ->execute()
          ->fetchField();
    
        // Remove the final '/'.
        $first_thread = substr($first_thread, 0, -1);
    
        // Find the number of the first comment of the first unread thread.
        $count = db_query('SELECT COUNT(*) FROM {comment} WHERE entity_id = :entity_id
                          AND entity_type = :entity_type
                          AND field_name = :field_name
                          AND status = :status AND SUBSTRING(thread, 1, (LENGTH(thread) - 1)) < :thread', array(
          ':status' => CommentInterface::PUBLISHED,
          ':entity_id' => $entity->id(),
          ':field_name' => $field_name,
          ':entity_type' => $entity->getEntityTypeId(),
          ':thread' => $first_thread,
        ))->fetchField();
    
        $pageno = $count / $comments_per_page;
      }
    
      if ($pageno >= 1) {
        $pagenum = array('page' => intval($pageno));
      }
    
      return $pagenum;
    }
    
    /**
     * Implements hook_entity_build_defaults_alter().
     */
    function comment_entity_build_defaults_alter(array &$build, EntityInterface $entity, $view_mode = 'full', $langcode = NULL) {
      // Get the corresponding display settings.
      $display = EntityViewDisplay::collectRenderDisplay($entity, $view_mode);
      // Add the comment page number to the cache key if render caching is enabled.
      if (isset($build['#cache']) && isset($build['#cache']['keys']) && \Drupal::request()->query->has('page')) {
        foreach ($entity->getFieldDefinitions() as $field_name => $definition) {
          if ($definition->getType() === 'comment' && ($display_options = $display->getComponent($field_name))) {
            $pager_id = $display_options['settings']['pager_id'];
            $page = pager_find_page($pager_id);
            $build['#cache']['keys'][] = $field_name . '-pager-' . $page;
          }
        }
      }
      return $build;
    }
    
    /**
     * Implements hook_node_links_alter().
     */
    function comment_node_links_alter(array &$node_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
      //   http://drupal.org/node/1901110
    
      $view_mode = $context['view_mode'];
      if ($view_mode == 'search_index' || $view_mode == 'search_result' || $view_mode == 'print') {
        // Do not add any links if the node displayed for:
        // - search indexing.
        // - constructing a search result excerpt.
        // - print.
        return;
      }
    
      $fields = \Drupal::service('comment.manager')->getFields('node');
      foreach ($fields as $field_name => $detail) {
        // Skip fields that the node does not have.
        if (!$node->hasField($field_name)) {
          continue;
        }
        $links = array();
        $commenting_status = $node->get($field_name)->status;
        if ($commenting_status) {
          $field_definition = $node->getFieldDefinition($field_name);
          // Node have commenting open or close.
          if ($view_mode == 'rss') {
            // Add a comments RSS element which is a URL to the comments of this node.
            $options = array(
              'fragment' => 'comments',
              'absolute' => TRUE,
            );
            $node->rss_elements[] = array(
              'key' => 'comments',
              'value' => $node->url('canonical', $options),
            );
          }
          elseif ($view_mode == 'teaser') {
            // Teaser view: display the number of comments that have been posted,
            // or a link to add new comments if the user has permission, the node
            // is open to new comments, and there currently are none.
            if (user_access('access comments')) {
              if (!empty($node->get($field_name)->comment_count)) {
                $links['comment-comments'] = array(
                  'title' => format_plural($node->get($field_name)->comment_count, '1 comment', '@count comments'),
                  'attributes' => array('title' => t('Jump to the first comment of this posting.')),
                  'fragment' => 'comments',
                  'html' => TRUE,
                ) + $node->urlInfo()->toArray();
                if (\Drupal::moduleHandler()->moduleExists('history')) {
                  $links['comment-new-comments'] = array(
                    'title' => '',
                    'href' => '',
                    'attributes' => array(
                      'class' => 'hidden',
                      'title' => t('Jump to the first new comment of this posting.'),
                      'data-history-node-last-comment-timestamp' => $node->get($field_name)->last_comment_timestamp,
                      'data-history-node-field-name' => $field_name,
                    ),
                    'html' => TRUE,
                  );
                }
              }
            }
            // Provide a link to new comment form.
            if ($commenting_status == CommentItemInterface::OPEN) {
              $comment_form_location = $field_definition->getSetting('form_location');
              if (user_access('post comments')) {
                $links['comment-add'] = array(
                  'title' => t('Add new comment'),
                  'language' => $node->language(),
                  'attributes' => array('title' => t('Add a new comment to this page.')),
                  'fragment' => 'comment-form',
                );
                if ($comment_form_location == COMMENT_FORM_SEPARATE_PAGE) {
                  $links['comment-add']['route_name'] = 'comment.reply';
                  $links['comment-add']['route_parameters'] = array(
                    'entity_type' => $node->getEntityTypeId(),
                    'entity_id' => $node->id(),
                    'field_name' => $field_name,
                  );
                }
                else {
                  $links['comment-add'] += $node->urlInfo()->toArray();
                }
              }
              elseif (\Drupal::currentUser()->isAnonymous()) {
                $links['comment-forbidden'] = array(
                  'title' => \Drupal::service('comment.manager')->forbiddenMessage($node, $field_name),
                  'html' => TRUE,
                );
              }
            }
          }
          else {
            // Node in other view modes: add a "post comment" link if the user is
            // allowed to post comments and if this node is allowing new comments.
            if ($commenting_status == CommentItemInterface::OPEN) {
              $comment_form_location = $field_definition->getSetting('form_location');
              if (user_access('post comments')) {
                // Show the "post comment" link if the form is on another page, or
                // if there are existing comments that the link will skip past.
                if ($comment_form_location == COMMENT_FORM_SEPARATE_PAGE || (!empty($node->get($field_name)->comment_count) && user_access('access comments'))) {
                  $links['comment-add'] = array(
                    'title' => t('Add new comment'),
                    'attributes' => array('title' => t('Share your thoughts and opinions related to this posting.')),
                    'fragment' => 'comment-form',
                  );
                  if ($comment_form_location == COMMENT_FORM_SEPARATE_PAGE) {
                    $links['comment-add']['route_name'] = 'comment.reply';
                    $links['comment-add']['route_parameters'] = array(
                      'entity_type' => $node->getEntityTypeId(),
                      'entity_id' => $node->id(),
                      'field_name' => $field_name,
                    );
                  }
                  else {
                    $links['comment-add'] += $node->urlInfo()->toArray();
                  }
                }
              }
              elseif (\Drupal::currentUser()->isAnonymous()) {
                $links['comment-forbidden'] = array(
                  'title' => \Drupal::service('comment.manager')->forbiddenMessage($node, $field_name),
                  'html' => TRUE,
                );
              }
            }
          }
        }
    
        if (!empty($links)) {
          $node_links['comment__' . $field_name] = array(
            '#theme' => 'links__entity__comment__' . $field_name,
            '#links' => $links,
            '#attributes' => array('class' => array('links', 'inline')),
          );
          if ($view_mode == 'teaser' && \Drupal::moduleHandler()->moduleExists('history') && \Drupal::currentUser()->isAuthenticated()) {
            $node_links['comment__' . $field_name]['#attached']['library'][] = 'comment/drupal.node-new-comments-link';
    
            // Embed the metadata for the "X new comments" link (if any) on this node.
            $node_links['comment__' . $field_name]['#post_render_cache']['history_attach_timestamp'] = array(
              array('node_id' => $node->id()),
            );
            $node_links['comment__' . $field_name]['#post_render_cache']['Drupal\comment\CommentViewBuilder::attachNewCommentsLinkMetadata'] = array(
              array('entity_type' => $node->getEntityTypeId(), 'entity_id' => $node->id(), 'field_name' => $field_name),
            );
          }
        }
      }
    }
    
    /**
     * Implements hook_node_view_alter().
     */
    function comment_node_view_alter(array &$build, EntityInterface $node, EntityViewDisplayInterface $display) {
      if (\Drupal::moduleHandler()->moduleExists('history')) {
        $build['#attributes']['data-history-node-id'] = $node->id();
      }
    }
    
    /**
     * Returns a rendered form to comment the given entity.
     *
     * @param \Drupal\Core\Entity\EntityInterface $entity
     *   The entity to which the comments are in reply to.
     * @param string $field_name
     *   The field name where the comments were entered.
     * @param int $pid
     *   (optional) Some comments are replies to other comments. In those cases,
     *   $pid is the parent comment's comment ID. Defaults to NULL.
     *
     * @return array
     *   The renderable array for the comment addition form.
     */
    function comment_add(EntityInterface $entity, $field_name = 'comment', $pid = NULL) {
      $field = Fieldconfig::loadByName($entity->getEntityTypeId(), $field_name);
      $values = array(
        'entity_type' => $entity->getEntityTypeId(),
        'entity_id' => $entity->id(),
        'field_name' => $field_name,
        'comment_type' => $field->getSetting('bundle'),
        'pid' => $pid,
      );
      $comment = entity_create('comment', $values);
      return \Drupal::service('entity.form_builder')->getForm($comment);
    }
    
    /**
     * Retrieves comments for a thread.
     *
     * @param \Drupal\Core\Entity\EntityInterface $entity
     *   The entity whose comment(s) needs rendering.
     * @param string $field_name
     *   The field_name whose comment(s) needs rendering.
     * @param int $mode
     *   The comment display mode; COMMENT_MODE_FLAT or COMMENT_MODE_THREADED.
     * @param int $comments_per_page
     *   The amount of comments to display per page.
     * @param int $pager_id
     *   (optional) Pager id to use in case of multiple pagers on the one page.
     *   Defaults to 0.
     *
     * @return int[]
     *   An array of the IDs of the comment to be displayed.
     *
     * To display threaded comments in the correct order we keep a 'thread' field
     * and order by that value. This field keeps this data in
     * a way which is easy to update and convenient to use.
     *
     * A "thread" value starts at "1". If we add a child (A) to this comment,
     * we assign it a "thread" = "1.1". A child of (A) will have "1.1.1". Next
     * brother of (A) will get "1.2". Next brother of the parent of (A) will get
     * "2" and so on.
     *
     * First of all note that the thread field stores the depth of the comment:
     * depth 0 will be "X", depth 1 "X.X", depth 2 "X.X.X", etc.
     *
     * Now to get the ordering right, consider this example:
     *
     * 1
     * 1.1
     * 1.1.1
     * 1.2
     * 2
     *
     * If we "ORDER BY thread ASC" we get the above result, and this is the
     * natural order sorted by time. However, if we "ORDER BY thread DESC"
     * we get:
     *
     * 2
     * 1.2
     * 1.1.1
     * 1.1
     * 1
     *
     * Clearly, this is not a natural way to see a thread, and users will get
     * confused. The natural order to show a thread by time desc would be:
     *
     * 2
     * 1
     * 1.2
     * 1.1
     * 1.1.1
     *
     * which is what we already did before the standard pager patch. To achieve
     * this we simply add a "/" at the end of each "thread" value. This way, the
     * thread fields will look like this:
     *
     * 1/
     * 1.1/
     * 1.1.1/
     * 1.2/
     * 2/
     *
     * we add "/" since this char is, in ASCII, higher than every number, so if
     * now we "ORDER BY thread DESC" we get the correct order. However this would
     * spoil the reverse ordering, "ORDER BY thread ASC" -- here, we do not need
     * to consider the trailing "/" so we use a substring only.
     */
    function comment_get_thread(EntityInterface $entity, $field_name, $mode, $comments_per_page, $pager_id = 0) {
      $query = db_select('comment', 'c')
        ->extend('Drupal\Core\Database\Query\PagerSelectExtender');
      if ($pager_id) {
        $query->element($pager_id);
      }
      $query->addField('c', 'cid');
      $query
        ->condition('c.entity_id', $entity->id())
        ->condition('c.entity_type', $entity->getEntityTypeId())
        ->condition('c.field_name', $field_name)
        ->addTag('entity_access')
        ->addTag('comment_filter')
        ->addMetaData('base_table', 'comment')
        ->addMetaData('entity', $entity)
        ->addMetaData('field_name', $field_name)
        ->limit($comments_per_page);
    
      $count_query = db_select('comment', 'c');
      $count_query->addExpression('COUNT(*)');
      $count_query
        ->condition('c.entity_id', $entity->id())
        ->condition('c.entity_type', $entity->getEntityTypeId())
        ->condition('c.field_name', $field_name)
        ->addTag('entity_access')
        ->addTag('comment_filter')
        ->addMetaData('base_table', 'comment')
        ->addMetaData('entity', $entity)
        ->addMetaData('field_name', $field_name);
    
      if (!user_access('administer comments')) {
        $query->condition('c.status', CommentInterface::PUBLISHED);
        $count_query->condition('c.status', CommentInterface::PUBLISHED);
      }
      if ($mode == COMMENT_MODE_FLAT) {
        $query->orderBy('c.cid', 'ASC');
      }
      else {
        // See comment above. Analysis reveals that this doesn't cost too
        // much. It scales much much better than having the whole comment
        // structure.
        $query->addExpression('SUBSTRING(c.thread, 1, (LENGTH(c.thread) - 1))', 'torder');
        $query->orderBy('torder', 'ASC');
      }
    
      $query->setCountQuery($count_query);
      return $query->execute()->fetchCol();
    }
    
    /**
     * Calculates the indentation level of each comment in a comment thread.
     *
     * This function loops over an array representing a comment thread. For each
     * comment, the function calculates the indentation level and saves it in the
     * 'divs' property of the comment object.
     *
     * @param array $comments
     *   An array of comment objects, keyed by comment ID.
     */
    function comment_prepare_thread(&$comments) {
      // A counter that helps track how indented we are.
      $divs = 0;
    
      foreach ($comments as $key => &$comment) {
        // The $divs element instructs #prefix whether to add an indent div or
        // close existing divs (a negative value).
        $comment->depth = count(explode('.', $comment->getThread())) - 1;
        if ($comment->depth > $divs) {
          $comment->divs = 1;
          $divs++;
        }
        else {
          $comment->divs = $comment->depth - $divs;
          while ($comment->depth < $divs) {
            $divs--;
          }
        }
      }
    
      // The final comment must close up some hanging divs
      $comments[$key]->divs_final = $divs;
    }
    
    /**
     * Generates an array for rendering a comment.
     *
     * @param \Drupal\comment\CommentInterface $comment
     *   The comment object.
     * @param $view_mode
     *   (optional) View mode, e.g. 'full', 'teaser'... Defaults to 'full'.
     * @param $langcode
     *   (optional) A language code to use for rendering. Defaults to the global
     *   content language of the current request.
     *
     * @return array
     *   An array as expected by drupal_render().
     */
    function comment_view(CommentInterface $comment, $view_mode = 'full', $langcode = NULL) {
      return entity_view($comment, $view_mode, $langcode);
    }
    
    /**
     * Constructs render array from an array of loaded comments.
     *
     * @param $comments
     *   An array of comments as returned by entity_load_multiple().
     * @param $view_mode
     *   View mode, e.g. 'full', 'teaser'...
     * @param $langcode
     *   (optional) A string indicating the language field values are to be shown
     *   in. If no language is provided the current content language is used.
     *   Defaults to NULL.
     *
     * @return array
     *   An array in the format expected by drupal_render().
     *
     * @see drupal_render()
     */
    function comment_view_multiple($comments, $view_mode = 'full', $langcode = NULL) {
      return entity_view_multiple($comments, $view_mode, $langcode);
    }
    
    /**
     * Implements hook_form_FORM_ID_alter().
     */
    function comment_form_field_ui_field_overview_form_alter(&$form, $form_state) {
      $request = \Drupal::request();
      if ($form['#entity_type'] == 'comment' && $request->attributes->has('commented_entity_type')) {
        $form['#title'] = \Drupal::service('comment.manager')->getFieldUIPageTitle($request->attributes->get('commented_entity_type'), $request->attributes->get('field_name'));
      }
      $entity_type_id = $form['#entity_type'];
      if (!_comment_entity_uses_integer_id($entity_type_id)) {
        // You cannot use comment fields on entity types with non-integer IDs.
        unset($form['fields']['_add_new_field']['type']['#options']['comment']);
      }
    }
    
    /**
     * Implements hook_form_FORM_ID_alter().
     */
    function comment_form_field_ui_form_display_overview_form_alter(&$form, $form_state) {
      $request = \Drupal::request();
      if ($form['#entity_type'] == 'comment' && $request->attributes->has('commented_entity_type')) {
        $form['#title'] = \Drupal::service('comment.manager')->getFieldUIPageTitle($request->attributes->get('commented_entity_type'), $request->attributes->get('field_name'));
      }
    }
    
    /**
     * Implements hook_form_FORM_ID_alter().
     */
    function comment_form_field_ui_display_overview_form_alter(&$form, $form_state) {
      $request = \Drupal::request();
      if ($form['#entity_type'] == 'comment' && $request->attributes->has('commented_entity_type')) {
        $form['#title'] = \Drupal::service('comment.manager')->getFieldUIPageTitle($request->attributes->get('commented_entity_type'), $request->attributes->get('field_name'));
      }
    }
    
    /**
     * Implements hook_form_FORM_ID_alter().
     */
    function comment_form_field_ui_field_edit_form_alter(&$form, $form_state) {
      if ($form['#field']->getType() == 'comment') {
        // We only support posting one comment at the time so it doesn't make sense
        // to let the site builder choose anything else.
        $form['field']['cardinality_container']['cardinality']['#options'] = array(1 => 1);
        $form['field']['cardinality_container']['#access'] = FALSE;
      }
    }
    
    /**
     * Implements hook_entity_load().
     *
     * @see \Drupal\comment\Plugin\Field\FieldType\CommentItem::propertyDefinitions()
     */
    function comment_entity_load($entities, $entity_type) {
      // Comments can only be attached to content entities, so skip others.
      if (!\Drupal::entityManager()->getDefinition($entity_type)->isSubclassOf('Drupal\Core\Entity\ContentEntityInterface')) {
        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->getEntityType()->isFieldable() && is_numeric($entity->id())) {
        $cids = db_select('comment', 'c')
          ->fields('c', array('cid'))
          ->condition('entity_id', (int) $entity->id())
          ->condition('entity_type', $entity->getEntityTypeId())
          ->execute()
          ->fetchCol();
        entity_delete_multiple('comment', $cids);
        \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::entityManager()->getDefinition($entity_type_id);
      $entity_type_id_key = $entity_type->getKey('id');
      if ($entity_type_id_key === FALSE) {
        return FALSE;
      }
      $field_definitions = \Drupal::entityManager()->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, $langcode) {
      $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::entityManager()->getStorage('user_role')->loadMultiple();
        $authenticated_can_access = $roles[DRUPAL_AUTHENTICATED_RID]->hasPermission('access comments');
        foreach ($roles as $rid => $role) {
          if ($role->hasPermission('search content') && !$role->hasPermission('access comments')) {
            if ($rid == DRUPAL_AUTHENTICATED_RID || $rid == DRUPAL_ANONYMOUS_RID || !$authenticated_can_access) {
              $index_comments = FALSE;
              break;
            }
          }
        }
      }
    
      $return = '';
    
      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 && $cids = comment_get_thread($node, $field_name, $mode, $comments_per_page)) {
            $comments = entity_load_multiple('comment', $cids);
            comment_prepare_thread($comments);
            $build = comment_view_multiple($comments);
            $return .= drupal_render($build);
          }
        }
      }
      return $return;
    }
    
    /**
     * 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 array('comment' => format_plural($comments, '1 comment', '@count comments'));
      }
    }
    
    /**
     * Implements hook_user_cancel().
     */
    function comment_user_cancel($edit, $account, $method) {
      switch ($method) {
        case 'user_cancel_block_unpublish':
          $comments = entity_load_multiple_by_properties('comment', array('uid' => $account->id()));
          foreach ($comments as $comment) {
            $comment->setPublished(CommentInterface::NOT_PUBLISHED);
            $comment->save();
          }
          break;
    
        case 'user_cancel_reassign':
          /** @var \Drupal\comment\CommentInterface[] $comments */
          $comments = entity_load_multiple_by_properties('comment', array('uid' => $account->id()));
          foreach ($comments as $comment) {
            $comment->setOwnerId(0);
            $comment->save();
          }
          break;
      }
    }
    
    /**
     * Implements hook_user_predelete().
     */
    function comment_user_predelete($account) {
      $cids = db_query('SELECT c.cid FROM {comment} c WHERE uid = :uid', array(':uid' => $account->id()))->fetchCol();
      entity_delete_multiple('comment', $cids);
    }
    
    /**
     * Loads comment entities from the database.
     *
     * @deprecated in Drupal 8.x, will be removed before Drupal 9.0.
     *   Use \Drupal\comment\Entity\Comment::loadMultiple().
     *
     * @param array $cids
     *   (optional) An array of entity IDs. If omitted, all entities are loaded.
     * @param bool $reset
     *   (optional) Whether to reset the internal static entity cache.
     *
     * @return array
     *   An array of comment objects, indexed by comment ID.
     *
     * @see entity_load()
     * @see \Drupal\Core\Entity\Query\QueryInterface
     */
    function comment_load_multiple(array $cids = NULL, $reset = FALSE) {
      if ($reset) {
        \Drupal::entityManager()->getStorage('comment')->resetCache($cids);
      }
      return Comment::loadMultiple($cids);
    }
    
    /**
     * Loads the entire comment by comment ID.
     *
     * @param int $cid
     *   The ID of the comment to be loaded.
     * @param bool $reset
     *   (optional) Whether to reset the internal static entity cache.
     *
     * @return \Drupal\comment\CommentInterface
     *   The comment object.
     *
     * @deprecated in Drupal 8.x, will be removed before Drupal 9.0.
     *   Use \Drupal\comment\Entity\Comment::load().
     */
    function comment_load($cid, $reset = FALSE) {
      if ($reset) {
        \Drupal::entityManager()->getStorage('comment')->resetCache(array($cid));
      }
      return Comment::load($cid);
    }
    
    /**
     * Gets the number of new comments for the current user and the specified node.
     *
     * @param int $entity_id
     *   Entity ID of the entity to which the comments are attached.
     * @param string $entity_type
     *   Entity type of the entity to which the comments are attached.
     * @param string $field_name
     *   (optional) The field_name to count comments for. Defaults to NULL.
     * @param $timestamp
     *   Time to count from (defaults to time of last user access to node).
     *
     * @return int|false
     *   The number of new comments or FALSE if the user is not logged in.
     */
    function comment_num_new($entity_id, $entity_type, $field_name = NULL, $timestamp = 0) {
      if (\Drupal::currentUser()->isAuthenticated() && \Drupal::moduleHandler()->moduleExists('history')) {
        // Retrieve the timestamp at which the current user last viewed this entity.
        if (!$timestamp) {
          if ($entity_type == 'node') {
            $timestamp = history_read($entity_id);
          }
          else {
            $function = $entity_type . '_last_viewed';
            if (function_exists($function)) {
              $timestamp = $function($entity_id);
            }
            else {
              // Default to 30 days ago.
              // @todo Remove once http://drupal.org/node/1029708 lands.
              $timestamp = COMMENT_NEW_LIMIT;
            }
          }
        }
        $timestamp = ($timestamp > HISTORY_READ_LIMIT ? $timestamp : HISTORY_READ_LIMIT);
    
        // Use the timestamp to retrieve the number of new comments.
        $query = db_select('comment', 'c');
        $query->addExpression('COUNT(cid)');
        $query->condition('c.entity_type', $entity_type)
          ->condition('c.entity_id', $entity_id)
          ->condition('c.status', CommentInterface::PUBLISHED)
          ->condition('c.created', $timestamp, '>');
        if ($field_name) {
          // Limit to a particular field.
          $query->condition('c.field_name', $field_name);
        }
    
        return $query->execute()
          ->fetchField();
      }
      else {
        return FALSE;
      }
    
    }
    
    /**
     * Gets the display ordinal for a comment, starting from 0.
     *
     * Count the number of comments which appear before the comment we want to
     * display, taking into account display settings and threading.
     *
     * @param int $cid
     *   The comment ID.
     * @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
     *   Field definition of the comments.
     *
     * @return int
     *   The display ordinal for the comment.
     *
     * @see comment_get_display_page()
     */
    function comment_get_display_ordinal($cid, FieldDefinitionInterface $field_definition) {
      // Count how many comments (c1) are before $cid (c2) in display order. This is
      // the 0-based display ordinal.
      $query = db_select('comment', 'c1');
      $query->innerJoin('comment', 'c2', 'c2.entity_id = c1.entity_id AND c2.entity_type = c1.entity_type AND c2.field_name = c1.field_name');
      $query->addExpression('COUNT(*)', 'count');
      $query->condition('c2.cid', $cid);
      if (!user_access('administer comments')) {
        $query->condition('c1.status', CommentInterface::PUBLISHED);
      }
    
      if ($field_definition->getSetting('default_mode') == COMMENT_MODE_FLAT) {
        // For flat comments, cid is used for ordering comments due to
        // unpredictable behavior with timestamp, so we make the same assumption
        // here.
        $query->condition('c1.cid', $cid, '<');
      }
      else {
        // For threaded comments, the c.thread column is used for ordering. We can
        // use the sorting code for comparison, but must remove the trailing slash.
        // See CommentViewBuilder.
        $query->where('SUBSTRING(c1.thread, 1, (LENGTH(c1.thread) -1)) < SUBSTRING(c2.thread, 1, (LENGTH(c2.thread) -1))');
      }
    
      return $query->execute()->fetchField();
    }
    
    /**
     * Returns the page number for a comment.
     *
     * Finds the correct page number for a comment taking into account display
     * and paging settings.
     *
     * @param int $cid
     *   The comment ID.
     * @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
     *   Field definition of the comments.
     *
     * @return int
     *   The page number.
     */
    function comment_get_display_page($cid, FieldDefinitionInterface $field_definition) {
      $ordinal = comment_get_display_ordinal($cid, $field_definition);
      $comments_per_page = $field_definition->getSetting('per_page');
      return floor($ordinal / $comments_per_page);
    }
    
    /**
     * Generates a comment preview.
     *
     * @param \Drupal\comment\CommentInterface $comment
     *   The comment entity to preview.
     *
     * @return array
     *   An array as expected by drupal_render().
     */
    function comment_preview(CommentInterface $comment, array &$form_state) {
      $preview_build = array();
      $entity = $comment->getCommentedEntity();
    
      if (!form_get_errors($form_state)) {
        // Attach the user and time information.
        $author_name = $comment->getAuthorName();
        if (!empty($author_name)) {
          $account = user_load_by_name($author_name);
        }
        elseif (\Drupal::currentUser()->isAuthenticated() && empty($comment->is_anonymous)) {
          $account = \Drupal::currentUser();
        }
    
        if (!empty($account) && $account->isAuthenticated()) {
          $comment->setOwner($account);
          $comment->setAuthorName(String::checkPlain($account->getUsername()));
        }
        elseif (empty($author_name)) {
          $comment->setAuthorName(\Drupal::config('user.settings')->get('anonymous'));
        }
    
        $created_time = !is_null($comment->getCreatedTime()) ? $comment->getCreatedTime() : REQUEST_TIME;
        $comment->setCreatedTime($created_time);
        $comment->changed->value = REQUEST_TIME;
        $comment->in_preview = TRUE;
        $comment_build = comment_view($comment);
        $comment_build['#weight'] = -100;
    
        $preview_build['comment_preview'] = $comment_build;
      }
    
      if ($comment->hasParentComment()) {
        $build = array();
        $parent = $comment->getParentComment();
        if ($parent && $parent->isPublished()) {
          $build = 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 entity_view(). 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 = entity_view($entity, 'full');
      }
    
      $preview_build['comment_output_below'] = $build;
      $preview_build['comment_output_below']['#weight'] = 100;
    
      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 a user account object for rendering comment authors.
     *
     * This helper handles anonymous authors in addition to registered comment
     * authors.
     *
     * @param \Drupal\comment\CommentInterface $comment
     *   The comment to which the author replied.
     *
     * @return \Drupal\user\UserInterface
     *   A user account, for use with theme_username() or the user_picture template.
     */
    function comment_prepare_author(CommentInterface $comment) {
      // The account has been pre-loaded by CommentViewBuilder::buildComponents().
      $account = $comment->getOwner();
      if (empty($account->uid->value)) {
        // @todo Avoid creating a new entity by just creating a new instance
        //   directly, see https://drupal.org/node/1867228.
        $account = entity_create('user', array('uid' => 0, 'name' => $comment->getAuthorName(), 'homepage' => $comment->getHomepage()));
        // The anonymous user is not a new account, do not treat it as one.
        $account->enforceIsNew(FALSE);
      }
      return $account;
    }
    
    /**
     * Prepares variables for comment templates.
     *
     * 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\comment\CommentInterface $comment */
      $comment = $variables['elements']['#comment'];
      $commented_entity = $comment->getCommentedEntity();
      $variables['comment'] = $comment;
      $variables['commented_entity'] = $commented_entity;
    
      $account = comment_prepare_author($comment);
      $username = array(
        '#theme' => 'username',
        '#account' => $account,
      );
      $variables['author'] = drupal_render($username);
      $variables['new_indicator_timestamp'] = $comment->getChangedTime();
      $variables['created'] = format_date($comment->getCreatedTime());
      // Avoid calling format_date() twice on the same timestamp.
      if ($comment->getChangedTime() == $comment->getCreatedTime()) {
        $variables['changed'] = $variables['created'];
      }
      else {
        $variables['changed'] = format_date($comment->getChangedTime());
      }
    
      if (theme_get_setting('features.comment_user_picture')) {
        // To change user picture settings (e.g., image style), edit the 'compact'
        // view mode on the User entity.
        $variables['user_picture'] = user_view($account, 'compact');
      }
      else {
        $variables['user_picture'] = array();
      }
    
      if (isset($variables['elements']['signature'])) {
        $variables['signature'] = $variables['elements']['signature']['#markup'];
        unset($variables['elements']['signature']);
      }
      else {
        $variables['signature'] = '';
      }
      if (isset($comment->in_preview)) {
        $variables['title'] = l($comment->getSubject(), '');
        $variables['permalink'] = l(t('Permalink'), '');
      }
      else {
        $uri = $comment->urlInfo();
        $attributes = $uri->getOption('attributes') ?: array();
        $attributes += array('class' => array('permalink'), 'rel' => 'bookmark');
        $uri->setOption('attributes', $attributes);
        $variables['title'] = \Drupal::linkGenerator()->generateFromUrl($comment->getSubject(), $uri);
    
        $variables['permalink'] = \Drupal::linkGenerator()->generateFromUrl(t('Permalink'), $comment->permalink());
      }
    
      $variables['submitted'] = t('Submitted by !username on !datetime', array('!username' => $variables['author'], '!datetime' => $variables['created']));
    
      if ($comment->hasParentComment()) {
        // Fetch and store the parent comment information for use in templates.
        $comment_parent = $comment->getParentComment();
        $account_parent = comment_prepare_author($comment_parent);
        $variables['parent_comment'] = $comment_parent;
        $username = array(
          '#theme' => 'username',
          '#account' => $account_parent,
        );
        $variables['parent_author'] = drupal_render($username);
        $variables['parent_created'] = format_date($comment_parent->getCreatedTime());
        // Avoid calling format_date() twice on the same timestamp.
        if ($comment_parent->getChangedTime() == $comment_parent->getCreatedTime()) {
          $variables['parent_changed'] = $variables['parent_created'];
        }
        else {
          $variables['parent_changed'] = format_date($comment_parent->getChangedTime());
        }
        $permalink_uri_parent = $comment_parent->permalink();
        $attributes = $permalink_uri_parent->getOption('attributes') ?: array();
        $attributes += array('class' => array('permalink'), 'rel' => 'bookmark');
        $permalink_uri_parent->setOption('attributes', $attributes);
        $variables['parent_title'] = \Drupal::linkGenerator()->generateFromUrl($comment_parent->getSubject(), $permalink_uri_parent);
        $variables['parent_permalink'] = \Drupal::linkGenerator()->generateFromUrl(t('Parent permalink'), $permalink_uri_parent);
        $variables['parent'] = t('In reply to !parent_title by !parent_username',
            array('!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'] = '';
      }
    
      // 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';
      }
    
      // Gather comment classes.
      $variables['attributes']['class'][] = 'comment';
      // 'published' class is not needed, it is either 'preview' or 'unpublished'.
      if ($variables['status'] != 'published') {
        $variables['attributes']['class'][] = $variables['status'];
      }
      if (!$comment->getOwnerId()) {
        $variables['attributes']['class'][] = 'by-anonymous';
      }
      else {
        // @todo Use $entity->getAuthorId() after https://drupal.org/node/2078387
        if ($commented_entity instanceof EntityOwnerInterface && $comment->getOwnerId() == $commented_entity->getOwnerId()) {
          $variables['attributes']['class'][] = 'by-' . $commented_entity->getEntityTypeId() . '-author';
        }
      }
      // Add clearfix class.
      $variables['attributes']['class'][] = 'clearfix';
    
      // Add comment author user ID. Necessary for the comment-by-viewer library.
      $variables['attributes']['data-comment-user-id'] = $comment->getOwnerId();
    
      $variables['content_attributes']['class'][] = 'content';
    }
    
    /**
     * Prepares variables for comment wrapper templates.
     *
     * Default template: comment-wrapper.html.twig.
     *
     * @param array $variables
     *   An associative array containing:
     *   - content: An associative array containing render arrays for the list of
     *     comments, and the comment form. Array keys: comments, comment_form.
     */
    function template_preprocess_comment_wrapper(&$variables) {
      // Provide contextual information.
      $variables['entity'] = $variables['content']['#entity'];
      $variables['display_mode'] = $variables['content']['#display_mode'];
    
      // The comment form is optional and may not exist.
      $variables['content'] += array('comment_form' => array());
    
      $variables['attributes']['id'] = 'comments';
    
      // Add a comment wrapper class.
      $variables['attributes']['class'][] = 'comment-wrapper';
    
      // Create separate variables for the comments and comment form.
      $variables['comments'] = $variables['content']['comments'];
      $variables['form'] = $variables['content']['comment_form'];
    }
    
    /**
     * Implements hook_ranking().
     */
    function comment_ranking() {
      return \Drupal::service('comment.statistics')->getRankingInfo();
    }
    
    /**
     * Implements hook_file_download_access().
     */
    function comment_file_download_access($field, EntityInterface $entity, FileInterface $file) {
      if ($entity instanceof CommentInterface) {
        if (user_access('access comments') && $entity->isPublished() || user_access('administer comments')) {
          $commented_entity = $entity->getCommentedEntity();
          // Check access to parent entity.
          return $commented_entity->access('view');
        }
        return FALSE;
      }
    }