Code Coverage |
||||||||||
Classes and Traits |
Functions and Methods |
Lines |
||||||||
| Total | |
0.00% |
0 / 1 |
|
20.00% |
4 / 20 |
CRAP | |
16.34% |
25 / 153 |
| Views | |
0.00% |
0 / 1 |
|
20.00% |
4 / 20 |
2387.00 | |
16.34% |
25 / 153 |
| viewsData | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| viewsDataHelper | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| executableFactory | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| analyzer | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| pluginManager | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| handlerManager | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| getView | |
0.00% |
0 / 1 |
2.06 | |
75.00% |
3 / 4 |
|||
| fetchPluginNames | |
0.00% |
0 / 1 |
110 | |
0.00% |
0 / 11 |
|||
| getPluginDefinitions | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 4 |
|||
| getEnabledDisplayExtenders | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| getApplicableViews | |
100.00% |
1 / 1 |
8 | |
100.00% |
16 / 16 |
|||
| getAllViews | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| getEnabledViews | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 4 |
|||
| getDisabledViews | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 4 |
|||
| getViewsAsOptions | |
0.00% |
0 / 1 |
210 | |
0.00% |
0 / 27 |
|||
| pluginList | |
0.00% |
0 / 1 |
90 | |
0.00% |
0 / 20 |
|||
| getHandlerTypes | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 46 |
|||
| getPluginTypes | |
0.00% |
0 / 1 |
4.12 | |
50.00% |
2 / 4 |
|||
| anonymous function | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| t | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 3 |
|||
| <?php | |
| /** | |
| * @file | |
| * Contains \Drupal\views\Views. | |
| */ | |
| 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 = 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(); | |
| } | |
| // Return views with display ids. | |
| 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); | |
| } | |
| } |