openy_gated_content.module

<?php

/**
 * @file
 * The openy_gated_content module routines.
 */

use Drupal\Core\Entity\Entity\EntityViewDisplay;
use Drupal\Core\Entity\EntityTypeInterface;
use Drupal\Core\Session\AccountInterface;
use Drupal\Core\Access\AccessResult;
use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Url;
use Drupal\openy_gated_content\VyFavoriteItemsManager;
use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
use Drupal\openy_gated_content\SegmentContentAccessCheck;
use Drupal\Core\Entity\EntityInterface;
use Drupal\Core\Field\BaseFieldDefinition;
use Drupal\taxonomy\Entity\Vocabulary;
use Drupal\taxonomy\TermStorageInterface;
use Drupal\node\NodeInterface;

/**
 * Implements hook_theme().
 */
function openy_gated_content_theme() {
  return [
    'paragraph__gated_content' => [
      'base hook' => 'paragraph',
      'variables' => [
        'app_settings' => '',
        'headline' => '',
      ],
    ],
    'paragraph__gated_content_login' => [
      'base hook' => 'paragraph',
      'variables' => [
        'auth_provider_id' => '',
        'auth_configuration' => '',
      ],
    ],
  ];
}

/**
 * Implements hook_preprocess_paragraph().
 */
function openy_gated_content_preprocess_paragraph(&$variables) {
  if (!isset($variables['paragraph'])) {
    return;
  }
  $paragraphs_list = ['gated_content', 'gated_content_login'];
  if (!in_array($variables['paragraph']->getType(), $paragraphs_list)) {
    return;
  }

  $variables['#cache']['tags'][] = 'config:openy_gated_content.settings';
  $variables['#cache']['tags'][] = 'config:openy_gc_auth.settings';
  $active_provider = \Drupal::config('openy_gc_auth.settings')->get('active_provider');
  $identityProviderManager = \Drupal::service('plugin.manager.gc_identity_provider');
  $plugin_definition = $identityProviderManager->getDefinition($active_provider, FALSE);
  if (!$plugin_definition) {
    return;
  }

  $plugin_instance = $identityProviderManager->createInstance($active_provider);
  $app_config = \Drupal::config('openy_gated_content.settings')->getOriginal();

  // Give ability for 3rd party modules to alter data for the js app.
  \Drupal::moduleHandler()->alter('virtual_y_app_settings', $app_config);

  $variables['app_settings'] = json_encode($app_config);

  if ($variables['paragraph']->getType() === 'gated_content') {
    $backgroundImage = '';
    if ($mediaImage = $variables['paragraph']->field_prgf_image->entity) {
      $display_options = EntityViewDisplay::collectRenderDisplay($variables['paragraph'], 'default')
        ->getComponent('field_prgf_image');
      $image_style = \Drupal::service('entity_type.manager')->getStorage('image_style')
        ->load($display_options['settings']['image_style']);
      $backgroundImage = $image_style->buildUrl($mediaImage->field_media_image->entity->uri->value);
    }

    if (empty($backgroundImage)) {
      $file = 'base://' . \Drupal::service('extension.list.module')->getPath('openy_gated_content') . '/assets/img/paragraph-headline.png';
      $backgroundImage = Url::fromUri($file)->setAbsolute()->toString();
    }

    $headline = [
      'title' => $variables['paragraph']->field_prgf_title->value,
      'description' => $variables['paragraph']->field_prgf_description->value,
      'backgroundImage' => $backgroundImage,
    ];

    if ($variables['paragraph']->field_prgf_link->title) {
      $headline['linkText'] = $variables['paragraph']->field_prgf_link->title;
      $headline['linkUrl'] = Url::fromUri($variables['paragraph']->field_prgf_link->uri)->toString();
    }

    $variables['headline'] = json_encode($headline);
  }

  $variables['#cache']['tags'][] = 'config:' . $plugin_instance->getConfigName();
}

/**
 * Implements hook_preprocess_html().
 *
 * Set 'openy-gated-content' body class
 * if gated_content paragraph is used on page.
 */
