edlp_d8/sites/all/modules/figli/edlp_corpus/src/Controller/CorpusController.php

<?php

namespace Drupal\edlp_corpus\Controller;

use Drupal\Core\Controller\ControllerBase;
use Drupal\Core\Language\LanguageInterface;
use Drupal\workflow\Entity\WorkflowManager;
use Drupal\Core\Url;
use Drupal\File\Entity\File;
use Drupal\taxonomy\Entity\Term;
// use Symfony\Component\HttpFoundation\JsonResponse;
use Drupal\Core\Cache\CacheableJsonResponse;
use Drupal\Core\Cache\CacheableMetadata;
use Drupal\core\render\RenderContext;
use Drupal\Core\Ajax\AjaxResponse;


class CorpusController extends ControllerBase {


  /**
   * Display the markup.
   *
   * @return array
   */
  public function contentjson() {


    // @see https://www.droptica.com/blog/drupal-8-restjson-integration-simple-javascript-application/
    // @see https://www.sitepoint.com/drupal-8-version-entityfieldquery/
    // @see https://www.frobiovox.com/posts/2016/03/28/simplify-drupal-8-field-value-calls.html
    // @see https://chromatichq.com/blog/dependency-injection-drupal-8-plugins

    // Get a node storage object.
    // $file_storage = \Drupal::entityManager()->getStorage('node');

    $current_langcode = \Drupal::languageManager()->getCurrentLanguage()->getId();

    $config = \Drupal::config('system.site');

    $query = \Drupal::entityQuery('node')
      ->condition('status', 1)
      ->condition('type', 'enregistrement');

    $nids = $query->execute();
    $nodes = entity_load_multiple('node', $nids);

    $view_builder = \Drupal::entityTypeManager()->getViewBuilder('node');

    $nodes_data = [];
    foreach ($nodes as $node) {
      // this would be ideal but it's too heavy to load : the whole ajax json goes from 138kb to 1.23Md (even optimized)...
      // $node_builder = $view_builder->view($node, 'popup');
      // $node = $n->getTranslation($current_langcode);

      // remove masqué
      $sid = WorkflowManager::getCurrentStateId($node, 'field_workflow');
      if($sid != 'corpus_documents_publie') continue;

      $entrees = [];
      foreach ($node->get('field_entrees')->getValue() as $key => $term) {
        $entrees[] = $term['target_id'];
      }
      // remove if no entries
      if(!count($entrees)) continue;

      if ($node->hasTranslation($current_langcode)
      && !$node->getTranslation($current_langcode)->field_description->isEmpty()) {
        $description_values = $node->getTranslation($current_langcode)->get('field_description')->getValue();
      }else{
        $description_values = $node->get('field_description')->getValue();
      }
      $description = count($description_values) ? $description_values[0]['value'] : "";
      // dpm($description);

      $field_son_values = $node->get('field_son')->getValue();
      $audio_fid = count($field_son_values) ? $field_son_values[0]['target_id'] : "";
      $audio_file = \Drupal\file\Entity\File::load($audio_fid);
      $audio_url = null;
      // if node don't have a sound file atteched, skip it
      if(!$audio_file) continue;

      $son_uri = $audio_file->getFileUri();
      $audio_url = file_create_url($son_uri);

      // has article ?
      $article_value = $node->body->getValue();
      $has_article = count($article_value);
      // if($has_article && $article_value[0]['value'] == "")
      //   dpm($article_value);

      $document_url = \Drupal::service('renderer')->executeInRenderContext(new RenderContext(), function () use ($node, $current_langcode) {
        if ($node->hasTranslation($current_langcode)){
          return $node->getTranslation($current_langcode)->toUrl()->toString();
        }else{
          return $node->toUrl()->toString();
        }
      });

      // favoris marker
      $nodes_data[] = array(
        "nid" => $node->get('nid')->getString(),
        "title" => $node->get('title')->getString(),
        "description" => $description,
        "entrees" => $entrees,
        // "son_fid" => $audio_fid,
        "audio_url" => $audio_url,
        "has_article" => $has_article,
        "chutier_action" => 'add',
        "document_url" => $document_url,
      );
    }

    $query = \Drupal::entityQuery('taxonomy_term')
      ->condition('vid', 'entrees');

    $tids = $query->execute();
    // $nodes = entity_load_multiple('node', $nids);
    foreach ($tids as $tid) {
      $entrees[] = $tid;
    }

    $data = array(
      'date' => time(),
      'site_name' => $config->get('name'),
      'count' => count($nodes),
      'nodes' => $nodes_data,
      'entrees' => $entrees,
      'language' => $current_langcode,
    );

    // https://spinningcode.org/2017/05/cached-json-responses-in-drupal-8/
    // cache is invalidated in edlp_corpus.module by tags
    $data['#cache'] = [
      'max-age' => \Drupal\Core\Cache\Cache::PERMANENT,
      'tags' => ['rebuild-corpus-cache'],
      'contexts' => ['languages:language_content'],
    ];

    // $response = new JsonResponse();
    // $response->setData($data);
    $response = new CacheableJsonResponse($data);
    $response->addCacheableDependency(CacheableMetadata::createFromRenderArray($data));

    return $response;

    return array(
      '#markup'=>'Hello Corpus'
    );
  }


