openlayers-8.x-4.x-dev/src/Form/OpenlayersLayerFormBase.php
src/Form/OpenlayersLayerFormBase.php
<?php
namespace Drupal\openlayers\Form;
use Drupal\Core\Entity\EntityForm;
use Drupal\Core\Entity\EntityStorageInterface;
use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Link;
use Symfony\Component\DependencyInjection\ContainerInterface;
/**
* Class OpenlayersLayerFormBase.
*
* Typically, we need to build the same form for both adding a new entity,
* and editing an existing entity. Instead of duplicating our form code,
* we create a base class. Drupal never routes to this class directly,
* but instead through the child classes of OpenlayersLayerAddForm and OpenlayersLayerEditForm.
*
* @ingroup config_entity_example
*/
class OpenlayersLayerFormBase extends EntityForm {
/**
* An entity query factory for the openlayers_layer entity type.
*
* @var \Drupal\Core\Entity\EntityStorageInterface
*/
protected $entityStorage;
/**
* Construct the LayerFormBase.
*
* For simple entity forms, there's no need for a constructor. Our openlayers_layer form
* base, however, requires an entity query factory to be injected into it
* from the container. We later use this query factory to build an entity
* query for the exists() method.
*
* @param \Drupal\Core\Entity\EntityStorageInterface $entity_storage
* An entity query factory for the openlayers_layer entity type.
*/
public function __construct(EntityStorageInterface $entity_storage) {
$this->entityStorage = $entity_storage;
}
/**
* Factory method for LayerFormBase.
*
* When Drupal builds this class it does not call the constructor directly.
* Instead, it relies on this method to build the new object. Why? The class
* constructor may take multiple arguments that are unknown to Drupal. The
* create() method always takes one parameter -- the container. The purpose
* of the create() method is twofold: It provides a standard way for Drupal
* to construct the object, meanwhile it provides you a place to get needed
* constructor parameters from the container.
*
* In this case, we ask the container for an entity query factory. We then
* pass the factory to our class as a constructor parameter.
*/
public static function create(ContainerInterface $container) {
$form = new static($container->get('entity_type.manager')->getStorage('openlayers_layer'));
$form->setMessenger($container->get('messenger'));
return $form;
}
/**
* Overrides Drupal\Core\Entity\EntityFormController::form().
*
* Builds the entity add/edit form.
*
* @param array $form
* An associative array containing the structure of the form.
* @param \Drupal\Core\Form\FormStateInterface $form_state
* An associative array containing the current state of the form.
*
* @return array
* An associative array containing the openlayers_layer add/edit form.
*/
public function buildForm(array $form, FormStateInterface $form_state) {
// Get anything we need from the base class.
$form = parent::buildForm($form, $form_state);
// Drupal provides the entity to us as a class variable. If this is an
// existing entity, it will be populated with existing values as class
// variables. If this is a new entity, it will be a new object with the
// class of our entity. Drupal knows which class to call from the
// annotation on our Layer class.
$openlayers_layer = $this->entity;
$sourceNames = \Drupal::service('config.storage')->listAll('openlayers.openlayers_source');
$source_options = [];
foreach ($sourceNames as $sourceName) {
$sourceLabel = \Drupal::config($sourceName)->get('label');
$sourceName = str_replace('openlayers.openlayers_source.', '', $sourceName);
$source_options[$sourceName] = $sourceLabel;
}
$layerPlugins = $this->getLayers();
$layerOptions = [];
foreach ($layerPlugins as $key => $layerPlugin) {
$layerOptions[$layerPlugin['id']] = isset($layerPlugin['label']) ? $layerPlugin['label'] : 'Unknown (' . $key . ')';
}
$source_options = [];
$sources = $this->entity->getAllSources();
foreach ($sources as $source => $definition) {
$source_options[$source] = $definition;
}
// Build the form.
$form['label'] = [
'#type' => 'textfield',
'#title' => $this->t('Label'),
'#maxlength' => 255,
'#default_value' => $openlayers_layer->label(),
'#required' => TRUE,
];
$form['id'] = [
'#type' => 'machine_name',
'#title' => $this->t('Machine name'),
'#default_value' => $openlayers_layer->id(),
'#machine_name' => [
'exists' => [$this, 'exists'],
'replace_pattern' => '([^a-z0-9_]+)|(^custom$)',
'error' => 'The machine-readable name must be unique, and can only contain lowercase letters, numbers, and underscores. Additionally, it can not be the reserved word "custom".',
],
'#disabled' => !$openlayers_layer->isNew(),
];
$form['pluginId'] = [
'#title' => t('Layer Type'),
'#type' => 'select',
'#description' => t(''),
'#options' => $layerOptions,
'#default_value' => isset($openlayers_layer->pluginId) ? $openlayers_layer->pluginId : null,
'#required' => true,
];
$form['source'] = [
'#title' => t('Source'),
'#type' => 'select',
'#description' => t(''),
'#options' => $source_options,
'#default_value' => isset($openlayers_layer->source) ? $openlayers_layer->source : null,
'#required' => true,
];
$form['is_configurable'] = [
'#type' => 'value',
'#value' => TRUE,
];
/*
$form['service'] = [
'#type' => 'value',
'#value' => 'zzzzzzzzzz',
];
*/
$form['options']['test1'] = [
'#type' => 'value',
'#value' => 'xxxxxxxx',
];
$form['options']['test2'] = [
'#type' => 'value',
'#value' => 'yyyyyyyy',
];
$form['options']['test3'] = [
'#type' => 'value',
'#value' => 'zzzzzzzz',
];
// Return the form.
return $form;
}
/**
* Checks for an existing openlayers_layer.
*
* @param string|int $entity_id
* The entity ID.
* @param array $element
* The form element.
* @param \Drupal\Core\Form\FormStateInterface $form_state
* The form state.
*
* @return bool
* TRUE if this format already exists, FALSE otherwise.
*/
public function exists($entity_id, array $element, FormStateInterface $form_state) {
// Use the query factory to build a new openlayers_layer entity query.
$query = $this->entityStorage->getQuery();
// Query the entity ID to see if its in use.
$result = $query->condition('id', $element['#field_prefix'] . $entity_id)
->execute();
// We don't need to return the ID, only if it exists or not.
return (bool) $result;
}
/**
* Overrides Drupal\Core\Entity\EntityFormController::actions().
*
* To set the submit button text, we need to override actions().
*
* @param array $form
* An associative array containing the structure of the form.
* @param \Drupal\Core\Form\FormStateInterface $form_state
* An associative array containing the current state of the form.
*
* @return array
* An array of supported actions for the current entity form.
*/
protected function actions(array $form, FormStateInterface $form_state) {
// Get the basic actins from the base class.
$actions = parent::actions($form, $form_state);
// Change the submit button text.
$actions['submit']['#value'] = $this->t('Save');
// Return the result.
return $actions;
}
/**
* {@inheritdoc}
*/
public function validateForm(array &$form, FormStateInterface $form_state) {
parent::validateForm($form, $form_state);
// Add code here to validate your config entity's form elements.
// Nothing to do here.
}
/**
* Overrides Drupal\Core\Entity\EntityFormController::save().
*
* Saves the entity. This is called after submit() has built the entity from
* the form values. Do not override submit() as save() is the preferred
* method for entity form controllers.
*
* @param array $form
* An associative array containing the structure of the form.
* @param \Drupal\Core\Form\FormStateInterface $form_state
* An associative array containing the current state of the form.
*/
public function save(array $form, FormStateInterface $form_state) {
// EntityForm provides us with the entity we're working on.
$openlayers_layer = $this->getEntity();
$openlayers_layer->options['source'] = $openlayers_layer->get('source');
$layerPlugins = $this->getLayers();
$layerPlugin = $layerPlugins[$openlayers_layer->pluginId];
$openlayers_layer->service = $layerPlugin['service'];
$openlayers_layer->is_configurable = (isset($layerPlugin['is_configurable']) && $layerPlugin['is_configurable'] === 'true') ? true: false;
// Drupal already populated the form values in the entity object. Each
// form field was saved as a public variable in the entity class. PHP
// allows Drupal to do this even if the method is not defined ahead of
// time.
$status = $openlayers_layer->save();
// Grab the URL of the new entity. We'll use it in the message.
$url = $openlayers_layer->toUrl();
// Create an edit link.
$edit_link = Link::fromTextAndUrl($this->t('Edit'), $url)->toString();
if ($status == SAVED_UPDATED) {
// If we edited an existing entity...
$this->messenger()->addMessage($this->t('Layer %label has been updated.', ['%label' => $openlayers_layer->label()]));
$this->logger('contact')->notice('Layer %label has been updated.', ['%label' => $openlayers_layer->label(), 'link' => $edit_link]);
}
else {
// If we created a new entity...
$this->messenger()->addMessage($this->t('Layer %label has been added.', ['%label' => $openlayers_layer->label()]));
$this->logger('contact')->notice('Layer %label has been added.', ['%label' => $openlayers_layer->label(), 'link' => $edit_link]);
}
// Redirect the user back to the listing route after the save operation.
$form_state->setRedirect('entity.openlayers_layer.list');
}
public function getLayers() {
$pluginManager = \Drupal::service('plugin.manager.openlayers');
$layerPlugins = $pluginManager->getDefinitions('layer');
return $layerPlugins;
}
}