function openy_gated_content_preprocess_html(&$variables) {
  $node = \Drupal::routeMatch()->getParameter('node');
  if ($node instanceof NodeInterface) {
    if ($node->hasField('field_content')) {
      foreach ($node->field_content as $field_item) {
        if ($field_item->entity->bundle() === 'gated_content') {
          $variables['attributes']['class'][] = openy_gated_content_get_base_theme() . '-based';
          $variables['attributes']['class'][] = 'openy-gated-content';

          if (openy_gated_content_get_base_theme() === 'openy_rose') {
            $variables['#attached']['library'][] = 'openy_gated_content/openy-rose-menu';
          }
        }
      }
    }

    if ($node->hasField('field_bottom_content')) {
      foreach ($node->field_bottom_content as $field_item) {
        if ($field_item->entity->bundle() === 'gated_content') {
          $variables['attributes']['class'][] = openy_gated_content_get_base_theme() . '-based';
          $variables['attributes']['class'][] = 'openy-gated-content';

          if (openy_gated_content_get_base_theme() === 'openy_rose') {
            $variables['#attached']['library'][] = 'openy_gated_content/openy-rose-menu';
          }
        }
      }
    }
  }
}

/**
 * Return base theme name.
 */
function openy_gated_content_get_base_theme() {
  $activeTheme = \Drupal::service('theme.manager')->getActiveTheme();
  if ($extensions = $activeTheme->getBaseThemeExtensions()) {
    $names = array_keys($extensions);
    return end($names);
  }
  return $activeTheme->getName();
}

/**
 * Implements hook_jsonapi_ENTITY_TYPE_filter_access().
 *
 * Without this hook there no access to filter by date in
 * JSON API for eventinstance.
 *
 * @see https://www.drupal.org/project/jsonapi/issues/3037519
 */
function openy_gated_content_jsonapi_eventinstance_filter_access(EntityTypeInterface $entity_type, AccountInterface $account) {
  return ([
    JSONAPI_FILTER_AMONG_ALL => AccessResult::allowedIfHasPermission($account, 'view eventinstance entity'),
    JSONAPI_FILTER_AMONG_PUBLISHED => AccessResult::allowedIfHasPermission($account, 'view eventinstance entity'),
    JSONAPI_FILTER_AMONG_OWN => AccessResult::allowedIfHasPermission($account, 'view eventinstance entity'),
  ]);
}

/**
 * Implements hook_jsonapi_ENTITY_TYPE_filter_access().
 *
 * Without this hook there no access to filter by parent category in
 * JSON API for eventinstance.
 *
 * @see https://www.drupal.org/project/jsonapi/issues/3037519
 */
function openy_gated_content_jsonapi_eventseries_filter_access(EntityTypeInterface $entity_type, AccountInterface $account) {
  return ([
    JSONAPI_FILTER_AMONG_ALL => AccessResult::allowedIfHasPermission($account, 'view eventseries entity'),
    JSONAPI_FILTER_AMONG_PUBLISHED => AccessResult::allowedIfHasPermission($account, 'view eventseries entity'),
    JSONAPI_FILTER_AMONG_OWN => AccessResult::allowedIfHasPermission($account, 'view eventseries entity'),
  ]);
}

/**
 * Implements hook_jsonapi_ENTITY_TYPE_filter_access().
 *
 * Without this hook there no access to filter by instructor in
 * JSON API for eventinstance.
 *
 * @see https://www.drupal.org/project/jsonapi/issues/3037519
 */
function openy_gated_content_jsonapi_taxonomy_term_filter_access(EntityTypeInterface $entity_type, AccountInterface $account) {
  return ([
    JSONAPI_FILTER_AMONG_ALL => AccessResult::allowedIfHasPermission($account, 'access content'),
    JSONAPI_FILTER_AMONG_PUBLISHED => AccessResult::allowedIfHasPermission($account, 'access content'),
    JSONAPI_FILTER_AMONG_OWN => AccessResult::allowedIfHasPermission($account, 'access content'),
  ]);
}

/**
 * Implements hook_form_alter().
 */
