user_dashboard_bootstrap-1.0.2/src/Hook/UserDashboardHooks.php

<?php

namespace Drupal\user_dashboard_bootstrap\Hook;

use Drupal\Component\Utility\Html;
use Drupal\Core\Config\ConfigFactoryInterface;
use Drupal\Core\Database\Connection;
use Drupal\Core\Entity\EntityInterface;
use Drupal\Core\Extension\ModuleHandlerInterface;
use Drupal\Core\Hook\Attribute\Hook;
use Drupal\Core\Messenger\MessengerInterface;
use Drupal\Core\Routing\RouteMatchInterface;
use Drupal\Core\StringTranslation\StringTranslationTrait;
use Drupal\filter\FilterPluginManager;
use Drupal\user\Entity\User;

/**
 * Hook implementations for user dashboard bootstrap.
 */
class UserDashboardHooks {
  use StringTranslationTrait;

  /**
   * Constructs a new DataFieldHook object.
   *
   * @param \Drupal\Core\Extension\ModuleHandlerInterface $moduleHandler
   *   The module handler service.
   * @param \Drupal\Core\Config\ConfigFactoryInterface $configFactory
   *   The config factory service.
   * @param \Drupal\Core\Messenger\MessengerInterface $messenger
   *   The message service.
   * @param \Drupal\Core\Database\Connection $connection
   *   The database service.
   * @param \Drupal\filter\FilterPluginManager|null $filterPluginManager
   *   Filter plugin manager.
   */
  public function __construct(
    protected ModuleHandlerInterface $moduleHandler,
    protected ConfigFactoryInterface $configFactory,
    protected MessengerInterface $messenger,
    protected Connection $connection,
    protected ?FilterPluginManager $filterPluginManager = NULL,
  ) {
  }

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container) {
    return new static(
      $container->get('module_handler'),
      $container->get('config.factory'),
      $container->get('messenger'),
      $container->get('database'),
      $container->get('plugin.manager.filter'),
    );
  }

  /**
   * Implements hook_help().
   */
  #[Hook('help')]
  public function help($route_name, RouteMatchInterface $route_match) {
    switch ($route_name) {
      case 'help.page.user_dashboard_bootstrap':
        $text = file_get_contents(__DIR__ . '/../../README.md');
        if (!$this->moduleHandler->moduleExists('markdown')) {
          return '<pre>' . Html::escape($text) . '</pre>';
        }
        else {
          // Use the Markdown filter to render the README.
          $settings = $this->configFactory->get('markdown.settings')->getRawData();
          $config = ['settings' => $settings];
          $filter = $this->filterPluginManager->createInstance('markdown', $config);
          return $filter->process($text, 'en');
        }
    }
    return FALSE;
  }

  /**
   * Implements hook_ENTITY_TYPE_insert() for user entities.
   */
  #[Hook('user_insert')]
  public function userInsert(EntityInterface $entity): void {
    $rowRegions = \Drupal::service('user_dashboard_bootstrap.blocks')->getRegions();
    $regions = [];
    foreach ($rowRegions as $row) {
      $regions = array_merge($regions, array_keys($row));
    }
    $roles = $entity->getRoles(TRUE);
    $config = $this->configFactory->get('user_dashboard_bootstrap.role');
    $uid = $entity->id();
    $insertBlocks = [];
    foreach ($regions as $region) {
      foreach ($roles as $role) {
        $configUserBlocks = $region . '-' . $role;
        if (!empty($blocks = $config->get($configUserBlocks))) {
          foreach ($blocks as $blockId) {
            $insertBlocks[$blockId] = [$blockId, 1, 0, $region, $uid];
          }
        }
      }
    }
    if (!empty($insertBlocks)) {
      foreach ($insertBlocks as $insertBlock) {
        $this->connection
          ->insert('user_dashboard_block')
          ->fields(['delta', 'status', 'weight', 'region', 'uid'])
          ->values($insertBlock)
          ->execute();
      }

    }
  }

  /**
   * Implements hook_cron().
   */
  #[Hook('cron')]
  public function cron(): void {
    $config = $this->configFactory->get('user_dashboard_bootstrap.settings');
    $queueName = 'cron_user_dashboard_email';
    $cid = 'dashboard_cron:time';
    /** @var \Drupal\Core\Queue\QueueFactory $queue_factory */
    $queue_factory = \Drupal::service('queue');
    $cacheFactory = \Drupal::cache();
    if ($cache = $cacheFactory->get($cid)) {
      $lastRunTime = $cache->data;
    }
    else {
      $lastRunTime = strtotime('today midnight');
      $cacheFactory->set($cid, $lastRunTime);
    }
    $cronHour = $config->get('cron_hour') ?: '00:00';
    $scheduledRunTime = strtotime(date('Y-m-d') . ' ' . $cronHour);
    $now = strtotime('now');
    // @todo check time with cron_hour.
    if ($now >= $scheduledRunTime && $lastRunTime < $scheduledRunTime) {
      $cacheFactory->set($cid, $now);
    }
    else {
      // Do nothing if e-mail sent during the day.
      $queue = $queue_factory->get($queueName);
      if ($queue) {
        while ($item = $queue->claimItem()) {
          if ((method_exists($queue, 'processItem'))) {
            $queue->processItem($item->data);
          }
          if ((method_exists($queue, 'deleteItem'))) {
            $queue->deleteItem($item);
          }
        }
      }
      return;
    }
    if ($config->get('cron_email')) {
      $cronEmail = $config->get('user_dashboard_cron_email_block');
      $query = $this->connection->select('user_dashboard_block', 'b');
      $query->leftJoin('users_field_data', 'u', 'b.uid= u.uid');
      $query->fields('b')
        ->condition('u.status', 1)
        ->orderBy('b.region', 'DESC')
        ->orderBy('b.weight', 'DESC');
      if (!empty($cronEmail)) {
        $query->condition('b.delta', $cronEmail, 'IN');
      }
      $result = $query->execute();
      $userDashboards = [];
      global $base_url;
      $logo = $base_url . base_path() . \Drupal::theme()->getActiveTheme()->getLogo();
      $systemSite = $this->configFactory->get('system.site');
      foreach ($result as $record) {
        if (empty($userDashboards[$record->uid])) {
          $user = User::load($record->uid);
          $userDashboards[$record->uid] = [
            '#theme' => 'user_dashboard_cron_email',
            '#uid' => $user->id(),
            '#username' => $user->getDisplayName(),
            '#email' => $user->getEmail(),
            '#subject' => $config->get('user_dashboard_cron_email_subject'),
            '#logo' => $logo,
            '#site_name' => $systemSite->get('name'),
            '#site_email' => $systemSite->get('mail'),
            '#site_slogan' => $systemSite->get('slogan'),
            '#regions' => [],
          ];
        }
        $userDashboards[$record->uid]['blocks'][] = (array) $record;
      }

      if (!empty($userDashboards)) {
        $queue = $queue_factory->get($queueName);
        foreach ($userDashboards as $dashboard) {
          $queue->createItem($dashboard);
        }
      }
    }
  }

}