class Views in Zircon Profile 8

Static service container wrapper for views.

Hierarchy

• class \Drupal\views\Views

205 files declare their use of Views

AccessPermissionTest.php in core/modules/user/src/Tests/Views/AccessPermissionTest.php

Contains \Drupal\user\Tests\Views\AccessPermissionTest.

AccessRoleTest.php in core/modules/user/src/Tests/Views/AccessRoleTest.php

Contains \Drupal\user\Tests\Views\AccessRoleTest.

AccessTest.php in core/modules/views/src/Tests/Plugin/AccessTest.php

Contains \Drupal\views\Tests\Plugin\AccessTest.

AddHandler.php in core/modules/views_ui/src/Form/Ajax/AddHandler.php

Contains \Drupal\views_ui\Form\Ajax\AddHandler.

AdvancedSettingsForm.php in core/modules/views_ui/src/Form/AdvancedSettingsForm.php

Contains \Drupal\views_ui\Form\AdvancedSettingsForm.

... See full list

3 string references to 'Views'

views.info.yml in core/modules/views/views.info.yml

core/modules/views/views.info.yml

views_ui.links.menu.yml in core/modules/views_ui/views_ui.links.menu.yml

core/modules/views_ui/views_ui.links.menu.yml

views_ui.routing.yml in core/modules/views_ui/views_ui.routing.yml

core/modules/views_ui/views_ui.routing.yml

File

core/modules/views/src/Views.php, line 13

Contains \Drupal\views\Views.

Namespace

Drupal\views

class Views {

  /**
   * The translation manager.
   *
   * @var \Drupal\Core\StringTranslation\TranslationInterface
   */
  protected static $translationManager;

  /**
   * A static cache for handler types data.
   *
   * @var array
   */
  protected static $handlerTypes;

  /**
   * A list of all available views plugin types.
   *
   * @var array
   */
  protected static $plugins = array(
    'access' => 'plugin',
    'area' => 'handler',
    'argument' => 'handler',
    'argument_default' => 'plugin',
    'argument_validator' => 'plugin',
    'cache' => 'plugin',
    'display_extender' => 'plugin',
    'display' => 'plugin',
    'exposed_form' => 'plugin',
    'field' => 'handler',
    'filter' => 'handler',
    'join' => 'plugin',
    'pager' => 'plugin',
    'query' => 'plugin',
    'relationship' => 'handler',
    'row' => 'plugin',
    'sort' => 'handler',
    'style' => 'plugin',
    'wizard' => 'plugin',
  );

  /**
   * Returns the views data service.
   *
   * @return \Drupal\views\ViewsData
   *   Returns a views data cache object.
   */
  public static function viewsData() {
    return \Drupal::service('views.views_data');
  }

  /**
   * Returns the views data helper service.
   *
   * @return \Drupal\views\ViewsData
   *   Returns a views data helper object.
   */
  public static function viewsDataHelper() {
    return \Drupal::service('views.views_data_helper');
  }

  /**
   * Returns the view executable factory service.
   *
   * @return \Drupal\views\ViewExecutableFactory
   *   Returns a views executable factory.
   */
  public static function executableFactory() {
    return \Drupal::service('views.executable');
  }

  /**
   * Returns the view analyzer.
   *
   * @return \Drupal\views\Analyzer
   *   Returns a view analyzer object.
   */
  public static function analyzer() {
    return \Drupal::service('views.analyzer');
  }

  /**
   * Returns the plugin manager for a certain views plugin type.
   *
   * @param string $type
   *   The plugin type, for example filter.
   *
   * @return \Drupal\views\Plugin\ViewsPluginManager
   */
  public static function pluginManager($type) {
    return \Drupal::service('plugin.manager.views.' . $type);
  }

  /**
   * Returns the plugin manager for a certain views handler type.
   *
   * @return \Drupal\views\Plugin\ViewsHandlerManager
   */
  public static function handlerManager($type) {
    return \Drupal::service('plugin.manager.views.' . $type);
  }

  /**
   * Loads a view from configuration and returns its executable object.
   *
   * @param string $id
   *   The view ID to load.
   *
   * @return \Drupal\views\ViewExecutable
   *   A view executable instance, from the loaded entity.
   */
  public static function getView($id) {
    $view = \Drupal::service('entity.manager')
      ->getStorage('view')
      ->load($id);
    if ($view) {
      return static::executableFactory()
        ->get($view);
    }
  }

