path: root/core/modules/views/views.module

<?php

/**
 * @file
 */

use Drupal\Core\Database\Query\AlterableInterface;
use Drupal\Core\Form\FormStateInterface;
use Drupal\field\FieldStorageConfigInterface;
use Drupal\views\ViewExecutable;
use Drupal\views\Entity\View;
use Drupal\views\Views;

/**
 * Allows view-based node templates if called from a view.
 *
 * The 'modules/node.views.inc' file is a better place for this, but
 * we haven't got a chance to load that file before Drupal builds the
 * node portion of the theme registry.
 */
function views_preprocess_node(&$variables): void {
  // The 'view' attribute of the node is added in
  // \Drupal\views\Plugin\views\row\EntityRow::preRender().
  if (!empty($variables['node']->view) && $variables['node']->view->storage->id()) {
    $variables['view'] = $variables['node']->view;

    // The view variable is deprecated.
    $variables['deprecations']['view'] = "'view' is deprecated in drupal:11.1.0 and is removed in drupal:12.0.0. There is no replacement. See https://www.drupal.org/node/3459903";

    // If a node is being rendered in a view, and the view does not have a path,
    // prevent drupal from accidentally setting the $page variable:
    if (!empty($variables['view']->current_display)
        && $variables['page']
        && $variables['view_mode'] == 'full'
        && !$variables['view']->display_handler->hasPath()) {
      $variables['page'] = FALSE;
    }
  }
}

/**
 * Allows view-based comment templates if called from a view.
 */
function views_preprocess_comment(&$variables): void {
  // The view data is added to the comment in
  // \Drupal\views\Plugin\views\row\EntityRow::preRender().
  if (!empty($variables['comment']->view) && $variables['comment']->view->storage->id()) {
    $variables['view'] = $variables['comment']->view;
  }
}

/**
 * Adds contextual links associated with a view display to a renderable array.
 *
 * This function should be called when a view is being rendered in a particular
 * location and you want to attach the appropriate contextual links (e.g.,
 * links for editing the view) to it.
 *
 * The function operates by checking the view's display plugin to see if it has
 * defined any contextual links that are intended to be displayed in the
 * requested location; if so, it attaches them. The contextual links intended
 * for a particular location are defined by the 'contextual links' and
 * 'contextual_links_locations' properties in the plugin annotation; as a
 * result, these hook implementations have full control over where and how
 * contextual links are rendered for each display.
 *
 * In addition to attaching the contextual links to the passed-in array (via
 * the standard #contextual_links property), this function also attaches
 * additional information via the #views_contextual_links_info property. This
 * stores an array whose keys are the names of each module that provided
 * views-related contextual links (same as the keys of the #contextual_links
 * array itself) and whose values are themselves arrays whose keys ('location',
 * 'view_name', and 'view_display_id') store the location, name of the view,
 * and display ID that were passed in to this function. This allows you to
 * access information about the contextual links and how they were generated in
 * a variety of contexts where you might be manipulating the renderable array
 * later on (for example, alter hooks which run later during the same page
 * request).
 *
 * @param array $render_element
 *   The renderable array to which contextual links will be added. This array
 *   should be suitable for passing in to
 *   \Drupal\Core\Render\RendererInterface::render() and will normally contain a
 *   representation of the view display whose contextual links are being
 *   requested.
 * @param string $location
 *   The location in which the calling function intends to render the view and
 *   its contextual links. The core system supports three options for this
 *   parameter:
 *   - 'block': Used when rendering a block which contains a view. This
 *     retrieves any contextual links intended to be attached to the block
 *     itself.
 *   - 'page': Used when rendering the main content of a page which contains a
 *     view. This retrieves any contextual links intended to be attached to the
 *     page itself (for example, links which are displayed directly next to the
 *     page title).
 *   - 'view': Used when rendering the view itself, in any context. This
 *     retrieves any contextual links intended to be attached directly to the
 *     view.
 *   If you are rendering a view and its contextual links in another location,
 *   you can pass in a different value for this parameter. However, you will
 *   also need to set 'contextual_links_locations' in your plugin annotation to
 *   indicate which view displays support having their contextual links
 *   rendered in the location you have defined.
 * @param string $display_id
 *   The ID of the display within $view whose contextual links will be added.
 * @param array $view_element
 *   The render array of the view. It should contain the following properties:
 *     - #view_id: The ID of the view.
 *     - #view_display_show_admin_links: A boolean whether the admin links
 *       should be shown.
 *     - #view_display_plugin_id: The plugin ID of the display.
 *
 * @see \Drupal\views\Plugin\Block\ViewsBlock::addContextualLinks()
 * @see template_preprocess_views_view()
 */