 //  _            _      _
 // | |   __ _ __| |_ __| |___  __ ___
 // | |__/ _` (_-<  _/ _` / _ \/ _(_-<
 // |____\__,_/__/\__\__,_\___/\__/__/

  private function query() {
    $query = \Drupal::entityQuery('node')
    ->condition('status', 1)
    ->condition('type', 'enregistrement')
    ->sort('created', 'DESC')
    ->range(0,50);

   $nids = $query->execute();
   $nodes = entity_load_multiple('node', $nids);

   // $current_langcode = \Drupal::languageManager()->getCurrentLanguage()->getId();

   $this->lastdocs_nodes = [];
   $this->lastdocs_nids = [];
   foreach ($nodes as $node) {
     // remove masqué
     $sid = WorkflowManager::getCurrentStateId($node, 'field_workflow');
     if($sid != 'corpus_documents_publie') continue;

     $this->lastdocs_nodes[] = $node;
     // record an array of nids for corpus map filtering
     $this->lastdocs_nids[] = $node->get('nid')->getString();
   }

   // // record an array of nids for corpus map filtering
   // $this->lastdocs_nids = [];
   // foreach($nids as $key => $nid){
   //   $this->lastdocs_nids[] = $nid;
   // }
  }

  private function toRenderable(){
     $this->query();
     // dpm($this->next_event_node);

     return array(
       "#theme"=>'edlp_corpus_lastdocs',
       '#lastdocs_nodes' => $this->lastdocs_nodes
     );

   }
  /**
   * Display lastdocs as a page.
   *
   * @return renderable array
   */
  public function lastdocs() {
    return $this->toRenderable();
  }

  /**
   * Get lastdocs data as json through ajax.
   *
   * @return json
   */
  public function lastdocsjson() {

    $renderable = $this->toRenderable();
    // $rendered = render($renderable);
    // We can't render directly the entity as it throw an exception with cachable data
    //http://blog.dcycle.com/blog/2018-01-24/caching-drupal-8-rest-resource/#the-dreaded-leaked-metadata-error
    $rendered = \Drupal::service('renderer')->executeInRenderContext(new RenderContext(), function () use ($renderable) {
      return render($renderable);
    });

    $data = [
      'rendered'=> $rendered,
      'title'=>t('Recently uploaded'),
      'documents_lies' => $this->lastdocs_nids,
    ];

    // translations links
    // use Drupal\Core\Url;
    // use Drupal\Core\Language\LanguageInterface;
    $route_name = 'edlp_corpus.lastdocs';
    $links = \Drupal::languageManager()->getLanguageSwitchLinks(LanguageInterface::TYPE_URL, Url::fromRoute($route_name));
    if (isset($links->links)) {
      $translations_build = [
        '#theme' => 'links__language_block',
        '#links' => $links->links,
        '#attributes' => ['class' => ["language-switcher-{$links->method_id}",],],
        '#set_active_class' => TRUE,
      ];
      $translations_rendered = \Drupal::service('renderer')->executeInRenderContext(new RenderContext(), function () use ($translations_build) {return render($translations_build);});

      $data['translations_links'] = $translations_rendered;
    }

    $data['#cache'] = [
      'max-age' => \Drupal\Core\Cache\Cache::PERMANENT,
      'tags' => ['edlp-lastdocs-cache'],
      'contexts' => [
        'languages:language_content'
      ]
    ];

    // $response = new JsonResponse();
    // $response->setData($data);
    $response = new CacheableJsonResponse($data);
    $response->addCacheableDependency(CacheableMetadata::createFromRenderArray($data));
    $response->addCacheableDependency(CacheableMetadata::createFromRenderArray($renderable));

    return $response;
  }