  /**
   * Fetches a list of all base tables available
   *
   * @param string $type
   *   Either 'display', 'style' or 'row'.
   * @param string $key
   *   For style plugins, this is an optional type to restrict to. May be
   *   'normal', 'summary', 'feed' or others based on the needs of the display.
   * @param array $base
   *   An array of possible base tables.
   *
   * @return
   *   A keyed array of in the form of 'base_table' => 'Description'.
   */
  public static function fetchPluginNames($type, $key = NULL, array $base = array()) {
    $definitions = static::pluginManager($type)
      ->getDefinitions();
    $plugins = array();
    foreach ($definitions as $id => $plugin) {

      // Skip plugins that don't conform to our key, if they have one.
      if ($key && isset($plugin['display_types']) && !in_array($key, $plugin['display_types'])) {
        continue;
      }
      if (empty($plugin['no_ui']) && (empty($base) || empty($plugin['base']) || array_intersect($base, $plugin['base']))) {
        $plugins[$id] = $plugin['title'];
      }
    }
    if (!empty($plugins)) {
      asort($plugins);
      return $plugins;
    }
    return $plugins;
  }

  /**
   * Gets all the views plugin definitions.
   *
   * @return array
   *   An array of plugin definitions for all types.
   */
  public static function getPluginDefinitions() {
    $plugins = array();
    foreach (ViewExecutable::getPluginTypes() as $plugin_type) {
      $plugins[$plugin_type] = static::pluginManager($plugin_type)
        ->getDefinitions();
    }
    return $plugins;
  }

  /**
   * Gets enabled display extenders.
   */
  public static function getEnabledDisplayExtenders() {
    $enabled = array_filter((array) \Drupal::config('views.settings')
      ->get('display_extenders'));
    return array_combine($enabled, $enabled);
  }

  /**
   * Return a list of all view IDs and display IDs that have a particular
   * setting in their display's plugin settings.
   *
   * @param string $type
   *   A flag from the display plugin definitions (e.g, 'uses_menu_links').
   *
   * @return array
   *   A list of arrays containing the $view_id and $display_id.
   * @code
   * array(
   *   array($view_id, $display_id),
   *   array($view_id, $display_id),
   * );
   * @endcode
   */
  public static function getApplicableViews($type) {

    // Get all display plugins which provides the type.
    $display_plugins = static::pluginManager('display')
      ->getDefinitions();
    $plugin_ids = [];
    foreach ($display_plugins as $id => $definition) {
      if (!empty($definition[$type])) {
        $plugin_ids[$id] = $id;
      }
    }
    $entity_ids = \Drupal::service('entity.query')
      ->get('view')
      ->condition('status', TRUE)
      ->condition("display.*.display_plugin", $plugin_ids, 'IN')
      ->execute();
    $result = array();
    foreach (\Drupal::entityManager()
      ->getStorage('view')
      ->loadMultiple($entity_ids) as $view) {

      // Check each display to see if it meets the criteria and is enabled.
      foreach ($view
        ->get('display') as $id => $display) {

        // If the key doesn't exist, enabled is assumed.
        $enabled = !empty($display['display_options']['enabled']) || !array_key_exists('enabled', $display['display_options']);
        if ($enabled && in_array($display['display_plugin'], $plugin_ids)) {
          $result[] = [
            $view
              ->id(),
            $id,
          ];
        }
      }
    }
    return $result;
  }

  /**
   * Returns an array of all views as fully loaded $view objects.
   *
   * @return \Drupal\views\Entity\View[]
   *   An array of loaded view entities.
   */
  public static function getAllViews() {
    return \Drupal::entityManager()
      ->getStorage('view')
      ->loadMultiple();
  }

  /**
   * Returns an array of all enabled views.
   *
   * @return \Drupal\views\Entity\View[]
   *   An array of loaded enabled view entities.
   */
  public static function getEnabledViews() {
    $query = \Drupal::entityQuery('view')
      ->condition('status', TRUE)
      ->execute();
    return \Drupal::entityManager()
      ->getStorage('view')
      ->loadMultiple($query);
  }

  /**
   * Returns an array of all disabled views.
   *
   * @return \Drupal\views\Entity\View[]
   *   An array of loaded disabled view entities.
   */
  public static function getDisabledViews() {
    $query = \Drupal::entityQuery('view')
      ->condition('status', FALSE)
      ->execute();
    return \Drupal::entityManager()
      ->getStorage('view')
      ->loadMultiple($query);
  }

