Code Coverage |
||||||||||
Classes and Traits |
Functions and Methods |
Lines |
||||||||
| Total | |
0.00% |
0 / 1 |
|
0.00% |
0 / 8 |
CRAP | |
0.00% |
0 / 128 |
| ViewsSelection | |
0.00% |
0 / 1 |
|
27.27% |
3 / 11 |
756 | |
0.00% |
0 / 128 |
| __construct | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 5 |
|||
| create | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 9 |
|||
| buildConfigurationForm | |
0.00% |
0 / 1 |
90 | |
0.00% |
0 / 49 |
|||
| validateConfigurationForm | |
100.00% |
1 / 1 |
1 | |
100.00% |
0 / 0 |
|||
| submitConfigurationForm | |
100.00% |
1 / 1 |
1 | |
100.00% |
0 / 0 |
|||
| initializeView | |
0.00% |
0 / 1 |
12 | |
0.00% |
0 / 18 |
|||
| getReferenceableEntities | |
0.00% |
0 / 1 |
20 | |
0.00% |
0 / 16 |
|||
| countReferenceableEntities | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 3 |
|||
| validateReferenceableEntities | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 10 |
|||
| settingsFormValidate | |
0.00% |
0 / 1 |
12 | |
0.00% |
0 / 17 |
|||
| entityQueryAlter | |
100.00% |
1 / 1 |
1 | |
100.00% |
0 / 0 |
|||
| <?php | |
| /** | |
| * @file | |
| * Contains \Drupal\views\Plugin\EntityReferenceSelection\ViewsSelection. | |
| */ | |
| namespace Drupal\views\Plugin\EntityReferenceSelection; | |
| use Drupal\Core\Database\Query\SelectInterface; | |
| use Drupal\Core\Entity\EntityManagerInterface; | |
| use Drupal\Core\Entity\EntityReferenceSelection\SelectionInterface; | |
| use Drupal\Core\Extension\ModuleHandlerInterface; | |
| use Drupal\Core\Form\FormStateInterface; | |
| use Drupal\Core\Plugin\ContainerFactoryPluginInterface; | |
| use Drupal\Core\Plugin\PluginBase; | |
| use Drupal\Core\Session\AccountInterface; | |
| use Drupal\Core\Url; | |
| use Drupal\views\Views; | |
| use Symfony\Component\DependencyInjection\ContainerInterface; | |
| /** | |
| * Plugin implementation of the 'selection' entity_reference. | |
| * | |
| * @EntityReferenceSelection( | |
| * id = "views", | |
| * label = @Translation("Views: Filter by an entity reference view"), | |
| * group = "views", | |
| * weight = 0 | |
| * ) | |
| */ | |
| class ViewsSelection extends PluginBase implements SelectionInterface, ContainerFactoryPluginInterface { | |
| /** | |
| * The entity manager. | |
| * | |
| * @var \Drupal\Core\Entity\EntityManagerInterface | |
| */ | |
| protected $entityManager; | |
| /** | |
| * The module handler service. | |
| * | |
| * @var \Drupal\Core\Extension\ModuleHandlerInterface | |
| */ | |
| protected $moduleHandler; | |
| /** | |
| * The current user. | |
| * | |
| * @var \Drupal\Core\Session\AccountInterface | |
| */ | |
| protected $currentUser; | |
| /** | |
| * Constructs a new SelectionBase object. | |
| * | |
| * @param array $configuration | |
| * A configuration array containing information about the plugin instance. | |
| * @param string $plugin_id | |
| * The plugin_id for the plugin instance. | |
| * @param mixed $plugin_definition | |
| * The plugin implementation definition. | |
| * @param \Drupal\Core\Entity\EntityManagerInterface $entity_manager | |
| * The entity manager service. | |
| * @param \Drupal\Core\Extension\ModuleHandlerInterface $module_handler | |
| * The module handler service. | |
| * @param \Drupal\Core\Session\AccountInterface $current_user | |
| * The current user. | |
| */ | |
| public function __construct(array $configuration, $plugin_id, $plugin_definition, EntityManagerInterface $entity_manager, ModuleHandlerInterface $module_handler, AccountInterface $current_user) { | |
| parent::__construct($configuration, $plugin_id, $plugin_definition); | |
| $this->entityManager = $entity_manager; | |
| $this->moduleHandler = $module_handler; | |
| $this->currentUser = $current_user; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) { | |
| return new static( | |
| $configuration, | |
| $plugin_id, | |
| $plugin_definition, | |
| $container->get('entity.manager'), | |
| $container->get('module_handler'), | |
| $container->get('current_user') | |
| ); | |
| } | |
| /** | |
| * The loaded View object. | |
| * | |
| * @var \Drupal\views\ViewExecutable; | |
| */ | |
| protected $view; | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function buildConfigurationForm(array $form, FormStateInterface $form_state) { | |
| $selection_handler_settings = $this->configuration['handler_settings']; | |
| $view_settings = !empty($selection_handler_settings['view']) ? $selection_handler_settings['view'] : array(); | |
| $displays = Views::getApplicableViews('entity_reference_display'); | |
| // Filter views that list the entity type we want, and group the separate | |
| // displays by view. | |
| $entity_type = $this->entityManager->getDefinition($this->configuration['target_type']); | |
| $view_storage = $this->entityManager->getStorage('view'); | |
| $options = array(); | |
| foreach ($displays as $data) { | |
| list($view_id, $display_id) = $data; | |
| $view = $view_storage->load($view_id); | |
| if (in_array($view->get('base_table'), [$entity_type->getBaseTable(), $entity_type->getDataTable()])) { | |
| $display = $view->get('display'); | |
| $options[$view_id . ':' . $display_id] = $view_id . ' - ' . $display[$display_id]['display_title']; | |
| } | |
| } | |
| // The value of the 'view_and_display' select below will need to be split | |
| // into 'view_name' and 'view_display' in the final submitted values, so | |
| // we massage the data at validate time on the wrapping element (not | |
| // ideal). | |
| $form['view']['#element_validate'] = array(array(get_called_class(), 'settingsFormValidate')); | |
| if ($options) { | |
| $default = !empty($view_settings['view_name']) ? $view_settings['view_name'] . ':' . $view_settings['display_name'] : NULL; | |
| $form['view']['view_and_display'] = array( | |
| '#type' => 'select', | |
| '#title' => $this->t('View used to select the entities'), | |
| '#required' => TRUE, | |
| '#options' => $options, | |
| '#default_value' => $default, | |
| '#description' => '<p>' . $this->t('Choose the view and display that select the entities that can be referenced.<br />Only views with a display of type "Entity Reference" are eligible.') . '</p>', | |
| ); | |
| $default = !empty($view_settings['arguments']) ? implode(', ', $view_settings['arguments']) : ''; | |
| $form['view']['arguments'] = array( | |
| '#type' => 'textfield', | |
| '#title' => $this->t('View arguments'), | |
| '#default_value' => $default, | |
| '#required' => FALSE, | |
| '#description' => $this->t('Provide a comma separated list of arguments to pass to the view.'), | |
| ); | |
| } | |
| else { | |
| if ($this->currentUser->hasPermission('administer views') && $this->moduleHandler->moduleExists('views_ui')) { | |
| $form['view']['no_view_help'] = array( | |
| '#markup' => '<p>' . $this->t('No eligible views were found. <a href=":create">Create a view</a> with an <em>Entity Reference</em> display, or add such a display to an <a href=":existing">existing view</a>.', array( | |
| ':create' => Url::fromRoute('views_ui.add')->toString(), | |
| ':existing' => Url::fromRoute('entity.view.collection')->toString(), | |
| )) . '</p>', | |
| ); | |
| } | |
| else { | |
| $form['view']['no_view_help']['#markup'] = '<p>' . $this->t('No eligible views were found.') . '</p>'; | |
| } | |
| } | |
| return $form; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function validateConfigurationForm(array &$form, FormStateInterface $form_state) { } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function submitConfigurationForm(array &$form, FormStateInterface $form_state) { } | |
| /** | |
| * Initializes a view. | |
| * | |
| * @param string|null $match | |
| * (Optional) Text to match the label against. Defaults to NULL. | |
| * @param string $match_operator | |
| * (Optional) The operation the matching should be done with. Defaults | |
| * to "CONTAINS". | |
| * @param int $limit | |
| * Limit the query to a given number of items. Defaults to 0, which | |
| * indicates no limiting. | |
| * @param array|null $ids | |
| * Array of entity IDs. Defaults to NULL. | |
| * | |
| * @return bool | |
| * Return TRUE if the view was initialized, FALSE otherwise. | |
| */ | |
| protected function initializeView($match = NULL, $match_operator = 'CONTAINS', $limit = 0, $ids = NULL) { | |
| $handler_settings = $this->configuration['handler_settings']; | |
| $view_name = $handler_settings['view']['view_name']; | |
| $display_name = $handler_settings['view']['display_name']; | |
| // Check that the view is valid and the display still exists. | |
| $this->view = Views::getView($view_name); | |
| if (!$this->view || !$this->view->access($display_name)) { | |
| drupal_set_message(t('The reference view %view_name cannot be found.', array('%view_name' => $view_name)), 'warning'); | |
| return FALSE; | |
| } | |
| $this->view->setDisplay($display_name); | |
| // Pass options to the display handler to make them available later. | |
| $entity_reference_options = array( | |
| 'match' => $match, | |
| 'match_operator' => $match_operator, | |
| 'limit' => $limit, | |
| 'ids' => $ids, | |
| ); | |
| $this->view->displayHandlers->get($display_name)->setOption('entity_reference_options', $entity_reference_options); | |
| return TRUE; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function getReferenceableEntities($match = NULL, $match_operator = 'CONTAINS', $limit = 0) { | |
| $handler_settings = $this->configuration['handler_settings']; | |
| $display_name = $handler_settings['view']['display_name']; | |
| $arguments = $handler_settings['view']['arguments']; | |
| $result = array(); | |
| if ($this->initializeView($match, $match_operator, $limit)) { | |
| // Get the results. | |
| $result = $this->view->executeDisplay($display_name, $arguments); | |
| } | |
| $return = array(); | |
| if ($result) { | |
| foreach ($this->view->result as $row) { | |
| $entity = $row->_entity; | |
| $return[$entity->bundle()][$entity->id()] = $entity->label(); | |
| } | |
| } | |
| return $return; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function countReferenceableEntities($match = NULL, $match_operator = 'CONTAINS') { | |
| $this->getReferenceableEntities($match, $match_operator); | |
| return $this->view->pager->getTotalItems(); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function validateReferenceableEntities(array $ids) { | |
| $handler_settings = $this->configuration['handler_settings']; | |
| $display_name = $handler_settings['view']['display_name']; | |
| $arguments = $handler_settings['view']['arguments']; | |
| $result = array(); | |
| if ($this->initializeView(NULL, 'CONTAINS', 0, $ids)) { | |
| // Get the results. | |
| $entities = $this->view->executeDisplay($display_name, $arguments); | |
| $result = array_keys($entities); | |
| } | |
| return $result; | |
| } | |
| /** | |
| * Element validate; Check View is valid. | |
| */ | |
| public static function settingsFormValidate($element, FormStateInterface $form_state, $form) { | |
| // Split view name and display name from the 'view_and_display' value. | |
| if (!empty($element['view_and_display']['#value'])) { | |
| list($view, $display) = explode(':', $element['view_and_display']['#value']); | |
| } | |
| else { | |
| $form_state->setError($element, t('The views entity selection mode requires a view.')); | |
| return; | |
| } | |
| // Explode the 'arguments' string into an actual array. Beware, explode() | |
| // turns an empty string into an array with one empty string. We'll need an | |
| // empty array instead. | |
| $arguments_string = trim($element['arguments']['#value']); | |
| if ($arguments_string === '') { | |
| $arguments = array(); | |
| } | |
| else { | |
| // array_map() is called to trim whitespaces from the arguments. | |
| $arguments = array_map('trim', explode(',', $arguments_string)); | |
| } | |
| $value = array('view_name' => $view, 'display_name' => $display, 'arguments' => $arguments); | |
| $form_state->setValueForElement($element, $value); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function entityQueryAlter(SelectInterface $query) { } | |
| } |