ForumController.php

<?php

namespace Drupal\forum\Controller;

use Drupal\Core\Cache\Cache;
use Drupal\Core\Controller\ControllerBase;
use Drupal\Core\Entity\EntityAccessControlHandlerInterface;
use Drupal\Core\Entity\EntityStorageInterface;
use Drupal\Core\Entity\EntityTypeInterface;
use Drupal\Core\Render\RendererInterface;
use Drupal\Core\Session\AccountInterface;
use Drupal\Core\Url;
use Drupal\forum\ForumManagerInterface;
use Drupal\taxonomy\TermInterface;
use Drupal\taxonomy\TermStorageInterface;
use Drupal\taxonomy\VocabularyStorageInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;

/**
 * Controller routines for forum routes.
 */
class ForumController extends ControllerBase {
    
    /**
     * Forum manager service.
     *
     * @var \Drupal\forum\ForumManagerInterface
     */
    protected $forumManager;
    
    /**
     * Vocabulary storage.
     *
     * @var \Drupal\taxonomy\VocabularyStorageInterface
     */
    protected $vocabularyStorage;
    
    /**
     * Term storage.
     *
     * @var \Drupal\taxonomy\TermStorageInterface
     */
    protected $termStorage;
    
    /**
     * Node access control handler.
     *
     * @var \Drupal\Core\Entity\EntityAccessControlHandlerInterface
     */
    protected $nodeAccess;
    
    /**
     * Field map of existing fields on the site.
     *
     * @var array
     */
    protected $fieldMap;
    
    /**
     * Node type storage handler.
     *
     * @var \Drupal\Core\Entity\EntityStorageInterface
     */
    protected $nodeTypeStorage;
    
    /**
     * The renderer.
     *
     * @var \Drupal\Core\Render\RendererInterface
     */
    protected $renderer;
    
    /**
     * Node entity type, we need to get cache tags from here.
     *
     * @var \Drupal\Core\Entity\EntityTypeInterface
     */
    protected $nodeEntityTypeDefinition;
    
    /**
     * Comment entity type, we need to get cache tags from here.
     *
     * @var \Drupal\Core\Entity\EntityTypeInterface
     */
    protected $commentEntityTypeDefinition;
    
    /**
     * Constructs a ForumController object.
     *
     * @param \Drupal\forum\ForumManagerInterface $forum_manager
     *   The forum manager service.
     * @param \Drupal\taxonomy\VocabularyStorageInterface $vocabulary_storage
     *   Vocabulary storage.
     * @param \Drupal\taxonomy\TermStorageInterface $term_storage
     *   Term storage.
     * @param \Drupal\Core\Session\AccountInterface $current_user
     *   The current logged in user.
     * @param \Drupal\Core\Entity\EntityAccessControlHandlerInterface $node_access
     *   Node access control handler.
     * @param array $field_map
     *   Array of active fields on the site.
     * @param \Drupal\Core\Entity\EntityStorageInterface $node_type_storage
     *   Node type storage handler.
     * @param \Drupal\Core\Render\RendererInterface $renderer
     *   The renderer.
     * @param \Drupal\Core\Entity\EntityTypeInterface $node_entity_type_definition
     *   Node entity type definition object
     * @param \Drupal\Core\Entity\EntityTypeInterface $comment_entity_type_definition
     *   Comment entity type definition object
     */
    public function __construct(ForumManagerInterface $forum_manager, VocabularyStorageInterface $vocabulary_storage, TermStorageInterface $term_storage, AccountInterface $current_user, EntityAccessControlHandlerInterface $node_access, array $field_map, EntityStorageInterface $node_type_storage, RendererInterface $renderer, EntityTypeInterface $node_entity_type_definition, EntityTypeInterface $comment_entity_type_definition) {
        $this->forumManager = $forum_manager;
        $this->vocabularyStorage = $vocabulary_storage;
        $this->termStorage = $term_storage;
        $this->currentUser = $current_user;
        $this->nodeAccess = $node_access;
        $this->fieldMap = $field_map;
        $this->nodeTypeStorage = $node_type_storage;
        $this->renderer = $renderer;
        $this->nodeEntityTypeDefinition = $node_entity_type_definition;
        $this->commentEntityTypeDefinition = $comment_entity_type_definition;
    }
    