  /**
   * Returns an array of view as options array, that can be used by select,
   * checkboxes and radios as #options.
   *
   * @param bool $views_only
   *  If TRUE, only return views, not displays.
   * @param string $filter
   *  Filters the views on status. Can either be 'all' (default), 'enabled' or
   *  'disabled'
   * @param mixed $exclude_view
   *  view or current display to exclude
   *  either a
   *  - views object (containing $exclude_view->storage->name and $exclude_view->current_display)
   *  - views name as string:  e.g. my_view
   *  - views name and display id (separated by ':'): e.g. my_view:default
   * @param bool $optgroup
   *  If TRUE, returns an array with optgroups for each view (will be ignored for
   *  $views_only = TRUE). Can be used by select
   * @param bool $sort
   *  If TRUE, the list of views is sorted ascending.
   *
   * @return array
   *  an associative array for use in select.
   *  - key: view name and display id separated by ':', or the view name only
   */
  public static function getViewsAsOptions($views_only = FALSE, $filter = 'all', $exclude_view = NULL, $optgroup = FALSE, $sort = FALSE) {

    // Filter the big views array.
    switch ($filter) {
      case 'all':
      case 'disabled':
      case 'enabled':
        $filter = ucfirst($filter);
        $views = call_user_func("static::get{$filter}Views");
        break;
      default:
        return array();
    }

    // Prepare exclude view strings for comparison.
    if (empty($exclude_view)) {
      $exclude_view_name = '';
      $exclude_view_display = '';
    }
    elseif (is_object($exclude_view)) {
      $exclude_view_name = $exclude_view->storage
        ->id();
      $exclude_view_display = $exclude_view->current_display;
    }
    else {

      // Append a ':' to the $exclude_view string so we always have more than one
      // item to explode.
      list($exclude_view_name, $exclude_view_display) = explode(':', "{$exclude_view}:");
    }
    $options = array();
    foreach ($views as $view) {
      $id = $view
        ->id();

      // Return only views.
      if ($views_only && $id != $exclude_view_name) {
        $options[$id] = $view
          ->label();
      }
      else {
        foreach ($view
          ->get('display') as $display_id => $display) {
          if (!($id == $exclude_view_name && $display_id == $exclude_view_display)) {
            if ($optgroup) {
              $options[$id][$id . ':' . $display['id']] = t('@view : @display', array(
                '@view' => $id,
                '@display' => $display['id'],
              ));
            }
            else {
              $options[$id . ':' . $display['id']] = t('View: @view - Display: @display', array(
                '@view' => $id,
                '@display' => $display['id'],
              ));
            }
          }
        }
      }
    }
    if ($sort) {
      ksort($options);
    }
    return $options;
  }

  /**
   * Returns a list of plugins and metadata about them.
   *
   * @return array
   *   An array keyed by PLUGIN_TYPE:PLUGIN_NAME, like 'display:page' or
   *   'pager:full', containing an array with the following keys:
   *   - title: The plugin's title.
   *   - type: The plugin type.
   *   - module: The module providing the plugin.
   *   - views: An array of enabled Views that are currently using this plugin,
   *     keyed by machine name.
   */
  public static function pluginList() {
    $plugin_data = static::getPluginDefinitions();
    $plugins = array();
    foreach (static::getEnabledViews() as $view) {
      foreach ($view
        ->get('display') as $display) {
        foreach ($plugin_data as $type => $info) {
          if ($type == 'display' && isset($display['display_plugin'])) {
            $name = $display['display_plugin'];
          }
          elseif (isset($display['display_options']["{$type}_plugin"])) {
            $name = $display['display_options']["{$type}_plugin"];
          }
          elseif (isset($display['display_options'][$type]['type'])) {
            $name = $display['display_options'][$type]['type'];
          }
          else {
            continue;
          }

          // Key first by the plugin type, then the name.
          $key = $type . ':' . $name;

          // Add info for this plugin.
          if (!isset($plugins[$key])) {
            $plugins[$key] = array(
              'type' => $type,
              'title' => $info[$name]['title'],
              'provider' => $info[$name]['provider'],
              'views' => array(),
            );
          }

          // Add this view to the list for this plugin.
          $plugins[$key]['views'][$view
            ->id()] = $view
            ->id();
        }
      }
    }
    return $plugins;
  }