function views_add_contextual_links(&$render_element, $location, $display_id, ?array $view_element = NULL): void {
  if (!isset($view_element)) {
    $view_element = $render_element;
  }
  $view_element['#cache_properties'] = ['view_id', 'view_display_show_admin_links', 'view_display_plugin_id'];
  $view_id = $view_element['#view_id'];
  $show_admin_links = $view_element['#view_display_show_admin_links'];
  $display_plugin_id = $view_element['#view_display_plugin_id'];

  // Do not do anything if the view is configured to hide its administrative
  // links or if the Contextual Links module is not enabled.
  if (\Drupal::moduleHandler()->moduleExists('contextual') && $show_admin_links) {
    // Also do not do anything if the display plugin has not defined any
    // contextual links that are intended to be displayed in the requested
    // location.
    $plugin = Views::pluginManager('display')->getDefinition($display_plugin_id);
    // If contextual_links_locations are not set, provide a sane default. (To
    // avoid displaying any contextual links at all, a display plugin can still
    // set 'contextual_links_locations' to, e.g., {""}.)

    if (!isset($plugin['contextual_links_locations'])) {
      $plugin['contextual_links_locations'] = ['view'];
    }
    elseif ($plugin['contextual_links_locations'] == [] || $plugin['contextual_links_locations'] == ['']) {
      $plugin['contextual_links_locations'] = [];
    }
    else {
      $plugin += ['contextual_links_locations' => ['view']];
    }

    // On exposed_forms blocks contextual links should always be visible.
    $plugin['contextual_links_locations'][] = 'exposed_filter';
    $has_links = !empty($plugin['contextual links']) && !empty($plugin['contextual_links_locations']);
    if ($has_links && in_array($location, $plugin['contextual_links_locations'])) {
      foreach ($plugin['contextual links'] as $group => $link) {
        $args = [];
        $valid = TRUE;
        if (!empty($link['route_parameters_names'])) {
          $view_storage = \Drupal::entityTypeManager()
            ->getStorage('view')
            ->load($view_id);
          foreach ($link['route_parameters_names'] as $parameter_name => $property) {
            // If the plugin is trying to create an invalid contextual link
            // (for example, "path/to/{$view->storage->property}", where
            // $view->storage->{property} does not exist), we cannot construct
            // the link, so we skip it.
            if (!property_exists($view_storage, $property)) {
              $valid = FALSE;
              break;
            }
            else {
              $args[$parameter_name] = $view_storage->get($property);
            }
          }
        }
        // If the link was valid, attach information about it to the renderable
        // array.
        if ($valid) {
          $render_element['#views_contextual_links'] = TRUE;
          $render_element['#contextual_links'][$group] = [
            'route_parameters' => $args,
            'metadata' => [
              'location' => $location,
              'name' => $view_id,
              'display_id' => $display_id,
            ],
          ];
          // If we're setting contextual links on a page, for a page view, for a
          // user that may use contextual links, attach Views' contextual links
          // JavaScript.
          $render_element['#cache']['contexts'][] = 'user.permissions';
        }
      }
    }
  }
}

/**
 * Invalidate the views cache, forcing a rebuild on the next grab of table data.
 */
function views_invalidate_cache(): void {
  // Set the menu as needed to be rebuilt.
  \Drupal::service('router.builder')->setRebuildNeeded();

  $module_handler = \Drupal::moduleHandler();

  // Reset the RouteSubscriber from views.
  \Drupal::getContainer()->get('views.route_subscriber')->reset();

  // Invalidate the block cache to update views block derivatives.
  if ($module_handler->moduleExists('block')) {
    \Drupal::service('plugin.manager.block')->clearCachedDefinitions();
  }

  // Allow modules to respond to the Views cache being cleared.
  $module_handler->invokeAll('views_invalidate_cache');
}

/**
 * Set the current view.
 *
 * Set the current view that is being built/rendered so that it is
 * easy for other modules or items in drupal_eval to identify
 *
 * @return \Drupal\views\ViewExecutable|null|false
 *   The current view object, NULL if no view is set yet,
 *   or FALSE if the view was removed.
 */
function &views_set_current_view($view = NULL) {
  static $cache = NULL;
  if (isset($view)) {
    $cache = $view;
  }

  return $cache;
}

/**
 * Find out what, if any, current view is currently in use.
 *
 * Note that this returns a reference, so be careful! You can unintentionally
 * modify the $view object.
 *
 * @return \Drupal\views\ViewExecutable|null|false
 *   The current view object, NULL if no view is set yet,
 *    or FALSE if the view was removed.
 */
