UWService.php

<?php

namespace Drupal\uw_cfg_common\Service;

use Drupal\Core\Database\Connection;
use Drupal\Core\Entity\EntityInterface;
use Drupal\Core\Entity\EntityTypeManagerInterface;
use Drupal\node\Entity\Node;
use Drupal\simplify_menu\MenuItems;
use Drupal\path_alias\AliasManager;
use Symfony\Component\HttpFoundation\RequestStack;

/**
 * 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;

  /**
   * Simplify_menu menu items.
   *
   * @var \Drupal\simplify_menu\MenuItems
   */
  private $simplifyMenu;

  /**
   * Simplify_menu menu items.
   *
   * @var \Drupal\simplify_menu\MenuItems
   */
  private $pathAliasManager;

  /**
   * The request stack.
   *
   * @var \Symfony\Component\HttpFoundation\RequestStack
   */
  private $requestStack;

  /**
   * Default constructor.
   *
   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entityTypeManager
   *   Entity Type Manager from core.
   * @param \Drupal\Core\Database\Connection $database
   *   The database entity.
   * @param \Drupal\simplify_menu\MenuItems $simplifyMenu
   *   The simplify_menu menu items.
   * @param \Drupal\path_alias\AliasManager $pathAliasManager
   *   The Drupal path alias manager.
   * @param \Symfony\Component\HttpFoundation\RequestStack $requestStack
   *   The request stack.
   */
  public function __construct(EntityTypeManagerInterface $entityTypeManager, Connection $database, MenuItems $simplifyMenu, AliasManager $pathAliasManager, RequestStack $requestStack) {
    $this->entityTypeManager = $entityTypeManager;
    $this->database = $database;
    $this->simplifyMenu = $simplifyMenu;
    $this->pathAliasManager = $pathAliasManager;
    $this->requestStack = $requestStack;
  }

  /**
   * {@inheritDoc}
   */
  public function getCropImageStyles(string $type, bool $get_all = FALSE): array {

    // Image styles for portrait.
    $image_styles['portrait'] = [
      'uw_is_portrait',
    ];

    // Image styles for responsive.
    $image_styles['responsive'] = [
      'uw_is_media_x_large',
      'uw_is_media_x_small',
      'uw_is_media_medium',
      'uw_is_media_large',
      'uw_is_media_small',
    ];

    // If the flag to get all the image styles is set,
    // return all of them.  If not return the
    // specific image style.
    if ($get_all) {
      return $image_styles;
    }
    else {
      return $image_styles[$type];
    }
  }

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

    // Ensure that we can load an entity on the media.
    if ($entity && isset($entity->field_media_image->entity)) {

      // 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;

        // Set the alt for the image.
        $variables['alt'] = $entity->field_media_image->alt;

        // This 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) {

          $srcset = $source->storage()['srcset']->value();
          $srcset_parts = explode('/', $srcset);

          foreach ($srcset_parts as $srcset_part) {
            if (strpos($srcset_part, 'uw_is') !== FALSE) {
              $style = $srcset_part;
              break;
            }
          }

          $variables['responsive_sources'][] = [
            'srcset' => $srcset,
            'media' => $source->storage()['media']->value(),
            'type' => $source->storage()['type']->value(),
            'style' => $style,
          ];
        }

        return $variables;
      }
    }

    return [];
  }

  /**
   * {@inheritDoc}
   */
  public function uwGetResponsiveImageStyles(): array {
    return [
      'uw_is_media_x_large',
      'uw_is_media_large',
      'uw_is_media_medium',
      'uw_is_media_small',
      'uw_is_media_x_small',
      'uw_is_portrait',
    ];
  }

  /**
   * {@inheritDoc}
   */
  public function uwGetNodePreprocessing(string $type): array {

    // Ensure that we return at least empty array.
    $preprocess = [];

    // Get the array of things to be proprocessed based
    // on the type.
    switch ($type) {

      case 'full':
        $preprocess = [
          'uw_ct_blog',
          'uw_ct_catalog_item',
          'uw_ct_contact',
          'uw_ct_event',
          'uw_ct_expand_collapse_group',
          'uw_ct_news_item',
          'uw_ct_opportunity',
          'uw_ct_profile',
          'uw_ct_project',
          'uw_ct_web_page',
          'uw_ct_service',
        ];
        break;

      case 'layout_container':
        $preprocess = [
          'uw_ct_blog',
          'uw_ct_contact',
          'uw_ct_event',
          'uw_ct_news_item',
          'uw_ct_opportunity',
          'uw_ct_profile',
          'uw_ct_project',
          'uw_ct_catalog_item',
          'uw_ct_service',
        ];
        break;

      case 'teaser':
        $preprocess = [
          'uw_ct_blog',
          'uw_ct_catalog_item',
          'uw_ct_contact',
          'uw_ct_event',
          'uw_ct_news_item',
          'uw_ct_opportunity',
          'uw_ct_profile',
          'uw_ct_project',
          'uw_ct_web_page',
        ];
        break;

      case 'media':
        $preprocess = [
          'uw_ct_blog',
          'uw_ct_event',
          'uw_ct_news_item',
        ];
        break;
    }

    return $preprocess;
  }

  /**
   * {@inheritDoc}
   */
  public function uwCheckNodeForMedia(Node $node): string {

    // Set the node type.
    $node_type = $node->getType();

    // Get the list of content types that are allowed to have
    // hero from our service.
    $media = $this->uwGetNodePreprocessing('media');

    // If node is allowed to have a media, make sure that
    // node actually has a media.
    if (in_array($node_type, $media)) {

      // Ensure that the node has the type of media field.
      if ($node->hasField('field_uw_type_of_media')) {

        // Get the type of media value from the node.
        $value = $node->field_uw_type_of_media->value;

        // If there is a media present, set the variable so that
        // the page title will not be displayed.
        if ($value) {
          return 'yes';
        }
      }
    }

    // Return a no by default.
    return 'no';
  }

  /**
   * {@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_contact' => FALSE,
      'uw_ct_event' => TRUE,
      'uw_ct_news_item' => TRUE,
      'uw_ct_opportunity' => FALSE,
      'uw_ct_profile' => FALSE,
      'uw_ct_project' => FALSE,
      'uw_ct_service' => 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;
  }

  /**
   * {@inheritDoc}
   */
  public function uwGetMenu(string $menu_name = 'main', bool $count_menu_items = FALSE, bool $include_parent_in_count = FALSE): array {

    // Get the main menu from the simplify menu module.
    $menu = $this->simplifyMenu->getMenuTree($menu_name);

    // Set it to the menu_tree which is done by simplify menu.
    $menu = $menu['menu_tree'];

    // Check that menu links are published and accessible.
    $this->uwCheckMenuItems($menu);

    // If we want to have the count of menu items, then count them.
    if ($count_menu_items) {

      // Add the count of the menu items.
      $menu = $this->uwSetMenuItems($menu, $include_parent_in_count);
    }

    return $menu;
  }

  /**
   * {@inheritDoc}
   */
  public function uwCheckMenuItems(&$menu): void {

    // The base path, need this for removing when on subfoldered sites,
    // for example d8/fdsu5/, we need to remove the fdsu5 from the path
    // alias.
    global $base_path;

    // Step through each menu and ensure that it is published.
    foreach ($menu as $key => $m) {

      // If there is a submenu (i.e. children), process it first.
      if (isset($m['submenu'])) {
        $this->uwCheckMenuItems($menu[$key]['submenu']);
      }

      // If its inaccessible, remove the menu link.
      if ($m['text'] == 'Inaccessible') {
        unset($menu[$key]);
      }
      else {

        // Remove the base path from the url so that we can get
        // the actual content from the path alias.
        $alias = str_replace($base_path, '', $m['url']);

        // Get the path from the URL of the menu link.
        $path = $this->pathAliasManager->getPathByAlias('/' . $alias);

        // Check if it is a node path and if so check if published.
        if (preg_match('/^node\/(\d+)$/', $path, $matches)) {

          // Load in the node based on the path.
          $node = $this->entityTypeManager->getStorage('node')->load($matches[1]);

          // If the node is unpublished, remove it from the menus.
          if ($node->status->value == 0) {
            unset($menu[$key]);
          }
        }
      }
    }
  }

  /**
   * {@inheritDoc}
   */
  public function uwSetMenuItems(array $menus, bool $include_parent_in_count = FALSE): array {

    // Step through the menu and do a few things:
    // (a) Remove the Home link (this will be a house icon)
    // (b) Add the number of menu items per menu link.
    foreach ($menus as $index => $menu) {

      // If this is the Home link, then remove it.
      if ($menu['text'] == "Home") {

        // Remove the home link.
        unset($menus[$index]);
      }

      // If we are not on the home link, then add the number
      // of menu items in this menu link.
      else {

        // Set the menu_item_count, initially to 0.
        $menu_items_count = 0;

        // If there is a submenu, recursivley call the count function.
        if (isset($menu['submenu']) && count($menu['submenu']) > 0) {

          // Call the count function recursively till we have the number of
          // menu items.
          $this->uwCountMenuItems($menu['submenu'], $menu_items_count);

          // Set the menu items count.
          // If we need to include the parent in the count, for example the
          // main menu will print the parent inside the tray, then we increment
          // the menu items count by 1.
          if ($include_parent_in_count) {
            $menu_items_count++;
          }

          // Set the menu items count in the menu.
          $menus[$index]['menu_items_count'] = $menu_items_count;

        }

        // If there are no submenus, the count is 0, there will be no tray.
        else {

          // Set the number of items count, which is 0.
          $menus[$index]['menu_items_count'] = $menu_items_count;
        }
      }
    }

    return $menus;
  }

  /**
   * {@inheritDoc}
   */
  public function uwCountMenuItems($menus, &$menu_items_count): void {

    // Step through the menus and check for submenus and count.
    foreach ($menus as $menu) {

      // Increment the menu items counter.
      $menu_items_count++;

      // If there is a submenu, recursivley call the count function.
      if (isset($menu['submenu']) && count($menu['submenu']) > 0) {

        // Recursively check the submenu.
        $this->uwCountMenuItems($menu['submenu'], $menu_items_count);

      }
    }
  }

  /**
   * Determine whether a node is the home page.
   *
   * @param int $nid
   *   A node ID.
   *
   * @return bool
   *   TRUE when the node is the home page, FALSE otherwise.
   */
  public static function nodeIsHomePage(int $nid): bool {
    $front_page_path = \Drupal::configFactory()->get('system.site')->get('page.front');
    $front_page_alias = \Drupal::service('path_alias.manager')->getAliasByPath($front_page_path);
    $node_alias = \Drupal::service('path_alias.manager')->getAliasByPath('/node/' . $nid);
    return $front_page_alias === $node_alias;
  }

  /**
   * {@inheritDoc}
   */
  public function uwMonthNameShort(int $month = NULL) {

    static $months = [
      1 => 'Jan.',
      2 => 'Feb.',
      3 => 'Mar.',
      4 => 'Apr.',
      5 => 'May',
      6 => 'June',
      7 => 'July',
      8 => 'Aug.',
      9 => 'Sep.',
      10 => 'Oct.',
      11 => 'Nov.',
      12 => 'Dec.',
    ];
    if ($month) {
      return $months[$month];
    }
    else {
      return $months;
    }
  }

  /**
   * {@inheritDoc}
   */
  public function getContentTypeUsage(
    array $content_types,
    bool $show_null_content_types = FALSE
  ): array {

    // Node content types array.
    $list = [];

    // Step through the content types and get info.
    foreach ($content_types as $ct) {

      // Query to get all nodes of the content type.
      $query = $this->entityTypeManager->getStorage('node')->getQuery();
      $query->condition('type', $ct);

      // Get the total number of nodes.
      $total = $query->count()->execute();

      // If there are no nodes of the content type,
      // break out of this iteration, as we do not
      // want to display no nodes, however if flag
      // is set to show null nodes we will show them.
      if ($total == 0 && !$show_null_content_types) {
        continue;
      }

      // Load the content type, we need to use current as this
      // will load multiple, current will load the first entry.
      $content_type = current(
        $this->entityTypeManager->getStorage('node_type')
          ->loadByProperties(['type' => $ct])
      );

      // Add the condition of published to query.
      $query->condition('status', 1);

      // Set the number of published nodes.
      $published = $query->count()->execute();

      // Set up the list to be used as rows in the table.
      $list[$ct] = [
        'name' => $content_type->get('name'),
        'total' => $total,
        'published' => $published,
        'unpublished' => $total - $published,
      ];
    }

    return $list;
  }

}