  /**
   * Provide a list of views handler types used in a view, with some information
   * about them.
   *
   * @return array
   *   An array of associative arrays containing:
   *   - title: The title of the handler type.
   *   - ltitle: The lowercase title of the handler type.
   *   - stitle: A singular title of the handler type.
   *   - lstitle: A singular lowercase title of the handler type.
   *   - plural: Plural version of the handler type.
   *   - (optional) type: The actual internal used handler type. This key is
   *     just used for header,footer,empty to link to the internal type: area.
   */
  public static function getHandlerTypes() {

    // Statically cache this so translation only occurs once per request for all
    // of these values.
    if (!isset(static::$handlerTypes)) {
      static::$handlerTypes = array(
        'field' => array(
          // title
          'title' => static::t('Fields'),
          // Lowercase title for mid-sentence.
          'ltitle' => static::t('fields'),
          // Singular title.
          'stitle' => static::t('Field'),
          // Singular lowercase title for mid sentence
          'lstitle' => static::t('field'),
          'plural' => 'fields',
        ),
        'argument' => array(
          'title' => static::t('Contextual filters'),
          'ltitle' => static::t('contextual filters'),
          'stitle' => static::t('Contextual filter'),
          'lstitle' => static::t('contextual filter'),
          'plural' => 'arguments',
        ),
        'sort' => array(
          'title' => static::t('Sort criteria'),
          'ltitle' => static::t('sort criteria'),
          'stitle' => static::t('Sort criterion'),
          'lstitle' => static::t('sort criterion'),
          'plural' => 'sorts',
        ),
        'filter' => array(
          'title' => static::t('Filter criteria'),
          'ltitle' => static::t('filter criteria'),
          'stitle' => static::t('Filter criterion'),
          'lstitle' => static::t('filter criterion'),
          'plural' => 'filters',
        ),
        'relationship' => array(
          'title' => static::t('Relationships'),
          'ltitle' => static::t('relationships'),
          'stitle' => static::t('Relationship'),
          'lstitle' => static::t('Relationship'),
          'plural' => 'relationships',
        ),
        'header' => array(
          'title' => static::t('Header'),
          'ltitle' => static::t('header'),
          'stitle' => static::t('Header'),
          'lstitle' => static::t('Header'),
          'plural' => 'header',
          'type' => 'area',
        ),
        'footer' => array(
          'title' => static::t('Footer'),
          'ltitle' => static::t('footer'),
          'stitle' => static::t('Footer'),
          'lstitle' => static::t('Footer'),
          'plural' => 'footer',
          'type' => 'area',
        ),
        'empty' => array(
          'title' => static::t('No results behavior'),
          'ltitle' => static::t('no results behavior'),
          'stitle' => static::t('No results behavior'),
          'lstitle' => static::t('No results behavior'),
          'plural' => 'empty',
          'type' => 'area',
        ),
      );
    }
    return static::$handlerTypes;
  }

  /**
   * Returns a list of plugin types.
   *
   * @param string $type
   *   (optional) filter the list of plugins by type. Available options are
   *   'plugin' or 'handler'.
   *
   * @return array
   *   An array of plugin types.
   */
  public static function getPluginTypes($type = NULL) {
    if ($type === NULL) {
      return array_keys(static::$plugins);
    }
    if (!in_array($type, array(
      'plugin',
      'handler',
    ))) {
      throw new \Exception('Invalid plugin type used. Valid types are "plugin" or "handler".');
    }
    return array_keys(array_filter(static::$plugins, function ($plugin_type) use ($type) {
      return $plugin_type == $type;
    }));
  }

  /**
   * Translates a string to the current language or to a given language.
   *
   * See the t() documentation for details.
   */
  protected static function t($string, array $args = array(), array $options = array()) {
    if (empty(static::$translationManager)) {
      static::$translationManager = \Drupal::service('string_translation');
    }
    return static::$translationManager
      ->translate($string, $args, $options);
  }

}

Members

Name	Modifiers	Type	Description	Overrides
Views::$handlerTypes	protected static	property	A static cache for handler types data.
Views::$plugins	protected static	property	A list of all available views plugin types.
Views::$translationManager	protected static	property	The translation manager.
Views::analyzer	public static	function	Returns the view analyzer.
Views::executableFactory	public static	function	Returns the view executable factory service.
Views::fetchPluginNames	public static	function	Fetches a list of all base tables available
Views::getAllViews	public static	function	Returns an array of all views as fully loaded $view objects.
Views::getApplicableViews	public static	function	Return a list of all view IDs and display IDs that have a particular setting in their display's plugin settings.
Views::getDisabledViews	public static	function	Returns an array of all disabled views.
Views::getEnabledDisplayExtenders	public static	function	Gets enabled display extenders.
Views::getEnabledViews	public static	function	Returns an array of all enabled views.
Views::getHandlerTypes	public static	function	Provide a list of views handler types used in a view, with some information about them.
Views::getPluginDefinitions	public static	function	Gets all the views plugin definitions.
Views::getPluginTypes	public static	function	Returns a list of plugin types.
Views::getView	public static	function	Loads a view from configuration and returns its executable object.
Views::getViewsAsOptions	public static	function	Returns an array of view as options array, that can be used by select, checkboxes and radios as #options.
Views::handlerManager	public static	function	Returns the plugin manager for a certain views handler type.
Views::pluginList	public static	function	Returns a list of plugins and metadata about them.
Views::pluginManager	public static	function	Returns the plugin manager for a certain views plugin type.
Views::t	protected static	function	Translates a string to the current language or to a given language.
Views::viewsData	public static	function	Returns the views data service.
Views::viewsDataHelper	public static	function	Returns the views data helper service.