function openy_gated_content_form_alter(&$form, FormStateInterface $form_state, $form_id) {
  $event_series_forms = [
    'eventseries_live_stream_edit_form',
    'eventseries_virtual_meeting_edit_form',
  ];
  if (in_array($form_id, $event_series_forms)) {
    // Disable rebuild form.
    $form['#validate'][] = '_openy_gated_content_form_eventseries_live_stream_validate';
    // We need to clear JSON API cache bin on submit.
    $form['actions']['submit']['#submit'][] = '_openy_gated_content_form_eventseries_live_stream_submit';
  }

  $event_instance_forms = [
    'eventinstance_live_stream_edit_form',
    'eventinstance_virtual_meeting_edit_form',
  ];
  if (in_array($form_id, $event_instance_forms)) {
    // Collapse field_inheritance by default in event instance edit form.
    $form['field_inheritance']['#open'] = FALSE;
  }

  if (!isset($form['field_vy_permission'])) {
    return;
  }

  $gcConfig = \Drupal::config('openy_gated_content.settings')->getRawData();
  $allowedForms = [];
  if (!empty($gcConfig['permissions_entities'])) {
    $permissionEnabledEntities = $gcConfig['permissions_entities'];
    foreach ($permissionEnabledEntities as $entity_key => $bundle_list) {
      foreach ($bundle_list as $bundle) {
        $allowedForms[] = $entity_key . '_' . $bundle . '_form';
        $allowedForms[] = $entity_key . '_' . $bundle . '_edit_form';
        $allowedForms[] = $entity_key . '_' . $bundle . '_add_form';
        // Adding _clone_form into allowedForms array.
        $allowedForms[] = $entity_key . '_' . $bundle . '_clone_form';
      }
    }
  }

  $form['virtual_y_permissions'] = [
    '#type' => 'details',
    '#title' => t('Virtual Y Permissions'),
    '#description' => t('Select user segments that available to see this content.'),
    '#open' => FALSE,
    '#group' => 'advanced',
    '#weight' => 125,
  ];

  $form['field_vy_permission']['#group'] = 'virtual_y_permissions';

  if (!in_array($form_id, $allowedForms)) {
    // Close access to permissions field for all entities except of enabled.
    $form['virtual_y_permissions']['#access'] = FALSE;
    $form['field_vy_permission']['#access'] = FALSE;
    return;
  }

}

/**
 * Custom validation for eventseries_live_stream_edit_form.
 */
function _openy_gated_content_form_eventseries_live_stream_validate(&$form, FormStateInterface $form_state) {
  // This will fix entity save, but disable confirmation step
  // on date change.
  $form_state->setRebuild(FALSE);
}

/**
 * Custom submit handler for eventseries_live_stream_edit_form.
 */
function _openy_gated_content_form_eventseries_live_stream_submit(&$form, FormStateInterface $form_state) {
  \Drupal::cache('jsonapi_normalizations')->deleteAll();
}

/**
 * Implements hook_page_attachments().
 */
function openy_gated_content_page_attachments(array &$attachments) {
  $attachments['#attached']['library'][] = 'openy_gated_content/admin_ui_styles';
  $attachments['#attached']['library'][] = 'openy_gated_content/openy_gated_content_styles';

  if (openy_gated_content_get_base_theme() === 'openy_lily') {
    $attachments['#attached']['library'][] = 'openy_gated_content/openy_lily_styles';
  }
  if (openy_gated_content_get_base_theme() === 'openy_carnation') {
    $attachments['#attached']['library'][] = 'openy_gated_content/openy_carnation_styles';
  }
  if (openy_gated_content_get_base_theme() === 'openy_rose') {
    $attachments['#attached']['library'][] = 'openy_gated_content/openy_rose_styles';
  }
}

/**
 * Implements hook_form_FORM_ID_alter().
 */
function openy_gated_content_form_user_login_form_alter(&$form, FormStateInterface $form_state, $form_id) {
  $form['#validate'][] = 'openy_gated_content_user_login_validation';
}

/**
 * Implements hook_form_FORM_ID_alter().
 */
function openy_gated_content_form_user_pass_alter(&$form, FormStateInterface $form_state, $form_id) {
  $form['#validate'][] = 'openy_gated_content_user_pass_validation';
}

/**
 * Implements hook_form_FORM_ID_alter().
 */
function openy_gated_content_form_taxonomy_term_gc_category_form_alter(&$form, FormStateInterface $form_state) {
  $form['#validate'][] = 'openy_gated_content_taxonomy_term_gc_category_validation';
}

/**
 * Implements hook_form_FORM_ID_alter().
 */
function openy_gated_content_form_taxonomy_term_gc_duration_form_alter(&$form, FormStateInterface $form_state) {
  $form['#validate'][] = 'openy_gated_content_taxonomy_term_gc_duration_validation';
}

/**
 * Implements hook_form_FORM_ID_alter().
 */
function openy_gated_content_form_taxonomy_overview_terms_alter(&$form, FormStateInterface $form_state) {
  $build_info = $form_state->getBuildInfo();
  if (isset($build_info['args'][0]) && $build_info['args'][0] instanceof Vocabulary) {
    /** @var Vocabulary $vocabulary */
    $vocabulary = $build_info['args'][0];
    if ($vocabulary->get('vid') === 'gc_category') {
      $form['#validate'][] = 'openy_gated_content_taxonomy_gc_category_overview_terms_validation';
    }
  }
}

/**
 * Checks if user has related to Virtual Y role.
 */