    /**
     * {@inheritdoc}
     */
    public static function create(ContainerInterface $container) {
        
        /** @var \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager */
        $entity_type_manager = $container->get('entity_type.manager');
        return new static($container->get('forum_manager'), $entity_type_manager->getStorage('taxonomy_vocabulary'), $entity_type_manager->getStorage('taxonomy_term'), $container->get('current_user'), $entity_type_manager->getAccessControlHandler('node'), $container->get('entity_field.manager')
            ->getFieldMap(), $entity_type_manager->getStorage('node_type'), $container->get('renderer'), $entity_type_manager->getDefinition('node'), $entity_type_manager->getDefinition('comment'));
    }
    
    /**
     * Returns forum page for a given forum.
     *
     * @param \Drupal\taxonomy\TermInterface $taxonomy_term
     *   The forum to render the page for.
     *
     * @return array
     *   A render array.
     */
    public function forumPage(TermInterface $taxonomy_term) {
        // Get forum details.
        $taxonomy_term->forums = $this->forumManager
            ->getChildren($this->config('forum.settings')
            ->get('vocabulary'), $taxonomy_term->id());
        $taxonomy_term->parents = $this->termStorage
            ->loadAllParents($taxonomy_term->id());
        if (empty($taxonomy_term->forum_container->value)) {
            $build = $this->forumManager
                ->getTopics($taxonomy_term->id(), $this->currentUser());
            $topics = $build['topics'];
            $header = $build['header'];
        }
        else {
            $topics = [];
            $header = [];
        }
        return $this->build($taxonomy_term->forums, $taxonomy_term, $topics, $taxonomy_term->parents, $header);
    }
    
    /**
     * Returns forum index page.
     *
     * @return array
     *   A render array.
     */
    public function forumIndex() {
        $vocabulary = $this->vocabularyStorage
            ->load($this->config('forum.settings')
            ->get('vocabulary'));
        $index = $this->forumManager
            ->getIndex();
        $build = $this->build($index->forums, $index);
        if (empty($index->forums)) {
            // Root of empty forum.
            $build['#title'] = $this->t('No forums defined');
        }
        else {
            // Set the page title to forum's vocabulary name.
            $build['#title'] = $vocabulary->label();
            $this->renderer
                ->addCacheableDependency($build, $vocabulary);
        }
        return $build;
    }
    
    /**
     * Returns a renderable forum index page array.
     *
     * @param array $forums
     *   A list of forums.
     * @param \Drupal\taxonomy\TermInterface $term
     *   The taxonomy term of the forum.
     * @param array $topics
     *   The topics of this forum.
     * @param array $parents
     *   The parent forums in relation this forum.
     * @param array $header
     *   Array of header cells.
     *
     * @return array
     *   A render array.
     */
    protected function build($forums, TermInterface $term, $topics = [], $parents = [], $header = []) {
        $config = $this->config('forum.settings');
        $build = [
            '#theme' => 'forums',
            '#forums' => $forums,
            '#topics' => $topics,
            '#parents' => $parents,
            '#header' => $header,
            '#term' => $term,
            '#sortby' => $config->get('topics.order'),
            '#forums_per_page' => $config->get('topics.page_limit'),
        ];
        if (empty($term->forum_container->value)) {
            $build['#attached']['feed'][] = [
                'taxonomy/term/' . $term->id() . '/feed',
                'RSS - ' . $term->getName(),
            ];
        }
        $this->renderer
            ->addCacheableDependency($build, $config);
        foreach ($forums as $forum) {
            $this->renderer
                ->addCacheableDependency($build, $forum);
        }
        foreach ($topics as $topic) {
            $this->renderer
                ->addCacheableDependency($build, $topic);
        }
        foreach ($parents as $parent) {
            $this->renderer
                ->addCacheableDependency($build, $parent);
        }
        $this->renderer
            ->addCacheableDependency($build, $term);
        $is_forum = empty($term->forum_container->value);
        return [
            'action' => $is_forum ? $this->buildActionLinks($config->get('vocabulary'), $term) : [],
            'forum' => $build,
            '#cache' => [
                'tags' => Cache::mergeTags($this->nodeEntityTypeDefinition
                    ->getListCacheTags(), $this->commentEntityTypeDefinition
                    ->getListCacheTags()),
            ],
        ];
    }
    
