Views.php

<?php

namespace Drupal\views;


/**
 * Static service container wrapper for 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 = [
        '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\ViewsDataHelper
     *   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|null
     *   A view executable instance or NULL if the view does not exist.
     */
    public static function getView($id) {
        $view = \Drupal::entityTypeManager()->getStorage('view')
            ->load($id);
        if ($view) {
            return static::executableFactory()->get($view);
        }
        return NULL;
    }
    
    /**
     * 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 array
     *   A keyed array of in the form of 'base_table' => 'Description'.
     */
    public static function fetchPluginNames($type, $key = NULL, array $base = []) {
        $definitions = static::pluginManager($type)->getDefinitions();
        $plugins = [];
        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 = [];
        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);
    }
    
    /**
     * Gets view and display IDs for a given setting in display plugin settings.
     *
     * 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
     * [
     *   [$view_id, $display_id],
     *   [$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::entityQuery('view')->condition('status', TRUE)
            ->condition("display.*.display_plugin", $plugin_ids, 'IN')
            ->execute();
        $result = [];
        foreach (\Drupal::entityTypeManager()->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::entityTypeManager()->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::entityTypeManager()->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::entityTypeManager()->getStorage('view')
            ->loadMultiple($query);
    }
    
    /**
     * Returns an array of view as options array.
     *
     * This array 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 \Drupal\views\ViewExecutable|string $exclude_view
     *   View or current display to exclude.
     *   Either a:
     *   - Views executable object
     *   - views name, for example 'my_view'
     *   - views name and display ID separated by ':', for example 'my_view:page'
     * @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::class . "::get{$filter}Views");
                break;
            default:
                return [];
        }
        // 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.
            [
                $exclude_view_name,
                $exclude_view_display,
            ] = explode(':', "{$exclude_view}:");
        }
        $options = [];
        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', [
                                '@view' => $id,
                                '@display' => $display['id'],
                            ]);
                        }
                        else {
                            $options[$id . ':' . $display['id']] = t('View: @view - Display: @display', [
                                '@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 = [];
        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] = [
                            'type' => $type,
                            'title' => $info[$name]['title'],
                            'provider' => $info[$name]['provider'],
                            'views' => [],
                        ];
                    }
                    // 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.
     *
     * Also provides 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 = [
                'field' => [
                    // 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' => [
                    'title' => static::t('Contextual filters'),
                    'ltitle' => static::t('contextual filters'),
                    'stitle' => static::t('Contextual filter'),
                    'lstitle' => static::t('contextual filter'),
                    'plural' => 'arguments',
                ],
                'sort' => [
                    'title' => static::t('Sort criteria'),
                    'ltitle' => static::t('sort criteria'),
                    'stitle' => static::t('Sort criterion'),
                    'lstitle' => static::t('sort criterion'),
                    'plural' => 'sorts',
                ],
                'filter' => [
                    'title' => static::t('Filter criteria'),
                    'ltitle' => static::t('filter criteria'),
                    'stitle' => static::t('Filter criterion'),
                    'lstitle' => static::t('filter criterion'),
                    'plural' => 'filters',
                ],
                'relationship' => [
                    'title' => static::t('Relationships'),
                    'ltitle' => static::t('relationships'),
                    'stitle' => static::t('Relationship'),
                    'lstitle' => static::t('Relationship'),
                    'plural' => 'relationships',
                ],
                'header' => [
                    'title' => static::t('Header'),
                    'ltitle' => static::t('header'),
                    'stitle' => static::t('Header'),
                    'lstitle' => static::t('Header'),
                    'plural' => 'header',
                    'type' => 'area',
                ],
                'footer' => [
                    'title' => static::t('Footer'),
                    'ltitle' => static::t('footer'),
                    'stitle' => static::t('Footer'),
                    'lstitle' => static::t('Footer'),
                    'plural' => 'footer',
                    'type' => 'area',
                ],
                'empty' => [
                    '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, [
            '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 $options = []) {
        if (empty(static::$translationManager)) {
            static::$translationManager = \Drupal::service('string_translation');
        }
        return static::$translationManager->translate($string, $args, $options);
    }

}