function openy_gated_content_user_login_validation(array &$form, FormStateInterface $form_state) {
  if (!$form_state->get('uid')) {
    return;
  }
  $account = \Drupal::entityTypeManager()->getStorage('user')->load($form_state->get('uid'));
  if ($account) {
    $roles = $account->getRoles();
    $vy_roles = array_filter($roles, function ($role) {
      return strpos($role, 'virtual_y_') !== FALSE || $role === 'virtual_y';
    });
    if (count($vy_roles) > 0 &&
      count(array_diff($roles, array_merge([AccountInterface::AUTHENTICATED_ROLE], $vy_roles))) === 0
    ) {
      \Drupal::messenger()->addError('Virtual YMCA members are not permitted to use this form. Please contact your branch for assistance or go back to the homepage to log in.');
      throw new AccessDeniedHttpException();
    }
  }
}

/**
 * Checks if user has related to Virtual Y role.
 */
function openy_gated_content_user_pass_validation(array &$form, FormStateInterface $form_state) {
  $account = $form_state->getValue('account');
  if ($account) {
    $roles = $account->getRoles();
    foreach ($roles as $role) {
      if (strpos($role, 'virtual_y_') !== FALSE || $role == 'virtual_y') {
        \Drupal::messenger()->addError('You\'re not allowed to reset password for user with Virtual Y role.');
        throw new AccessDeniedHttpException();
      }
    }
  }
}

/**
 * Implements hook_mail().
 */
function openy_gated_content_mail($key, &$message, $params) {
  switch ($key) {
    case 'welcome_email':
      $token = \Drupal::token();
      $config = \Drupal::config('openy_gated_content.welcome_email_settings');
      $message['from'] = \Drupal::config('system.site')->get('mail');
      $message['subject'] = $token->replace($config->get('email_subject'), $params);
      $message['body'][] = $token->replace($config->get('email_body'), $params);
      break;
  }
}

/**
 * Make sure the terms do not have 2nd level of hierarchy.
 */
function openy_gated_content_taxonomy_term_gc_category_validation(array &$form, FormStateInterface $form_state) {
  $parents = $form_state->getValue('parent');
  $first_item = reset($parents);

  // If current term references only <root> we can be sure the current term is
  // going to have 1 level.
  if (count($parents) == 1 && $first_item === 0) {
    return;
  }

  /** @var TermStorageInterface $terms_storage */
  $terms_storage = \Drupal::entityTypeManager()->getStorage('taxonomy_term');
  foreach (array_keys($parents) as $parent_tid) {
    // If the parents for the current term's parent are not empty, this means
    // the current term is going to have 3rd level. We shouldn't allow it.
    if (!empty($terms_storage->loadParents($parent_tid))) {
      $form_state->setErrorByName('parent', "You are not allowed to have more than 2 levels of Categories terms. Please, adjust current term parent accordingly.");
      break;
    }
  }
}

/**
 * Do not allow duration ranges overlapping.
 */
function openy_gated_content_taxonomy_term_gc_duration_validation(array &$form, FormStateInterface $form_state) {
  $taxonomy_storage = \Drupal::entityTypeManager()->getStorage('taxonomy_term');
  $entity_id = 0;

  /** @var EntityInterface $entity */
  $entity = $form_state->getFormObject()->getEntity();
  if (!$entity->isNew()) {
    $entity_id = $entity->id();
  }

  // We have to make sure there are no overlapping duration terms. In order to
  // do that, let's request all of the duration terms that satisfy the following
  // criteria: "start-1" <= "end-2" && "start-2" <= "end-1".
  // "start-1"
  $min = $form_state->getValue('field_gc_duration_min', [['value' => '']]);
  // "end-1"
  $max = $form_state->getValue('field_gc_duration_max', [['value' => '']]);

  $query = $taxonomy_storage->getQuery()
    ->condition('vid', 'gc_duration')
    ->range(0, 1)
    // "start-2"
    ->condition('field_gc_duration_min', $max[0]['value'], '<=')
    // "end-2"
    ->condition('field_gc_duration_max', $min[0]['value'], '>=');

  // Exclude current duration term.
  if ($entity_id !== 0) {
    $query->condition('tid', $entity_id, '<>');
  }

  $intersection_term_id = $query->execute();

  if (!empty($intersection_term_id)) {
    $intersection_term_id = reset($intersection_term_id);
    $intersection_term = $taxonomy_storage->load($intersection_term_id);

    $form_state->setErrorByName('field_gc_duration_min', t(
      'Given range intersects with the range of the Duration term @link. Please, make sure the newly created Duration range does not overlap existing duration ranges.',
      [
        '@link' => $intersection_term->toLink(NULL, 'edit-form')->toString(),
      ]
    ));
  }
}