  //    _       _   _    _          ___         _
  //   /_\  _ _| |_(_)__| |___ ___ |_ _|_ _  __| |_____ __
  //  / _ \| '_|  _| / _| / -_|_-<  | || ' \/ _` / -_) \ /
  // /_/ \_\_|  \__|_\__|_\___/__/ |___|_||_\__,_\___/_\_\


  private function articlesQuery() {
    $query = \Drupal::entityQuery('node')
    ->condition('status', 1)
    ->condition('type', 'enregistrement')
    ->condition('body', '', "<>")
    ->sort('created', 'DESC');
    // ->range(0,20);

    $nids = $query->execute();
    $nodes = entity_load_multiple('node', $nids);

    $current_langcode = \Drupal::languageManager()->getCurrentLanguage()->getId();

    $this->articles_nodes = [];
    $this->articles_nids = [];
    foreach ($nodes as $node) {
      // remove masqué
      $sid = WorkflowManager::getCurrentStateId($node, 'field_workflow');
      if($sid != 'corpus_documents_publie') continue;

      // TODO: check if article is translated
      if ($node->getTranslation($current_langcode)->body->isEmpty()) continue;

      $this->articles_nodes[] = $node;
      // record an array of nids for corpus map filtering
      $this->articles_nids[] = $node->get('nid')->getString();
    }

  }

  private function articlesToRenderable(){
     $this->articlesQuery();
     // dpm($this->next_event_node);

     return array(
       "#theme"=>'edlp_corpus_articlesindex',
       '#articles_nodes' => $this->articles_nodes
     );

   }
  /**
   * Display lastdocs as a page.
   *
   * @return renderable array
   */
  public function articlesindex() {
    return $this->articlesToRenderable();
  }

  /**
   * Get lastdocs data as json through ajax.
   *
   * @return json
   */
  public function articlesindexjson() {

    $renderable = $this->articlesToRenderable();
    // $rendered = render($renderable);
    // We can't render directly the entity as it throw an exception with cachable data
    //http://blog.dcycle.com/blog/2018-01-24/caching-drupal-8-rest-resource/#the-dreaded-leaked-metadata-error
    $rendered = \Drupal::service('renderer')->executeInRenderContext(new RenderContext(), function () use ($renderable) {
      return render($renderable);
    });

    $data = [
      'rendered'=> $rendered,
      'title'=>'Articles',
      'articles' => $this->articles_nids,
      'documents_lies' => $this->articles_nids,
    ];

    // translations links
    // use Drupal\Core\Url;
    // use Drupal\Core\Language\LanguageInterface;
    $route_name = 'edlp_corpus.articlesindex';
    $links = \Drupal::languageManager()->getLanguageSwitchLinks(LanguageInterface::TYPE_URL, Url::fromRoute($route_name));
    if (isset($links->links)) {
      $translations_build = [
        '#theme' => 'links__language_block',
        '#links' => $links->links,
        '#attributes' => ['class' => ["language-switcher-{$links->method_id}",],],
        '#set_active_class' => TRUE,
      ];
      $translations_rendered = \Drupal::service('renderer')->executeInRenderContext(new RenderContext(), function () use ($translations_build) {return render($translations_build);});

      $data['translations_links'] = $translations_rendered;
    }

    $data['#cache'] = [
      'max-age' => \Drupal\Core\Cache\Cache::PERMANENT,
      'tags' => ['edlp-articlesindex-cache'],
      'contexts' => [
        'languages:language_content'
      ]
    ];

    // $response = new JsonResponse();
    // $response->setData($data);
    $response = new CacheableJsonResponse($data);
    $response->addCacheableDependency(CacheableMetadata::createFromRenderArray($data));
    $response->addCacheableDependency(CacheableMetadata::createFromRenderArray($renderable));

    return $response;
  }