function &views_get_current_view() {
  return views_set_current_view();
}

/**
 * Implements hook_hook_info().
 */
function views_hook_info(): array {
  $hooks = [];

  $hooks += array_fill_keys([
    'views_data',
    'views_data_alter',
    'views_analyze',
    'views_invalidate_cache',
  ], ['group' => 'views']);

  // Register a views_plugins alter hook for all plugin types.
  foreach (ViewExecutable::getPluginTypes() as $type) {
    $hooks['views_plugins_' . $type . '_alter'] = [
      'group' => 'views',
    ];
  }

  $hooks += array_fill_keys([
    'views_query_substitutions',
    'views_form_substitutions',
    'views_pre_view',
    'views_pre_build',
    'views_post_build',
    'views_pre_execute',
    'views_post_execute',
    'views_pre_render',
    'views_post_render',
    'views_query_alter',
  ], ['group' => 'views_execution']);

  $hooks['field_views_data'] = [
    'group' => 'views',
  ];
  $hooks['field_views_data_alter'] = [
    'group' => 'views',
  ];

  return $hooks;
}

/**
 * Returns whether the view is enabled.
 *
 * @param \Drupal\views\Entity\View $view
 *   The view object to check.
 *
 * @return bool
 *   Returns TRUE if a view is enabled, FALSE otherwise.
 */
function views_view_is_enabled(View $view) {
  return $view->status();
}

/**
 * Returns whether the view is disabled.
 *
 * @param \Drupal\views\Entity\View $view
 *   The view object to check.
 *
 * @return bool
 *   Returns TRUE if a view is disabled, FALSE otherwise.
 */
function views_view_is_disabled(View $view) {
  return !$view->status();
}

/**
 * Enables and saves a view.
 *
 * @param \Drupal\views\Entity\View $view
 *   The View object to disable.
 */
function views_enable_view(View $view): void {
  $view->enable()->save();
}

/**
 * Disables and saves a view.
 *
 * @param \Drupal\views\Entity\View $view
 *   The View object to disable.
 */
function views_disable_view(View $view): void {
  $view->disable()->save();
}

/**
 * Replaces the substitutions recursive foreach condition.
 */
function _views_query_tag_alter_condition(AlterableInterface $query, &$conditions, $substitutions): void {
  foreach ($conditions as $condition_id => &$condition) {
    if (is_numeric($condition_id)) {
      if (is_string($condition['field'])) {
        $condition['field'] = str_replace(array_keys($substitutions), array_values($substitutions), $condition['field']);
      }
      elseif (is_object($condition['field'])) {
        $sub_conditions = &$condition['field']->conditions();
        _views_query_tag_alter_condition($query, $sub_conditions, $substitutions);
      }
      // $condition['value'] is a subquery so alter the subquery recursive.
      // Therefore make sure to get the metadata of the main query.
      if (is_object($condition['value'])) {
        $subquery = $condition['value'];
        $subquery->addMetaData('views_substitutions', $query->getMetaData('views_substitutions'));
        \Drupal::moduleHandler()->invoke('views', 'query_views_alter', [$condition['value']]);
      }
      elseif (isset($condition['value'])) {
        // We can not use a simple str_replace() here because it always returns
        // a string and we have to keep the type of the condition value intact.
        if (is_array($condition['value'])) {
          foreach ($condition['value'] as &$value) {
            if (is_string($value)) {
              $value = str_replace(array_keys($substitutions), array_values($substitutions), $value);
            }
          }
        }
        elseif (is_string($condition['value'])) {
          $condition['value'] = str_replace(array_keys($substitutions), array_values($substitutions), $condition['value']);
        }
      }
    }
  }
}

/**
 * Embed a view using a PHP snippet.
 *
 * This function is meant to be called from PHP snippets, should one wish to
 * embed a view in a node or something. It's meant to provide the simplest
 * solution and doesn't really offer a lot of options, but breaking the function
 * apart is pretty easy, and this provides a worthwhile guide to doing so.
 *
 * Note that this function does NOT display the title of the view. If you want
 * to do that, you will need to do what this function does manually, by
 * loading the view, getting the preview and then getting $view->getTitle().
 *
 * @param string $name
 *   The name of the view to embed.
 * @param string $display_id
 *   The display id to embed. If unsure, use 'default', as it will always be
 *   valid. But things like 'page' or 'block' should work here.
 * @param mixed ...$args
 *   Any additional parameters will be passed as arguments.
 *
 * @return array|null
 *   A renderable array containing the view output or NULL if the display ID
 *   of the view to be executed doesn't exist.
 */