/**
 * Make sure the terms do not have 2nd level of hierarchy.
 */
function openy_gated_content_taxonomy_gc_category_overview_terms_validation(array &$form, FormStateInterface $form_state) {
  $terms = $form_state->getValue('terms');

  foreach ($terms as $term_id => $term_info) {
    if ($term_info['term']['depth'] > 1) {
      $form_state->setErrorByName('terms', "You are not allowed to have more than 2 levels of categories. Please, adjust hierarchy accordingly.");
      break;
    }
  }
}

/**
 * Implements hook_entity_field_storage_info().
 */
function openy_gated_content_entity_field_storage_info(EntityTypeInterface $entity_type) {
  $manageable_entity_types = [
    'node',
    'eventseries',
    'eventinstance',
  ];
  if (!in_array($entity_type->id(), $manageable_entity_types)) {
    return [];
  }
  $fields = [];
  $fields['field_vy_permission'] = BaseFieldDefinition::create('string')
    ->setLabel(t('Virtual Y Access Group'))
    ->setCardinality(1)
    ->setSetting('max_length', 255)
    ->setProvider('openy_gated_content')
    ->setName('field_vy_permission')
    ->setTargetEntityTypeId($entity_type->id())
    ->setRequired(FALSE)
    ->setRevisionable(FALSE)
    ->setTranslatable(FALSE)
    ->setDisplayConfigurable('view', FALSE)
    ->setDisplayConfigurable('form', TRUE)
    ->setDisplayOptions('form', [
      'type' => 'virtual_y_roles_select',
      'settings' => [
        'size' => '255',
      ],
    ]);
  if ($entity_type->id() !== 'eventinstance') {
    $fields['field_vy_permission']->setDefaultValue('virtual_y,virtual_y_premium');
  }
  return $fields;
}

/**
 * Implements hook_entity_bundle_field_info().
 */
function openy_gated_content_entity_bundle_field_info(EntityTypeInterface $entity_type, $bundle) {
  $gc_config = \Drupal::config('openy_gated_content.settings')->getRawData();
  if (!empty($gc_config['permissions_entities'])) {
    $permissions_entities = $gc_config['permissions_entities'];
  }
  $entity_type_id = $entity_type->id();
  if (!isset($permissions_entities[$entity_type_id])) {
    return [];
  }
  $managed_bundles = $permissions_entities[$entity_type_id];
  if (!in_array($bundle, $managed_bundles)) {
    return [];
  }
  $fields = [];
  $persistent_map = \Drupal::keyValue('entity.definitions.bundle_field_map');
  foreach (openy_gated_content_entity_field_storage_info($entity_type) as $name => $definition) {
    $fields[$name] = $definition;
    $bundle_field_map = $persistent_map->get($entity_type_id);
    if (!isset($bundle_field_map[$name])) {
      // This field did not exist yet, initialize it with the type and empty
      // bundle list.
      $bundle_field_map[$name] = [
        'type' => $definition->getType(),
        'bundles' => [],
      ];
    }
    $bundle_field_map[$name]['bundles'][$bundle] = $bundle;
    $persistent_map->set($entity_type_id, $bundle_field_map);
  }
  return $fields;
}

/**
 * Implements hook_entity_access().
 */
function openy_gated_content_entity_access(EntityInterface $entity, $operation, AccountInterface $account) {
  return \Drupal::service('class_resolver')
    ->getInstanceFromDefinition(SegmentContentAccessCheck::class)
    ->checkAccess($entity, $operation, $account);

}

/**
 * Implements hook_entity_delete().
 */
function openy_gated_content_entity_delete(EntityInterface $entity) {
  $vy_entity_types = [
    'node' => [
      'vy_blog_post',
      'gc_video',
    ],
    'eventinstance' => [
      'live_stream',
      'virtual_meeting',
    ],
    'taxonomy_term' => [
      'gc_category',
    ],
  ];
  $is_vy_entity = FALSE;
  foreach ($vy_entity_types as $entity_type => $bundles) {
    $is_vy_entity |= $entity->getEntityTypeId() === $entity_type && in_array($entity->bundle(), $bundles);
  }
  if (!$is_vy_entity) {
    return;
  }
  \Drupal::service('class_resolver')
    ->getInstanceFromDefinition(VyFavoriteItemsManager::class)
    ->deleteRelatedFavoriteItems($entity);
}