UWService.php

<?php

namespace Drupal\uw_cfg_common\Service;

use Drupal\Core\Entity\EntityInterface;
use Drupal\Core\Entity\EntityTypeManagerInterface;
use Drupal\node\NodeInterface;
use Drupal\Core\Database\Connection;

/**
 * Class UWService.
 *
 * UW Service that holds common functionality used by uw blocks.
 *
 * @package Drupal\uw_cfg_common\Service
 */
class UWService implements UWServiceInterface {

  /**
   * Entity type manager from core.
   *
   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
   */
  private $entityTypeManager;

  /**
   * Database connection.
   *
   * @var \Drupal\Core\Database\Connection
   */
  private $database;

  /**
   * Default constructor.
   *
   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entityTypeManager
   *   Entity Type Manager from core.
   * @param \Drupal\Core\Database\Connection $database
   *   The database entity.
   */
  public function __construct(EntityTypeManagerInterface $entityTypeManager, Connection $database) {
    $this->entityTypeManager = $entityTypeManager;
    $this->database = $database;
  }

  /**
   * {@inheritDoc}
   */
  public function prepareResponsiveImage(EntityInterface $entity, string $image_style): array {

    // Load in the file object if we have one.
    if ($file = $entity->field_media_image->entity) {

      // Need to set these variables so that responsive image function,
      // has all the necessary info to process the image style.
      $variables['uri'] = $file->getFileUri();
      $variables['responsive_image_style_id'] = $image_style;

      // These is a function from the responsive image module that sets all
      // the variables for the sources of the responsive image.
      template_preprocess_responsive_image($variables);

      // Step through each of the sources and setup our own sources array.
      foreach ($variables['sources'] as $source) {
        $variables['responsive_sources'][] = [
          'srcset' => $source->storage()['srcset']->value(),
          'media' => $source->storage()['media']->value(),
          'type' => $source->storage()['type']->value(),
        ];
      }

      return $variables;
    }

    return [];
  }

  /**
   * {@inheritDoc}
   */
  public function getTeaserContent(NodeInterface $node, array $variables_to_get, string $teaser_type): array {
    $variables = [];
    // Step through each of the variables to get and set the variables for the
    // teaser content.
    foreach ($variables_to_get as $variable_to_get) {

      // Switch on the variable to get and set the variables for the teaser
      // content.
      switch ($variable_to_get) {

        case 'title':

          // Set the title from the node object.
          $variables['title'] = $node->getTitle();
          break;

        case 'url':

          // Set the title from the node object.
          $variables['url'] = $node->toUrl()->toString();
          break;

        case 'date':

          // Set the field name, all of our content types use the same format,
          // field_uw_<content_type>_date.
          $field_name = 'field_uw_' . trim($teaser_type) . '_date';

          // Set the date variable, once returned to the calling function, they
          // can change the date format as required (i.e. change it to long-date
          // or date-time).
          $variables['date'] = $node->$field_name->getString();
          break;

        case 'author':

          // If author is selected, get both the author name and link.
          $variables['author_name'] = $node->getOwner()->getDisplayName();
          $variables['author_link'] = $node->getOwner()->toUrl()->toString();
          break;

        case 'sources':

          // Event has a different name for the image than the rest, so ensuring
          // that we get the correct field name for the image.
          // In most cases it is field_uw_<content_type>_lising_page_image.
          if ($teaser_type == 'event') {
            $field_name = 'field_uw_event_listing_page_img';
          }
          else {
            $field_name = 'field_uw_' . trim($teaser_type) . '_listing_page_image';
          }

          // Get the image object from the node.
          $image = $node->$field_name->entity;

          // Ensure that we have an image before adding variables.
          if ($image !== NULL) {

            // Get all the image variables, including the sources using the
            // prepareResponsiveImage function.
            $image_variables = $this->prepareResponsiveImage($image, 'uw_ris_media');

            // Set the responsive image variables for the teaser content.
            $variables['sources'] = $image_variables['responsive_sources'];
            $variables['img_element'] = $image_variables['img_element']['#uri'];
            $variables['alt'] = $image->field_media_image->alt;
          }
          break;

        case 'tags':

          // Set the field name for the tags which is
          // field_uw_<content_type>_tags.
          $field_name = 'field_uw_' . trim($teaser_type) . '_tags';

          // Get all the taxonomy terms for the blog.
          // Step through each taxonomy term and get the tag info.
          foreach ($node->$field_name as $tag) {

            // Set the tags in the teaser content variables.
            $variables['tags'][] = [
              'title' => $tag->entity->name->value,
              'url' => $tag->entity->toUrl()->toString(),
            ];
          }
          break;

        case 'content':

          // Set the field name for the summary, which is
          // field_name<content_type>_summary.
          $field_name = 'field_uw_' . $teaser_type . '_summary';

          // Set the render array for the summary, we simply can not just send
          // the value as Drupal will just render it with no filters or HTML
          // applied. We need to send the full render array.
          $variables['content'] = [
            '#type' => 'processed_text',
            '#text' => $node->$field_name->value,
            '#format' => $node->$field_name->format,
          ];
          break;
      }
    }

    return $variables;
  }

  /**
   * {@inheritDoc}
   */
  public function getOrCheckAttachedSidebar(int $attached_page_nid, int $sidebar_nid = NULL, string $type = NULL): int {

    // A database called to get the field with the condition of the
    // attached_page_nid.
    $result = $this->database
      ->select('node__field_uw_attach_page', 'nfuap')
      ->fields('nfuap', ['entity_id', 'field_uw_attach_page_target_id'])
      ->condition('field_uw_attach_page_target_id', $attached_page_nid);

    // If we are doing a a check for sidebar, then add the condition
    // that it is not equal to the current sidebar_nid that we are on.
    // Meaning that we are checking for any other sidebars that this
    // attached_page_nid is attached to.
    if ($type == 'check') {

      // Add the not equals to condition.
      $result->condition('entity_id', $sidebar_nid, '<>');
    }

    // Get the results of query, we only need to fetch, because we are
    // only every expecting one sidebar only has one other node page
    // attached.
    $results = $result->execute()->fetch();

    // If we have results, then return the entity_id, which is the
    // sidebar_nid that the attached_page_nid is attached to.
    if (isset($results->entity_id)) {

      // Return the entity_id.
      return $results->entity_id;
    }

    // If we made it here, there are no other sidebars that the
    // attached_page_nid is attached to, so we can simply return 0.
    else {
      return 0;
    }
  }

  /**
   * {@inheritDoc}
   */
  public function getUwContentTypes($with_sidebar = FALSE): array {
    $return_content_types = [];

    // This is the list of all UW content types, with a TRUE/FALSE, indicating
    // whether or not a sidebar can be attached to this content type.
    $content_types = [
      'uw_ct_blog' => TRUE,
      'uw_ct_catalog_item' => FALSE,
      'uw_ct_event' => TRUE,
      'uw_ct_news_item' => TRUE,
      'uw_ct_sidebar' => FALSE,
      'uw_ct_site_footer' => FALSE,
      'uw_ct_web_page' => TRUE,
    ];

    foreach ($content_types as $key => $value) {
      if ($with_sidebar && $value) {
        $return_content_types[] = $key;
      }
      elseif (!$with_sidebar) {
        $return_content_types[] = $key;
      }
    }

    return $return_content_types;
  }

}