    /**
     * Returns add forum entity form.
     *
     * @return array
     *   Render array for the add form.
     */
    public function addForum() {
        $vid = $this->config('forum.settings')
            ->get('vocabulary');
        $taxonomy_term = $this->termStorage
            ->create([
            'vid' => $vid,
        ]);
        return $this->entityFormBuilder()
            ->getForm($taxonomy_term, 'forum');
    }
    
    /**
     * Returns add container entity form.
     *
     * @return array
     *   Render array for the add form.
     */
    public function addContainer() {
        $vid = $this->config('forum.settings')
            ->get('vocabulary');
        $taxonomy_term = $this->termStorage
            ->create([
            'vid' => $vid,
            'forum_container' => 1,
        ]);
        return $this->entityFormBuilder()
            ->getForm($taxonomy_term, 'container');
    }
    
    /**
     * Generates an action link to display at the top of the forum listing.
     *
     * @param string $vid
     *   Vocabulary ID.
     * @param \Drupal\taxonomy\TermInterface $forum_term
     *   The term for which the links are to be built.
     *
     * @return array
     *   Render array containing the links.
     */
    protected function buildActionLinks($vid, TermInterface $forum_term = NULL) {
        $user = $this->currentUser();
        $links = [];
        // Loop through all bundles for forum taxonomy vocabulary field.
        foreach ($this->fieldMap['node']['taxonomy_forums']['bundles'] as $type) {
            if ($this->nodeAccess
                ->createAccess($type)) {
                $node_type = $this->nodeTypeStorage
                    ->load($type);
                $links[$type] = [
                    '#theme' => 'menu_local_action',
                    '#link' => [
                        'title' => $this->t('Add new @node_type', [
                            '@node_type' => $this->nodeTypeStorage
                                ->load($type)
                                ->label(),
                        ]),
                        'url' => Url::fromRoute('node.add', [
                            'node_type' => $type,
                        ]),
                    ],
                    '#cache' => [
                        'tags' => $node_type->getCacheTags(),
                    ],
                ];
                if ($forum_term && $forum_term->bundle() == $vid) {
                    // We are viewing a forum term (specific forum), append the tid to
                    // the URL.
                    $links[$type]['#link']['localized_options']['query']['forum_id'] = $forum_term->id();
                }
            }
        }
        if (empty($links)) {
            // Authenticated user does not have access to create new topics.
            if ($user->isAuthenticated()) {
                $links['disallowed'] = [
                    '#markup' => $this->t('You are not allowed to post new content in the forum.'),
                ];
            }
            else {
                $links['login'] = [
                    '#theme' => 'menu_local_action',
                    '#link' => [
                        'title' => $this->t('Log in to post new content in the forum.'),
                        'url' => Url::fromRoute('user.login', [], [
                            'query' => $this->getDestinationArray(),
                        ]),
                    ],
                    // Without this workaround, the action links will be rendered as <li>
                    // with no wrapping <ul> element.
                    // @todo Find a better way for this in https://www.drupal.org/node/3181052.
'#prefix' => '<ul class="action-links">',
                    '#suffix' => '</ul>',
                ];
            }
        }
        else {
            // Without this workaround, the action links will be rendered as <li> with
            // no wrapping <ul> element.
            // @todo Find a better way for this in https://www.drupal.org/node/3181052.
            $links['#prefix'] = '<ul class="action-links">';
            $links['#suffix'] = '</ul>';
        }
        return $links;
    }

}