  //   ___     _ _        _   _
  //  / __|___| | |___ __| |_(_)___ _ _
  // | (__/ _ \ | / -_) _|  _| / _ \ ' \
  //  \___\___/_|_\___\__|\__|_\___/_||_|

  private function collectionQuery(){
    $language = \Drupal::languageManager()->getCurrentLanguage()->getId();

    $query = \Drupal::entityQuery('taxonomy_term')
      // ->sort('weight', 'DESC')
      // ->sort('name', 'DESC')
      ->condition('vid', 'entrees');

    $tids = $query->execute();
    // $terms = entity_load_multiple('taxonomy_term', $tids);
    // $terms = \Drupal::entityManager()->getStorage('taxonomy_term')->loadMultiple($t‌​erms);
    $terms = Term::loadMultiple($tids);

    $ordered_terms = [];
    foreach ($terms as $term) {
      // remove masqué
      $sid = WorkflowManager::getCurrentStateId($term, 'field_workflow');
      if($sid == 'generique_masque') continue;
      // translate the term
      $term = \Drupal::service('entity.repository')->getTranslationFromContext($term, $language);
      $name = $term->getName();
      $ordered_trans_terms[$name] = $term;
    }
    ksort($ordered_trans_terms);
    $this->entrees_terms = $ordered_trans_terms;

  }

  private function collectionToRenderable(){
    $this->collectionQuery();

    return array(
      "#theme"=>'edlp_corpus_collection',
      '#entrees_terms' => $this->entrees_terms
    );
  }

  public function collection(){
    return $this->collectionToRenderable();
  }

  public function collectionjson(){
    $renderable = $this->collectionToRenderable();
    // $rendered = render($renderable);
    // We can't render directly the entity as it throw an exception with cachable data
    //http://blog.dcycle.com/blog/2018-01-24/caching-drupal-8-rest-resource/#the-dreaded-leaked-metadata-error
    $rendered = \Drupal::service('renderer')->executeInRenderContext(new RenderContext(), function () use ($renderable) {
      return render($renderable);
    });

    $data = [
      'rendered'=> $rendered,
      'title'=>'Collection'
    ];

    // translations links
    // use Drupal\Core\Url;
    // use Drupal\Core\Language\LanguageInterface;
    $route_name = 'edlp_corpus.collection';
    $links = \Drupal::languageManager()->getLanguageSwitchLinks(LanguageInterface::TYPE_URL, Url::fromRoute($route_name));
    if (isset($links->links)) {
      $translations_build = [
        '#theme' => 'links__language_block',
        '#links' => $links->links,
        '#attributes' => ['class' => ["language-switcher-{$links->method_id}",],],
        '#set_active_class' => TRUE,
      ];
      $translations_rendered = \Drupal::service('renderer')->executeInRenderContext(new RenderContext(), function () use ($translations_build) {return render($translations_build);});

      $data['translations_links'] = $translations_rendered;
    }

    $data['#cache'] = [
      'max-age' => \Drupal\Core\Cache\Cache::PERMANENT,
      'tags' => ['edlp-articlesindex-cache'],
      'contexts' => [
        'languages:language_content'
      ]
    ];

    // $response = new JsonResponse();
    // $response->setData($data);
    $response = new CacheableJsonResponse($data);
    $response->addCacheableDependency(CacheableMetadata::createFromRenderArray($data));
    $response->addCacheableDependency(CacheableMetadata::createFromRenderArray($renderable));

    return $response;
  }

}