function views_embed_view($name, $display_id = 'default', ...$args) {
  $view = Views::getView($name);
  if (!$view || !$view->access($display_id)) {
    return;
  }

  return [
    '#type' => 'view',
    '#name' => $name,
    '#display_id' => $display_id,
    '#arguments' => $args,
  ];
}

/**
 * Get the result of a view.
 *
 * @param string $name
 *   The name of the view to retrieve the data from.
 * @param string $display_id
 *   The display ID. On the edit page for the view in question, you'll find a
 *   list of displays at the left side of the control area. "Default" will be at
 *   the top of that list. Hover your cursor over the name of the display you
 *   want to use. A URL will appear in the status bar of your browser. This is
 *   usually at the bottom of the window, in the chrome. Everything after
 *   #views-tab- is the display ID, e.g. page_1.
 * @param mixed ...$args
 *   Any additional parameters will be passed as arguments.
 *
 * @return array
 *   An array containing an object for each view item.
 */
function views_get_view_result($name, $display_id = NULL, ...$args) {
  $view = Views::getView($name);
  if (is_object($view)) {
    if (is_array($args)) {
      $view->setArguments($args);
    }
    if (is_string($display_id)) {
      $view->setDisplay($display_id);
    }
    else {
      $view->initDisplay();
    }
    $view->preExecute();
    $view->execute();
    return $view->result;
  }
  else {
    return [];
  }
}

/**
 * Validation callback for query tags.
 */
function views_element_validate_tags($element, FormStateInterface $form_state): void {
  $values = array_map('trim', explode(',', $element['#value']));
  foreach ($values as $value) {
    if (preg_match("/[^a-z_]/", $value)) {
      $form_state->setError($element, t('The query tags may only contain lower-case alphabetical characters and underscores.'));
      return;
    }
  }
}

/**
 * Determines whether the entity type the field appears in is SQL based.
 *
 * @param \Drupal\field\FieldStorageConfigInterface $field_storage
 *   The field storage definition.
 *
 * @return \Drupal\Core\Entity\Sql\SqlContentEntityStorage
 *   Returns the entity type storage if supported.
 *
 * @deprecated in drupal:11.2.0 and is removed from drupal:12.0.0. Use
 * \Drupal::service('views.field_data_provider')
 * ->getSqlStorageForField($field_storage); instead.
 * @see https://www.drupal.org/node/3489502
 */
function _views_field_get_entity_type_storage(FieldStorageConfigInterface $field_storage) {
  @trigger_error('_views_field_get_entity_type_storage() is deprecated in drupal:11.2.0 and is removed from drupal:12.0.0. Use \Drupal::service(\'views.field_data_provider\')->getSqlStorageForField($field_storage). See https://www.drupal.org/node/3489502', E_USER_DEPRECATED);
  return \Drupal::service('views.field_data_provider')->getSqlStorageForField($field_storage);
}

/**
 * Default views data implementation for a field.
 *
 * @param \Drupal\field\FieldStorageConfigInterface $field_storage
 *   The field definition.
 *
 * @return array
 *   The default views data for the field.
 *
 * @deprecated in drupal:11.2.0 and is removed from drupal:12.0.0. Use
 * \Drupal::service('views.field_data_provider')
 * ->defaultFieldImplementation($field_storage); instead.
 * @see https://www.drupal.org/node/3489502
 */
function views_field_default_views_data(FieldStorageConfigInterface $field_storage) {
  @trigger_error('views_field_default_views_data() is deprecated in drupal:11.2.0 and is removed from drupal:12.0.0. Use \Drupal::service(\'views.field_data_provider\')->defaultFieldImplementation($field_storage). See https://www.drupal.org/node/3489502', E_USER_DEPRECATED);
  return \Drupal::service('views.field_data_provider')->defaultFieldImplementation($field_storage);
}

/**
 * Returns the label of a certain field.
 *
 * Therefore it looks up in all bundles to find the most used field.
 *
 * @deprecated in drupal:11.2.0 and is removed from drupal:12.0.0. Use
 *   \Drupal::service('entity_field.manager')->getFieldLabels() instead.
 *
 * @see https://www.drupal.org/node/3489411
 */
function views_entity_field_label($entity_type, $field_name) {
  @trigger_error("views_entity_field_label() is deprecated in drupal:11.2.0 and is removed from drupal:12.0.0. Use \Drupal::service('entity_field.manager')->getFieldLabels(). See https://www.drupal.org/node/3489411", E_USER_DEPRECATED);
  return \Drupal::service('entity_field.manager')->getFieldLabels($entity_type, $field_name);
}