diff --git a/dynamic_entity_reference.services.yml b/dynamic_entity_reference.services.yml new file mode 100644 index 0000000..153fff9 --- /dev/null +++ b/dynamic_entity_reference.services.yml @@ -0,0 +1,4 @@ +services: + plugin.manager.dynamic_entity_reference_selection: + class: Drupal\dynamic_entity_reference\SelectionPluginManager + parent: plugin.manager.entity_reference_selection diff --git a/src/DynamicEntityReferenceController.php b/src/DynamicEntityReferenceController.php index 98f54ac..1ab3430 100644 --- a/src/DynamicEntityReferenceController.php +++ b/src/DynamicEntityReferenceController.php @@ -82,15 +82,15 @@ class DynamicEntityReferenceController extends ControllerBase { } $settings = $field_definition->getSettings(); - $target_types = DynamicEntityReferenceItem::getAllEntityTypeIds($settings); + $target_types = DynamicEntityReferenceItem::getTargetTypes($settings); if (!in_array($target_type, array_keys($target_types))) { throw new AccessDeniedHttpException(); } // We put the dummy value here so selection plugins can work. - // @todo Remove these once https://www.drupal.org/node/1959806 - // and https://www.drupal.org/node/2107243 are fixed. - $field_definition->settings['target_type'] = $target_type; + // @todo Remove these once https://www.drupal.org/node/1959806 is fixed. + // @see \Drupal\Core\Entity\EntityReferenceSelection\SelectionPluginManager::getSelectionHandler(). + $field_definition->getFieldStorageDefinition()->settings['target_type'] = $target_type; $field_definition->settings['handler'] = $settings[$target_type]['handler']; $field_definition->settings['handler_settings'] = $settings[$target_type]['handler_settings']; diff --git a/src/DynamicEntityReferenceFieldItemList.php b/src/DynamicEntityReferenceFieldItemList.php index 6b32164..af595ee 100644 --- a/src/DynamicEntityReferenceFieldItemList.php +++ b/src/DynamicEntityReferenceFieldItemList.php @@ -29,6 +29,10 @@ class DynamicEntityReferenceFieldItemList extends EntityReferenceFieldItemList { // Collect the IDs of existing entities to load, and directly grab the // "autocreate" entities that are already populated in $item->entity. $target_entities = $ids = array(); + /** + * @var int $delta + * @var \Drupal\dynamic_entity_reference\Plugin\Field\FieldType\DynamicEntityReferenceItem $item + */ foreach ($this->list as $delta => $item) { if ($item->hasNewEntity()) { $target_entities[$delta] = $item->entity; @@ -76,20 +80,16 @@ class DynamicEntityReferenceFieldItemList extends EntityReferenceFieldItemList { $entity_uuids = array(); foreach ($all_uuids as $target_type => $uuids) { if ($uuids) { - $entity_ids = \Drupal::entityQuery($target_type) - ->condition('uuid', $uuids, 'IN') - ->execute(); $entities = \Drupal::entityManager() ->getStorage($target_type) - ->loadMultiple($entity_ids); + ->loadByProperties(array('uuid' => $uuids)); $entity_uuids[$target_type] = array(); foreach ($entities as $id => $entity) { $entity_uuids[$target_type][$entity->uuid()] = $id; } foreach ($uuids as $delta => $uuid) { - if (isset($entity_uuids[$uuid])) { + if (isset($entity_uuids[$target_type]) && isset($entity_uuids[$target_type][$uuid])) { $default_value[$delta]['target_id'] = $entity_uuids[$target_type][$uuid]; - $default_value[$delta]['target_type'] = $target_type; unset($default_value[$delta]['target_uuid']); } else { diff --git a/src/Plugin/DataType/DynamicEntityReference.php b/src/Plugin/DataType/DynamicEntityReference.php index afa467e..f68eee8 100644 --- a/src/Plugin/DataType/DynamicEntityReference.php +++ b/src/Plugin/DataType/DynamicEntityReference.php @@ -7,7 +7,6 @@ namespace Drupal\dynamic_entity_reference\Plugin\DataType; -use Drupal\Core\Entity\EntityInterface; use Drupal\Core\Entity\Plugin\DataType\EntityReference; /** diff --git a/src/Plugin/Field/FieldType/DynamicEntityReferenceItem.php b/src/Plugin/Field/FieldType/DynamicEntityReferenceItem.php index 273670a..d950a3c 100644 --- a/src/Plugin/Field/FieldType/DynamicEntityReferenceItem.php +++ b/src/Plugin/Field/FieldType/DynamicEntityReferenceItem.php @@ -136,33 +136,32 @@ class DynamicEntityReferenceItem extends ConfigurableEntityReferenceItem { /** * {@inheritdoc} + * + * To select both target_type and target_id the option value is + * changed from target_id to target_type-target_id. + * + * @see \Drupal\dynamic_entity_reference\Plugin\Field\FieldWidget\DynamicEntityReferenceOptionsTrait::massageFormValues() */ public function getSettableOptions(AccountInterface $account = NULL) { - $options = array(); $field_definition = $this->getFieldDefinition(); + $options = array(); $settings = $this->getSettings(); - $entity_type_ids = static::getAllEntityTypeIds($settings); - foreach (array_keys($entity_type_ids) as $entity_type_id) { - // We put the dummy value here so selection plugins can work. - // @todo Remove these once https://www.drupal.org/node/1959806 - // and https://www.drupal.org/node/2107243 are fixed. - $field_definition->settings['target_type'] = $entity_type_id; - $field_definition->settings['handler'] = $settings[$entity_type_id]['handler']; - $field_definition->settings['handler_settings'] = $settings[$entity_type_id]['handler_settings']; - $options[$entity_type_id] = \Drupal::service('plugin.manager.entity_reference.selection')->getSelectionHandler($field_definition, $this->getEntity())->getReferenceableEntities(); + $target_types = static::getTargetTypes($settings); + foreach (array_keys($target_types) as $target_type) { + $options[$target_type] = \Drupal::service('plugin.manager.dynamic_entity_reference_selection')->getSelectionHandler($field_definition, $this->getEntity(), $target_type)->getReferenceableEntities(); } if (empty($options)) { return array(); } $return = array(); - foreach ($options as $target_type) { - + foreach ($options as $target_type => $referenceable_entities) { // Rebuild the array by changing the bundle key into the bundle label. $bundles = \Drupal::entityManager()->getBundleInfo($target_type); - - foreach ($options[$target_type] as $bundle => $entity_ids) { + foreach ($referenceable_entities as $bundle => $entities) { $bundle_label = String::checkPlain($bundles[$bundle]['label']); - $return[$entity_type_ids[$target_type]][$bundle_label] = $entity_ids; + foreach ($entities as $id => $entity_label) { + $return[$target_types[$target_type]][$bundle_label]["{$target_type}-{$id}"] = $entity_label; + } } } @@ -203,21 +202,100 @@ class DynamicEntityReferenceItem extends ConfigurableEntityReferenceItem { $settings_form = array(); $field = $form_state->get('field'); $settings = $this->getSettings(); - $entity_type_ids = static::getAllEntityTypeIds($settings); - foreach (array_keys($entity_type_ids) as $entity_type_id) { - // We put the dummy value here so selection plugins can work. - // @todo Remove these once https://www.drupal.org/node/1959806 - // and https://www.drupal.org/node/2107243 are fixed. - $field->settings['target_type'] = $entity_type_id; - $field->settings['handler'] = $settings[$entity_type_id]['handler']; - $field->settings['handler_settings'] = $settings[$entity_type_id]['handler_settings']; - $settings_form[$entity_type_id] = parent::fieldSettingsForm($form, $form_state); - $settings_form[$entity_type_id]['handler']['#title'] = t('Reference type for @entity_type_id', array('@entity_type_id' => $entity_type_ids[$entity_type_id])); + $target_types = static::getTargetTypes($settings); + foreach (array_keys($target_types) as $target_type) { + $settings_form[$target_type] = $this->targetTypeFieldSettingsForm($form, $form_state, $target_type); + $settings_form[$target_type]['handler']['#title'] = t('Reference type for @target_type', array('@target_type' => $target_types[$target_type])); } return $settings_form; } /** + * Returns a form for single target type settings. + * + * This is same as + * \Drupal\entity_reference\ConfigurableEntityReferenceItem::fieldSettingsForm() + * but it use dynamic_entity_reference_selection plugin manager instead of + * entity_reference_selection plugin manager. + * + * @param array $form + * The form where the settings form is being included in. + * @param \Drupal\Core\Form\FormStateInterface $form_state + * The form state of the (entire) configuration form. + * @param string $target_type + * The target entity type id. + * + * @return array + * The form definition for the field settings. + */ + protected function targetTypeFieldSettingsForm(array $form, FormStateInterface $form_state, $target_type) { + /** @var \Drupal\field\FieldConfigInterface $field */ + $field = $form_state->get('field'); + $field_settings = $field->getSettings(); + /** @var \Drupal\dynamic_entity_reference\SelectionPluginManager $manager */ + $manager = \Drupal::service('plugin.manager.dynamic_entity_reference_selection'); + // Get all selection plugins for this entity type. + $selection_plugins = $manager->getSelectionGroups($target_type); + $handlers_options = array(); + foreach (array_keys($selection_plugins) as $selection_group_id) { + // We only display base plugins (e.g. 'default', 'views', ...) and not + // entity type specific plugins (e.g. 'default:node', 'default:user', + // ...). + if (array_key_exists($selection_group_id, $selection_plugins[$selection_group_id])) { + $handlers_options[$selection_group_id] = String::checkPlain($selection_plugins[$selection_group_id][$selection_group_id]['label']); + } + elseif (array_key_exists($selection_group_id . ':' . $target_type, $selection_plugins[$selection_group_id])) { + $selection_group_plugin = $selection_group_id . ':' . $target_type; + $handlers_options[$selection_group_id] = String::checkPlain($selection_plugins[$selection_group_id][$selection_group_plugin]['base_plugin_label']); + } + } + + $form = array( + '#type' => 'container', + '#process' => array( + '_entity_reference_field_field_settings_ajax_process', + ), + '#element_validate' => array(array(get_class($this), 'fieldSettingsFormValidate')), + ); + $form['handler'] = array( + '#type' => 'details', + '#title' => t('Reference type'), + '#open' => TRUE, + '#tree' => TRUE, + '#process' => array('_entity_reference_form_process_merge_parent'), + ); + + $form['handler']['handler'] = array( + '#type' => 'select', + '#title' => t('Reference method'), + '#options' => $handlers_options, + '#default_value' => $field_settings[$target_type]['handler'], + '#required' => TRUE, + '#ajax' => TRUE, + '#limit_validation_errors' => array(), + ); + $form['handler']['handler_submit'] = array( + '#type' => 'submit', + '#value' => t('Change handler'), + '#limit_validation_errors' => array(), + '#attributes' => array( + 'class' => array('js-hide'), + ), + '#submit' => array('entity_reference_settings_ajax_submit'), + ); + + $form['handler']['handler_settings'] = array( + '#type' => 'container', + '#attributes' => array('class' => array('entity_reference-settings')), + ); + + $handler = $manager->getSelectionHandler($field, NULL, $target_type); + $form['handler']['handler_settings'] += $handler->buildConfigurationForm(array(), $form_state); + + return $form; + } + + /** * Form element validation handler; Stores the new values in the form state. * * @param array $form @@ -228,13 +306,16 @@ class DynamicEntityReferenceItem extends ConfigurableEntityReferenceItem { public static function fieldSettingsFormValidate(array $form, FormStateInterface $form_state) { if ($form_state->hasValue('field')) { $settings = $form_state->getValue(array('field', 'settings')); - foreach (array_keys($settings) as $entity_type_id) { + foreach (array_keys($settings) as $target_type) { $form_state->unsetValue(array( 'field', 'settings', - $entity_type_id, + $target_type, 'handler_submit', )); + /** @var \Drupal\Core\Entity\EntityReferenceSelection\SelectionInterface $handler */ + $handler = \Drupal::service('plugin.manager.dynamic_entity_reference_selection')->getSelectionHandler($form_state->get('field'), NULL, $target_type); + $handler->validateConfigurationForm($form, $form_state); } $form_state->get('field')->settings = $form_state->getValue(array('field', 'settings')); } @@ -243,6 +324,14 @@ class DynamicEntityReferenceItem extends ConfigurableEntityReferenceItem { /** * {@inheritdoc} */ + public static function mainPropertyName() { + // We have two main properties i.e. target_type and target_id. + return NULL; + } + + /** + * {@inheritdoc} + */ public function setValue($values, $notify = TRUE) { if (empty($values['target_type']) && !empty($values['target_id'])) { throw new \InvalidArgumentException('No entity type was provided, value is not a valid entity.'); @@ -319,18 +408,13 @@ class DynamicEntityReferenceItem extends ConfigurableEntityReferenceItem { * {@inheritdoc} */ public static function generateSampleValue(FieldDefinitionInterface $field_definition) { - $manager = \Drupal::service('plugin.manager.entity_reference.selection'); + /** @var \Drupal\dynamic_entity_reference\SelectionPluginManager $manager */ + $manager = \Drupal::service('plugin.manager.dynamic_entity_reference_selection'); $settings = $field_definition->getSettings(); - $entity_type_ids = static::getAllEntityTypeIds($settings); - foreach (array_keys($entity_type_ids) as $entity_type_id) { - $values['target_type'] = $entity_type_id; - // We put the dummy value here so selection plugins can work. - // @todo Remove these once https://www.drupal.org/node/1959806 - // and https://www.drupal.org/node/2107243 are fixed. - $field_definition->settings['target_type'] = $entity_type_id; - $field_definition->settings['handler'] = $settings[$entity_type_id]['handler']; - $field_definition->settings['handler_settings'] = $settings[$entity_type_id]['handler_settings']; - if ($referenceable = $manager->getSelectionHandler($field_definition)->getReferenceableEntities()) { + $target_types = static::getTargetTypes($settings); + foreach (array_keys($target_types) as $target_type) { + $values['target_type'] = $target_type; + if ($referenceable = $manager->getSelectionHandler($field_definition, NULL, $target_type)->getReferenceableEntities()) { $group = array_rand($referenceable); $values['target_id'] = array_rand($referenceable[$group]); return $values; @@ -345,14 +429,14 @@ class DynamicEntityReferenceItem extends ConfigurableEntityReferenceItem { $dependencies = []; if (is_array($field_definition->default_value) && count($field_definition->default_value)) { - $target_entity_types = static::getAllEntityTypeIds($field_definition->getFieldStorageDefinition()->getSettings()); + $target_entity_types = static::getTargetTypes($field_definition->getFieldStorageDefinition()->getSettings()); foreach ($target_entity_types as $target_entity_type) { $key = $target_entity_type instanceof ConfigEntityType ? 'config' : 'content'; foreach ($field_definition->default_value as $default_value) { if (is_array($default_value) && isset($default_value['target_uuid']) && isset($default_value['target_type'])) { $entity = \Drupal::entityManager()->loadEntityByUuid($default_value['target_type'], $default_value['target_uuid']); // If the entity does not exist do not create the dependency. - // @see \Drupal\Core\Field\EntityReferenceFieldItemList::processDefaultValue() + // @see \Drupal\Core\Field\DynamicEntityReferenceFieldItemList::processDefaultValue() if ($entity) { $dependencies[$key][] = $entity->getConfigDependencyName(); } @@ -370,19 +454,19 @@ class DynamicEntityReferenceItem extends ConfigurableEntityReferenceItem { * The settings of the field storage. * * @return string[] - * All the entity type ids that can be referenced. + * All the target entity type ids that can be referenced. */ - public static function getAllEntityTypeIds($settings) { + public static function getTargetTypes($settings) { $labels = \Drupal::entityManager()->getEntityTypeLabels(TRUE); $options = $labels['Content']; if ($settings['exclude_entity_types']) { - $entity_type_ids = array_diff_key($options, $settings['entity_type_ids'] ?: array()); + $target_types = array_diff_key($options, $settings['entity_type_ids'] ?: array()); } else { - $entity_type_ids = array_intersect_key($options, $settings['entity_type_ids'] ?: array()); + $target_types = array_intersect_key($options, $settings['entity_type_ids'] ?: array()); } - return $entity_type_ids; + return $target_types; } } diff --git a/src/Plugin/Field/FieldWidget/DynamicEntityReferenceOptionsButtonsWidget.php b/src/Plugin/Field/FieldWidget/DynamicEntityReferenceOptionsButtonsWidget.php new file mode 100644 index 0000000..df511ce --- /dev/null +++ b/src/Plugin/Field/FieldWidget/DynamicEntityReferenceOptionsButtonsWidget.php @@ -0,0 +1,27 @@ +getSettings())) == 1; + } + + /** + * {@inheritdoc} + * + * This widget only support single target type dynamic entity reference + * fields so no need to support groups. + */ + protected function supportsGroups() { + return FALSE; + } + + /** + * {@inheritdoc} + */ + protected function getSelectedOptions(FieldItemListInterface $items, $delta = 0) { + // We need to check against a flat list of options. + $flat_options = OptGroup::flattenOptions($this->getOptions($items->getEntity())); + + $selected_options = array(); + foreach ($items as $item) { + $value = "{$item->target_type}-{$item->target_id}"; + // Keep the value if it actually is in the list of options (needs to be + // checked against the flat list). + if (isset($flat_options[$value])) { + $selected_options[] = $value; + } + } + + return $selected_options; + } + + /** + * {@inheritdoc} + * + * To save both target_type and target_id the option value is split into + * target_type and target_id. + * + * @see \Drupal\dynamic_entity_reference\Plugin\Field\FieldType\DynamicEntityReferenceItem::getSettableOptions() + */ + public function massageFormValues(array $values, array $form, FormStateInterface $form_state) { + foreach ($values as $index => $value) { + list($values[$index]['target_type'], $values[$index]['target_id']) = explode('-', $value['target_id']); + } + return $values; + } + + /** + * {@inheritdoc} + */ + protected function getOptions(FieldableEntityInterface $entity) { + $options = parent::getOptions($entity); + + // Add an empty option if the widget needs one. + if ($empty_option = $this->getEmptyOption()) { + $plugin_id = $this->getPluginId(); + if (strpos($plugin_id, 'buttons') !== FALSE) { + $label = t('N/A'); + } + else { + $label = ($empty_option == static::OPTIONS_EMPTY_NONE ? t('- None -') : t('- Select a value -')); + } + + $options = array('_none' => $label) + $options; + } + return $options; + } + +} diff --git a/src/Plugin/Field/FieldWidget/DynamicEntityReferenceWidget.php b/src/Plugin/Field/FieldWidget/DynamicEntityReferenceWidget.php index e191c5a..a1efd4a 100644 --- a/src/Plugin/Field/FieldWidget/DynamicEntityReferenceWidget.php +++ b/src/Plugin/Field/FieldWidget/DynamicEntityReferenceWidget.php @@ -34,7 +34,7 @@ class DynamicEntityReferenceWidget extends AutocompleteWidget { $entity = $items->getEntity(); $target = $items->get($delta)->entity; - $available = DynamicEntityReferenceItem::getAllEntityTypeIds($this->getFieldSettings()); + $available = DynamicEntityReferenceItem::getTargetTypes($this->getFieldSettings()); $cardinality = $items->getFieldDefinition()->getFieldStorageDefinition()->getCardinality(); // Prepare the autocomplete route parameters. @@ -107,6 +107,9 @@ class DynamicEntityReferenceWidget extends AutocompleteWidget { * TRUE if a content entity is referenced. */ protected function isContentReferenced($target_type = NULL) { + if ($target_type === NULL) { + return parent::isContentReferenced(); + } $target_type_info = \Drupal::entityManager()->getDefinition($target_type); return $target_type_info->isSubclassOf('\Drupal\Core\Entity\ContentEntityInterface'); } @@ -139,25 +142,20 @@ class DynamicEntityReferenceWidget extends AutocompleteWidget { elseif (preg_match("/.+\(([\w.]+)\)/", $element['#value'], $matches)) { $value = $matches[1]; } - $auto_create = $this->getHandlerSetting('auto_create', $values['target_type']); + $auto_create = $this->getSelectionHandlerSetting('auto_create', $values['target_type']); // Try to get a match from the input string when the user didn't use the // autocomplete but filled in a value manually. if ($value === NULL) { - // To use entity_reference selection_handler for this target_type we - // have to change these settings to entity_reference field settings. - // @todo Remove these once https://www.drupal.org/node/1959806 - // and https://www.drupal.org/node/2107243 are fixed. - $this->fakeFieldSettings($values['target_type']); - /** @var \Drupal\entity_reference\Plugin\Type\Selection\SelectionInterface $handler */ - $handler = \Drupal::service('plugin.manager.entity_reference.selection')->getSelectionHandler($this->fieldDefinition); + /** @var \Drupal\Core\Entity\EntityReferenceSelection\SelectionInterface $handler */ + $handler = \Drupal::service('plugin.manager.dynamic_entity_reference_selection')->getSelectionHandler($this->fieldDefinition, NULL, $values['target_type']); $value = $handler->validateAutocompleteInput($element['#value'], $element, $form_state, $form, !$auto_create); } // Auto-create item. See - // \Drupal\Core\Field\Plugin\Field\FieldType\EntityReferenceItem::presave(). - if (!$value && $auto_create && (count($this->getHandlerSetting('target_bundles', $values['target_type'])) == 1)) { + // \Drupal\Core\Field\Plugin\Field\FieldType\DynamicEntityReferenceItem::presave(). + if (!$value && $auto_create && (count($this->getSelectionHandlerSetting('target_bundles', $values['target_type'])) == 1)) { $value = array( 'target_id' => NULL, - 'entity' => $this->createNewEntity($element['#value'], $element['#autocreate_uid']), + 'entity' => $this->createNewEntity($element['#value'], $element['#autocreate_uid'], $values['target_type']), // Keep the weight property. '_weight' => $element['#weight'], ); @@ -171,39 +169,67 @@ class DynamicEntityReferenceWidget extends AutocompleteWidget { } /** - * Sets the fake field settings values. + * Returns the value of a setting for the dynamic entity reference handler. * - * These settings are required by - * \Drupal\entity_reference\Plugin\Type\SelectionPluginManager to select the - * proper selection plugin and these settings are also used by - * \Drupal\entity_reference\Plugin\entity_reference\selection\SelectionBase - * @todo Remove these once https://www.drupal.org/node/1959806 - * and https://www.drupal.org/node/2107243 are fixed. + * @param string $setting_name + * The setting name. + * @param string $target_type + * The id of the target entity type. * - * @param string $entity_type_id - * The id of the entity type. + * @return mixed + * The setting value. */ - protected function fakeFieldSettings($entity_type_id) { + protected function getSelectionHandlerSetting($setting_name, $target_type = NULL) { + if ($target_type === NULL) { + return parent::getSelectionHandlerSetting($setting_name); + } $settings = $this->getFieldSettings(); - $this->fieldDefinition->settings['target_type'] = $entity_type_id; - $this->fieldDefinition->settings['handler'] = $settings[$entity_type_id]['handler']; - $this->fieldDefinition->settings['handler_settings'] = $settings[$entity_type_id]['handler_settings']; + return isset($settings[$target_type]['handler_settings'][$setting_name]) ? $settings[$target_type]['handler_settings'][$setting_name] : NULL; } /** - * Returns the value of a setting for the entity reference selection handler. + * Creates a new entity from a label entered in the autocomplete input. * - * @param string $setting_name - * The setting name. - * @param string $entity_type_id - * The id of the entity type. + * @param string $label + * The entity label. + * @param int $uid + * The entity uid. + * @param string $target_type + * The target entity type id. * - * @return mixed - * The setting value. + * @return \Drupal\Core\Entity\EntityInterface + * The newly created entity. */ - protected function getHandlerSetting($setting_name, $entity_type_id) { - $settings = $this->getFieldSettings(); - return isset($settings[$entity_type_id]['handler_settings'][$setting_name]) ? $settings[$entity_type_id]['handler_settings'][$setting_name] : NULL; + protected function createNewEntity($label, $uid, $target_type = NULL) { + if ($target_type === NULL) { + return parent::createNewEntity($label, $uid); + } + $entity_manager = \Drupal::entityManager(); + $target_bundles = $this->getSelectionHandlerSetting('target_bundles', $target_type); + + // Get the bundle. + if (!empty($target_bundles)) { + $bundle = reset($target_bundles); + } + else { + $bundles = $entity_manager->getBundleInfo($target_type); + $bundle = reset($bundles); + } + + $entity_type = $entity_manager->getDefinition($target_type); + $bundle_key = $entity_type->getKey('bundle'); + $label_key = $entity_type->getKey('label'); + + $entity = $entity_manager->getStorage($target_type)->create(array( + $label_key => $label, + $bundle_key => $bundle, + )); + + if ($entity instanceof EntityOwnerInterface) { + $entity->setOwnerId($uid); + } + + return $entity; } } diff --git a/src/Plugin/Validation/Constraint/ValidDynamicReferenceConstraintValidator.php b/src/Plugin/Validation/Constraint/ValidDynamicReferenceConstraintValidator.php index 436a264..a466095 100644 --- a/src/Plugin/Validation/Constraint/ValidDynamicReferenceConstraintValidator.php +++ b/src/Plugin/Validation/Constraint/ValidDynamicReferenceConstraintValidator.php @@ -26,7 +26,7 @@ class ValidDynamicReferenceConstraintValidator extends ConstraintValidator { } $id = $value->get('target_id')->getValue(); $type = $value->get('target_type')->getValue(); - $types = DynamicEntityReferenceItem::getAllEntityTypeIds($value->getFieldDefinition()->getSettings()); + $types = DynamicEntityReferenceItem::getTargetTypes($value->getFieldDefinition()->getSettings()); $valid_type = !empty($type) && in_array($type, array_keys($types)); // '0' or NULL are considered valid empty references. if (empty($id) && $valid_type) { diff --git a/src/SelectionPluginManager.php b/src/SelectionPluginManager.php new file mode 100644 index 0000000..02aebd8 --- /dev/null +++ b/src/SelectionPluginManager.php @@ -0,0 +1,39 @@ +getSettings(); + $options = array( + 'target_type' => $target_type, + 'handler' => $settings[$target_type]['handler'], + 'handler_settings' => $settings[$target_type]['handler_settings'], + 'entity' => $entity, + ); + return $this->getInstance($options); + } + +}