www.aleph1.co.uk Git - yaffs-website/blob - web/core/modules/views/src/EntityViewsData.php

   1 <?php
   2
   3 namespace Drupal\views;
   4
   5 use Drupal\Core\Entity\ContentEntityType;
   6 use Drupal\Core\Entity\EntityHandlerInterface;
   7 use Drupal\Core\Entity\EntityManagerInterface;
   8 use Drupal\Core\Entity\EntityTypeInterface;
   9 use Drupal\Core\Entity\Sql\SqlEntityStorageInterface;
  10 use Drupal\Core\Entity\Sql\TableMappingInterface;
  11 use Drupal\Core\Extension\ModuleHandlerInterface;
  12 use Drupal\Core\Field\FieldDefinitionInterface;
  13 use Drupal\Core\StringTranslation\StringTranslationTrait;
  14 use Drupal\Core\StringTranslation\TranslationInterface;
  15 use Symfony\Component\DependencyInjection\Container;
  16 use Symfony\Component\DependencyInjection\ContainerInterface;
  17
  18 /**
  19  * Provides generic views integration for entities.
  20  */
  21 class EntityViewsData implements EntityHandlerInterface, EntityViewsDataInterface {
  22
  23   use StringTranslationTrait;
  24
  25   /**
  26    * Entity type for this views data handler instance.
  27    *
  28    * @var \Drupal\Core\Entity\EntityTypeInterface
  29    */
  30   protected $entityType;
  31
  32   /**
  33    * The storage used for this entity type.
  34    *
  35    * @var \Drupal\Core\Entity\Sql\SqlEntityStorageInterface
  36    */
  37   protected $storage;
  38
  39   /**
  40    * The module handler.
  41    *
  42    * @var \Drupal\Core\Extension\ModuleHandlerInterface
  43    */
  44   protected $moduleHandler;
  45
  46   /**
  47    * The translation manager.
  48    *
  49    * @var \Drupal\Core\StringTranslation\TranslationInterface
  50    */
  51   protected $translationManager;
  52
  53   /**
  54    * The field storage definitions for all base fields of the entity type.
  55    *
  56    * @var \Drupal\Core\Field\FieldStorageDefinitionInterface[]
  57    */
  58   protected $fieldStorageDefinitions;
  59
  60   /**
  61    * The entity manager.
  62    *
  63    * @var \Drupal\Core\Entity\EntityManagerInterface
  64    */
  65   protected $entityManager;
  66
  67   /**
  68    * Constructs an EntityViewsData object.
  69    *
  70    * @param \Drupal\Core\Entity\EntityTypeInterface $entity_type
  71    *   The entity type to provide views integration for.
  72    * @param \Drupal\Core\Entity\Sql\SqlEntityStorageInterface $storage_controller
  73    *   The storage handler used for this entity type.
  74    * @param \Drupal\Core\Entity\EntityManagerInterface $entity_manager
  75    *   The entity manager.
  76    * @param \Drupal\Core\Extension\ModuleHandlerInterface $module_handler
  77    *   The module handler.
  78    * @param \Drupal\Core\StringTranslation\TranslationInterface $translation_manager
  79    *   The translation manager.
  80    */
  81   public function __construct(EntityTypeInterface $entity_type, SqlEntityStorageInterface $storage_controller, EntityManagerInterface $entity_manager, ModuleHandlerInterface $module_handler, TranslationInterface $translation_manager) {
  82     $this->entityType = $entity_type;
  83     $this->entityManager = $entity_manager;
  84     $this->storage = $storage_controller;
  85     $this->moduleHandler = $module_handler;
  86     $this->setStringTranslation($translation_manager);
  87   }
  88
  89   /**
  90    * {@inheritdoc}
  91    */
  92   public static function createInstance(ContainerInterface $container, EntityTypeInterface $entity_type) {
  93     return new static(
  94       $entity_type,
  95       $container->get('entity.manager')->getStorage($entity_type->id()),
  96       $container->get('entity.manager'),
  97       $container->get('module_handler'),
  98       $container->get('string_translation'),
  99       $container->get('typed_data_manager')
 100     );
 101   }
 102
 103   /**
 104    * Gets the field storage definitions.
 105    *
 106    * @return \Drupal\Core\Field\FieldStorageDefinitionInterface[]
 107    */
 108   protected function getFieldStorageDefinitions() {
 109     if (!isset($this->fieldStorageDefinitions)) {
 110       $this->fieldStorageDefinitions = $this->entityManager->getFieldStorageDefinitions($this->entityType->id());
 111     }
 112     return $this->fieldStorageDefinitions;
 113   }
 114
 115   /**
 116    * {@inheritdoc}
 117    */
 118   public function getViewsData() {
 119     $data = [];
 120
 121     $base_table = $this->entityType->getBaseTable() ?: $this->entityType->id();
 122     $views_revision_base_table = NULL;
 123     $revisionable = $this->entityType->isRevisionable();
 124     $base_field = $this->entityType->getKey('id');
 125
 126     $revision_table = '';
 127     if ($revisionable) {
 128       $revision_table = $this->entityType->getRevisionTable() ?: $this->entityType->id() . '_revision';
 129     }
 130
 131     $translatable = $this->entityType->isTranslatable();
 132     $data_table = '';
 133     if ($translatable) {
 134       $data_table = $this->entityType->getDataTable() ?: $this->entityType->id() . '_field_data';
 135     }
 136
 137     // Some entity types do not have a revision data table defined, but still
 138     // have a revision table name set in
 139     // \Drupal\Core\Entity\Sql\SqlContentEntityStorage::initTableLayout() so we
 140     // apply the same kind of logic.
 141     $revision_data_table = '';
 142     if ($revisionable && $translatable) {
 143       $revision_data_table = $this->entityType->getRevisionDataTable() ?: $this->entityType->id() . '_field_revision';
 144     }
 145     $revision_field = $this->entityType->getKey('revision');
 146
 147     // Setup base information of the views data.
 148     $data[$base_table]['table']['group'] = $this->entityType->getLabel();
 149     $data[$base_table]['table']['provider'] = $this->entityType->getProvider();
 150
 151     $views_base_table = $base_table;
 152     if ($data_table) {
 153       $views_base_table = $data_table;
 154     }
 155     $data[$views_base_table]['table']['base'] = [
 156       'field' => $base_field,
 157       'title' => $this->entityType->getLabel(),
 158       'cache_contexts' => $this->entityType->getListCacheContexts(),
 159     ];
 160     $data[$base_table]['table']['entity revision'] = FALSE;
 161
 162     if ($label_key = $this->entityType->getKey('label')) {
 163       if ($data_table) {
 164         $data[$views_base_table]['table']['base']['defaults'] = [
 165           'field' => $label_key,
 166           'table' => $data_table,
 167         ];
 168       }
 169       else {
 170         $data[$views_base_table]['table']['base']['defaults'] = [
 171           'field' => $label_key,
 172         ];
 173       }
 174     }
 175
 176     // Entity types must implement a list_builder in order to use Views'
 177     // entity operations field.
 178     if ($this->entityType->hasListBuilderClass()) {
 179       $data[$base_table]['operations'] = [
 180         'field' => [
 181           'title' => $this->t('Operations links'),
 182           'help' => $this->t('Provides links to perform entity operations.'),
 183           'id' => 'entity_operations',
 184         ],
 185       ];
 186     }
 187
 188     if ($this->entityType->hasViewBuilderClass()) {
 189       $data[$base_table]['rendered_entity'] = [
 190         'field' => [
 191           'title' => $this->t('Rendered entity'),
 192           'help' => $this->t('Renders an entity in a view mode.'),
 193           'id' => 'rendered_entity',
 194         ],
 195       ];
 196     }
 197
 198     // Setup relations to the revisions/property data.
 199     if ($data_table) {
 200       $data[$base_table]['table']['join'][$data_table] = [
 201         'left_field' => $base_field,
 202         'field' => $base_field,
 203         'type' => 'INNER'
 204       ];
 205       $data[$data_table]['table']['group'] = $this->entityType->getLabel();
 206       $data[$data_table]['table']['provider'] = $this->entityType->getProvider();
 207       $data[$data_table]['table']['entity revision'] = FALSE;
 208     }
 209     if ($revision_table) {
 210       $data[$revision_table]['table']['group'] = $this->t('@entity_type revision', ['@entity_type' => $this->entityType->getLabel()]);
 211       $data[$revision_table]['table']['provider'] = $this->entityType->getProvider();
 212
 213       $views_revision_base_table = $revision_table;
 214       if ($revision_data_table) {
 215         $views_revision_base_table = $revision_data_table;
 216       }
 217       $data[$views_revision_base_table]['table']['entity revision'] = TRUE;
 218       $data[$views_revision_base_table]['table']['base'] = [
 219         'field' => $revision_field,
 220         'title' => $this->t('@entity_type revisions', ['@entity_type' => $this->entityType->getLabel()]),
 221       ];
 222       // Join the revision table to the base table.
 223       $data[$views_revision_base_table]['table']['join'][$views_base_table] = [
 224         'left_field' => $revision_field,
 225         'field' => $revision_field,
 226         'type' => 'INNER',
 227       ];
 228
 229       if ($revision_data_table) {
 230         $data[$revision_data_table]['table']['group'] = $this->t('@entity_type revision', ['@entity_type' => $this->entityType->getLabel()]);
 231         $data[$revision_data_table]['table']['entity revision'] = TRUE;
 232
 233         $data[$revision_table]['table']['join'][$revision_data_table] = [
 234           'left_field' => $revision_field,
 235           'field' => $revision_field,
 236           'type' => 'INNER',
 237         ];
 238       }
 239     }
 240
 241     $this->addEntityLinks($data[$base_table]);
 242
 243     // Load all typed data definitions of all fields. This should cover each of
 244     // the entity base, revision, data tables.
 245     $field_definitions = $this->entityManager->getBaseFieldDefinitions($this->entityType->id());
 246     /** @var \Drupal\Core\Entity\Sql\DefaultTableMapping $table_mapping */
 247     if ($table_mapping = $this->storage->getTableMapping($field_definitions)) {
 248       // Fetch all fields that can appear in both the base table and the data
 249       // table.
 250       $entity_keys = $this->entityType->getKeys();
 251       $duplicate_fields = array_intersect_key($entity_keys, array_flip(['id', 'revision', 'bundle']));
 252       // Iterate over each table we have so far and collect field data for each.
 253       // Based on whether the field is in the field_definitions provided by the
 254       // entity manager.
 255       // @todo We should better just rely on information coming from the entity
 256       //   storage.
 257       // @todo https://www.drupal.org/node/2337511
 258       foreach ($table_mapping->getTableNames() as $table) {
 259         foreach ($table_mapping->getFieldNames($table) as $field_name) {
 260           // To avoid confusing duplication in the user interface, for fields
 261           // that are on both base and data tables, only add them on the data
 262           // table (same for revision vs. revision data).
 263           if ($data_table && ($table === $base_table || $table === $revision_table) && in_array($field_name, $duplicate_fields)) {
 264             continue;
 265           }
 266           $this->mapFieldDefinition($table, $field_name, $field_definitions[$field_name], $table_mapping, $data[$table]);
 267         }
 268       }
 269
 270       foreach ($field_definitions as $field_definition) {
 271         if ($table_mapping->requiresDedicatedTableStorage($field_definition->getFieldStorageDefinition())) {
 272           $table = $table_mapping->getDedicatedDataTableName($field_definition->getFieldStorageDefinition());
 273
 274           $data[$table]['table']['group'] = $this->entityType->getLabel();
 275           $data[$table]['table']['provider'] = $this->entityType->getProvider();
 276           $data[$table]['table']['join'][$views_base_table] = [
 277             'left_field' => $base_field,
 278             'field' => 'entity_id',
 279             'extra' => [
 280               ['field' => 'deleted', 'value' => 0, 'numeric' => TRUE],
 281             ],
 282           ];
 283
 284           if ($revisionable) {
 285             $revision_table = $table_mapping->getDedicatedRevisionTableName($field_definition->getFieldStorageDefinition());
 286
 287             $data[$revision_table]['table']['group'] = $this->t('@entity_type revision', ['@entity_type' => $this->entityType->getLabel()]);
 288             $data[$revision_table]['table']['provider'] = $this->entityType->getProvider();
 289             $data[$revision_table]['table']['join'][$views_revision_base_table] = [
 290               'left_field' => $revision_field,
 291               'field' => 'entity_id',
 292               'extra' => [
 293                 ['field' => 'deleted', 'value' => 0, 'numeric' => TRUE],
 294               ],
 295             ];
 296           }
 297         }
 298       }
 299     }
 300
 301     // Add the entity type key to each table generated.
 302     $entity_type_id = $this->entityType->id();
 303     array_walk($data, function(&$table_data) use ($entity_type_id){
 304       $table_data['table']['entity type'] = $entity_type_id;
 305     });
 306
 307     return $data;
 308   }
 309
 310   /**
 311    * Sets the entity links in case corresponding link templates exist.
 312    *
 313    * @param array $data
 314    *   The views data of the base table.
 315    */
 316   protected function addEntityLinks(array &$data) {
 317     $entity_type_id = $this->entityType->id();
 318     $t_arguments = ['@entity_type_label' => $this->entityType->getLabel()];
 319     if ($this->entityType->hasLinkTemplate('canonical')) {
 320       $data['view_' . $entity_type_id] = [
 321         'field' => [
 322           'title' => $this->t('Link to @entity_type_label', $t_arguments),
 323           'help' => $this->t('Provide a view link to the @entity_type_label.', $t_arguments),
 324           'id' => 'entity_link',
 325         ],
 326       ];
 327     }
 328     if ($this->entityType->hasLinkTemplate('edit-form')) {
 329       $data['edit_' . $entity_type_id] = [
 330         'field' => [
 331           'title' => $this->t('Link to edit @entity_type_label', $t_arguments),
 332           'help' => $this->t('Provide an edit link to the @entity_type_label.', $t_arguments),
 333           'id' => 'entity_link_edit',
 334         ],
 335       ];
 336     }
 337     if ($this->entityType->hasLinkTemplate('delete-form')) {
 338       $data['delete_' . $entity_type_id] = [
 339         'field' => [
 340           'title' => $this->t('Link to delete @entity_type_label', $t_arguments),
 341           'help' => $this->t('Provide a delete link to the @entity_type_label.', $t_arguments),
 342           'id' => 'entity_link_delete',
 343         ],
 344       ];
 345     }
 346   }
 347
 348   /**
 349    * Puts the views data for a single field onto the views data.
 350    *
 351    * @param string $table
 352    *   The table of the field to handle.
 353    * @param string $field_name
 354    *   The name of the field to handle.
 355    * @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
 356    *   The field definition defined in Entity::baseFieldDefinitions()
 357    * @param \Drupal\Core\Entity\Sql\TableMappingInterface $table_mapping
 358    *   The table mapping information
 359    * @param array $table_data
 360    *   A reference to a specific entity table (for example data_table) inside
 361    *   the views data.
 362    */
 363   protected function mapFieldDefinition($table, $field_name, FieldDefinitionInterface $field_definition, TableMappingInterface $table_mapping, &$table_data) {
 364     // Create a dummy instance to retrieve property definitions.
 365     $field_column_mapping = $table_mapping->getColumnNames($field_name);
 366     $field_schema = $this->getFieldStorageDefinitions()[$field_name]->getSchema();
 367
 368     $field_definition_type = $field_definition->getType();
 369     // Add all properties to views table data. We need an entry for each
 370     // column of each field, with the first one given special treatment.
 371     // @todo Introduce concept of the "main" column for a field, rather than
 372     //   assuming the first one is the main column. See also what the
 373     //   mapSingleFieldViewsData() method does with $first.
 374     $multiple = (count($field_column_mapping) > 1);
 375     $first = TRUE;
 376     foreach ($field_column_mapping as $field_column_name => $schema_field_name) {
 377       $views_field_name = ($multiple) ? $field_name . '__' . $field_column_name : $field_name;
 378       $table_data[$views_field_name] = $this->mapSingleFieldViewsData($table, $field_name, $field_definition_type, $field_column_name, $field_schema['columns'][$field_column_name]['type'], $first, $field_definition);
 379
 380       $table_data[$views_field_name]['entity field'] = $field_name;
 381       $first = FALSE;
 382     }
 383   }
 384
 385   /**
 386    * Provides the views data for a given data type and schema field.
 387    *
 388    * @param string $table
 389    *   The table of the field to handle.
 390    * @param string $field_name
 391    *   The machine name of the field being processed.
 392    * @param string $field_type
 393    *   The type of field being handled.
 394    * @param string $column_name
 395    *   For fields containing multiple columns, the column name being processed.
 396    * @param string $column_type
 397    *   Within the field, the column type being handled.
 398    * @param bool $first
 399    *   TRUE if this is the first column within the field.
 400    * @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
 401    *   The field definition.
 402    *
 403    * @return array
 404    *   The modified views data field definition.
 405    */
 406   protected function mapSingleFieldViewsData($table, $field_name, $field_type, $column_name, $column_type, $first, FieldDefinitionInterface $field_definition) {
 407     $views_field = [];
 408
 409     // Provide a nicer, less verbose label for the first column within a field.
 410     // @todo Introduce concept of the "main" column for a field, rather than
 411     //   assuming the first one is the main column.
 412     if ($first) {
 413       $views_field['title'] = $field_definition->getLabel();
 414     }
 415     else {
 416       $views_field['title'] = $field_definition->getLabel() . " ($column_name)";
 417     }
 418
 419     if ($description = $field_definition->getDescription()) {
 420       $views_field['help'] = $description;
 421     }
 422
 423     // Set up the field, sort, argument, and filters, based on
 424     // the column and/or field data type.
 425     // @todo Allow field types to customize this.
 426     // @see https://www.drupal.org/node/2337515
 427     switch ($field_type) {
 428       // Special case a few field types.
 429       case 'timestamp':
 430       case 'created':
 431       case 'changed':
 432         $views_field['field']['id'] = 'field';
 433         $views_field['argument']['id'] = 'date';
 434         $views_field['filter']['id'] = 'date';
 435         $views_field['sort']['id'] = 'date';
 436         break;
 437
 438       case 'language':
 439         $views_field['field']['id'] = 'field';
 440         $views_field['argument']['id'] = 'language';
 441         $views_field['filter']['id'] = 'language';
 442         $views_field['sort']['id'] = 'standard';
 443         break;
 444
 445       case 'boolean':
 446         $views_field['field']['id'] = 'field';
 447         $views_field['argument']['id'] = 'numeric';
 448         $views_field['filter']['id'] = 'boolean';
 449         $views_field['sort']['id'] = 'standard';
 450         break;
 451
 452       case 'uri':
 453         // Let's render URIs as URIs by default, not links.
 454         $views_field['field']['id'] = 'field';
 455         $views_field['field']['default_formatter'] = 'string';
 456
 457         $views_field['argument']['id'] = 'string';
 458         $views_field['filter']['id'] = 'string';
 459         $views_field['sort']['id'] = 'standard';
 460         break;
 461
 462       case 'text':
 463       case 'text_with_summary':
 464         // Treat these three long text fields the same.
 465         $field_type = 'text_long';
 466         // Intentional fall-through here to the default processing!
 467
 468       default:
 469         // For most fields, the field type is generic enough to just use
 470         // the column type to determine the filters etc.
 471         switch ($column_type) {
 472
 473           case 'int':
 474           case 'integer':
 475           case 'smallint':
 476           case 'tinyint':
 477           case 'mediumint':
 478           case 'float':
 479           case 'double':
 480           case 'decimal':
 481             $views_field['field']['id'] = 'field';
 482             $views_field['argument']['id'] = 'numeric';
 483             $views_field['filter']['id'] = 'numeric';
 484             $views_field['sort']['id'] = 'standard';
 485             break;
 486
 487           case 'char':
 488           case 'string':
 489           case 'varchar':
 490           case 'varchar_ascii':
 491           case 'tinytext':
 492           case 'text':
 493           case 'mediumtext':
 494           case 'longtext':
 495             $views_field['field']['id'] = 'field';
 496             $views_field['argument']['id'] = 'string';
 497             $views_field['filter']['id'] = 'string';
 498             $views_field['sort']['id'] = 'standard';
 499             break;
 500
 501           default:
 502             $views_field['field']['id'] = 'field';
 503             $views_field['argument']['id'] = 'standard';
 504             $views_field['filter']['id'] = 'standard';
 505             $views_field['sort']['id'] = 'standard';
 506         }
 507     }
 508
 509     // Do post-processing for a few field types.
 510
 511     $process_method = 'processViewsDataFor' . Container::camelize($field_type);
 512     if (method_exists($this, $process_method)) {
 513       $this->{$process_method}($table, $field_definition, $views_field, $column_name);
 514     }
 515
 516     return $views_field;
 517   }
 518
 519   /**
 520    * Processes the views data for a language field.
 521    *
 522    * @param string $table
 523    *   The table the language field is added to.
 524    * @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
 525    *   The field definition.
 526    * @param array $views_field
 527    *   The views field data.
 528    * @param string $field_column_name
 529    *   The field column being processed.
 530    */
 531   protected function processViewsDataForLanguage($table, FieldDefinitionInterface $field_definition, array &$views_field, $field_column_name) {
 532     // Apply special titles for the langcode field.
 533     if ($field_definition->getName() == $this->entityType->getKey('langcode')) {
 534       if ($table == $this->entityType->getDataTable() || $table == $this->entityType->getRevisionDataTable()) {
 535         $views_field['title'] = $this->t('Translation language');
 536       }
 537       if ($table == $this->entityType->getBaseTable() || $table == $this->entityType->getRevisionTable()) {
 538         $views_field['title'] = $this->t('Original language');
 539       }
 540     }
 541   }
 542
 543   /**
 544    * Processes the views data for an entity reference field.
 545    *
 546    * @param string $table
 547    *   The table the language field is added to.
 548    * @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
 549    *   The field definition.
 550    * @param array $views_field
 551    *   The views field data.
 552    * @param string $field_column_name
 553    *   The field column being processed.
 554    */
 555   protected function processViewsDataForEntityReference($table, FieldDefinitionInterface $field_definition, array &$views_field, $field_column_name) {
 556
 557     // @todo Should the actual field handler respect that this just renders a
 558     //   number?
 559     // @todo Create an optional entity field handler, that can render the
 560     //   entity.
 561     // @see https://www.drupal.org/node/2322949
 562
 563     if ($entity_type_id = $field_definition->getItemDefinition()->getSetting('target_type')) {
 564       $entity_type = $this->entityManager->getDefinition($entity_type_id);
 565       if ($entity_type instanceof ContentEntityType) {
 566         $views_field['relationship'] = [
 567           'base' => $this->getViewsTableForEntityType($entity_type),
 568           'base field' => $entity_type->getKey('id'),
 569           'label' => $entity_type->getLabel(),
 570           'title' => $entity_type->getLabel(),
 571           'id' => 'standard',
 572         ];
 573         $views_field['field']['id'] = 'field';
 574         $views_field['argument']['id'] = 'numeric';
 575         $views_field['filter']['id'] = 'numeric';
 576         $views_field['sort']['id'] = 'standard';
 577       }
 578       else {
 579         $views_field['field']['id'] = 'field';
 580         $views_field['argument']['id'] = 'string';
 581         $views_field['filter']['id'] = 'string';
 582         $views_field['sort']['id'] = 'standard';
 583       }
 584     }
 585
 586     if ($field_definition->getName() == $this->entityType->getKey('bundle')) {
 587       $views_field['filter']['id'] = 'bundle';
 588     }
 589   }
 590
 591   /**
 592    * Processes the views data for a text field with formatting.
 593    *
 594    * @param string $table
 595    *   The table the field is added to.
 596    * @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
 597    *   The field definition.
 598    * @param array $views_field
 599    *   The views field data.
 600    * @param string $field_column_name
 601    *   The field column being processed.
 602    */
 603   protected function processViewsDataForTextLong($table, FieldDefinitionInterface $field_definition, array &$views_field, $field_column_name) {
 604     // Connect the text field to its formatter.
 605     if ($field_column_name == 'value') {
 606       $views_field['field']['format'] = $field_definition->getName() . '__format';
 607       $views_field['field']['id'] = 'field';
 608     }
 609   }
 610
 611   /**
 612    * Processes the views data for a UUID field.
 613    *
 614    * @param string $table
 615    *   The table the field is added to.
 616    * @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
 617    *   The field definition.
 618    * @param array $views_field
 619    *   The views field data.
 620    * @param string $field_column_name
 621    *   The field column being processed.
 622    */
 623   protected function processViewsDataForUuid($table, FieldDefinitionInterface $field_definition, array &$views_field, $field_column_name) {
 624     // It does not make sense for UUID fields to be click sortable.
 625     $views_field['field']['click sortable'] = FALSE;
 626   }
 627
 628   /**
 629    * {@inheritdoc}
 630    */
 631   public function getViewsTableForEntityType(EntityTypeInterface $entity_type) {
 632     return $entity_type->getDataTable() ?: $entity_type->getBaseTable();
 633   }
 634
 635 }