DraggableListBuilder.php

<?php

namespace Drupal\Core\Config\Entity;

use Drupal\Core\Entity\EntityInterface;
use Drupal\Core\Entity\EntityStorageInterface;
use Drupal\Core\Entity\EntityTypeInterface;
use Drupal\Core\Form\FormInterface;
use Drupal\Core\Form\FormStateInterface;

/**
 * Defines a class to build a draggable listing of configuration entities.
 */
abstract class DraggableListBuilder extends ConfigEntityListBuilder implements FormInterface {
    
    /**
     * The key to use for the form element containing the entities.
     *
     * @var string
     */
    protected $entitiesKey = 'entities';
    
    /**
     * The entities being listed.
     *
     * @var \Drupal\Core\Entity\EntityInterface[]
     */
    protected $entities = [];
    
    /**
     * Name of the entity's weight field or FALSE if no field is provided.
     *
     * @var string|bool
     */
    protected $weightKey = FALSE;
    
    /**
     * {@inheritdoc}
     */
    protected $limit = FALSE;
    
    /**
     * The form builder.
     *
     * @var \Drupal\Core\Form\FormBuilderInterface
     */
    protected $formBuilder;
    
    /**
     * {@inheritdoc}
     */
    public function __construct(EntityTypeInterface $entity_type, EntityStorageInterface $storage) {
        parent::__construct($entity_type, $storage);
        // Check if the entity type supports weighting.
        if ($this->entityType
            ->hasKey('weight')) {
            $this->weightKey = $this->entityType
                ->getKey('weight');
        }
    }
    
    /**
     * {@inheritdoc}
     */
    public function buildHeader() {
        $header = [];
        if (!empty($this->weightKey)) {
            $header['weight'] = t('Weight');
        }
        return $header + parent::buildHeader();
    }
    
    /**
     * {@inheritdoc}
     */
    public function buildRow(EntityInterface $entity) {
        $row = [];
        if (!empty($this->weightKey)) {
            // Override default values to markup elements.
            $row['#attributes']['class'][] = 'draggable';
            $row['#weight'] = $entity->get($this->weightKey);
            // Add weight column.
            $row['weight'] = [
                '#type' => 'weight',
                '#title' => t('Weight for @title', [
                    '@title' => $entity->label(),
                ]),
                '#title_display' => 'invisible',
                '#default_value' => $entity->get($this->weightKey),
                '#attributes' => [
                    'class' => [
                        'weight',
                    ],
                ],
            ];
        }
        return $row + parent::buildRow($entity);
    }
    
    /**
     * {@inheritdoc}
     */
    public function render() {
        if (!empty($this->weightKey)) {
            return $this->formBuilder()
                ->getForm($this);
        }
        return parent::render();
    }
    
    /**
     * {@inheritdoc}
     */
    public function buildForm(array $form, FormStateInterface $form_state) {
        $form[$this->entitiesKey] = [
            '#type' => 'table',
            '#header' => $this->buildHeader(),
            '#empty' => t('There are no @label yet.', [
                '@label' => $this->entityType
                    ->getPluralLabel(),
            ]),
            '#tabledrag' => [
                [
                    'action' => 'order',
                    'relationship' => 'sibling',
                    'group' => 'weight',
                ],
            ],
        ];
        $this->entities = $this->load();
        $delta = 10;
        // Change the delta of the weight field if have more than 20 entities.
        if (!empty($this->weightKey)) {
            $count = count($this->entities);
            if ($count > 20) {
                $delta = ceil($count / 2);
            }
        }
        foreach ($this->entities as $entity) {
            $row = $this->buildRow($entity);
            if (isset($row['label'])) {
                $row['label'] = [
                    '#markup' => $row['label'],
                ];
            }
            if (isset($row['weight'])) {
                $row['weight']['#delta'] = $delta;
            }
            $form[$this->entitiesKey][$entity->id()] = $row;
        }
        $form['actions']['#type'] = 'actions';
        $form['actions']['submit'] = [
            '#type' => 'submit',
            '#value' => t('Save'),
            '#button_type' => 'primary',
        ];
        return $form;
    }
    
    /**
     * {@inheritdoc}
     */
    public function validateForm(array &$form, FormStateInterface $form_state) {
        // No validation.
    }
    
    /**
     * {@inheritdoc}
     */
    public function submitForm(array &$form, FormStateInterface $form_state) {
        foreach ($form_state->getValue($this->entitiesKey) as $id => $value) {
            if (isset($this->entities[$id]) && $this->entities[$id]
                ->get($this->weightKey) != $value['weight']) {
                // Save entity only when its weight was changed.
                $this->entities[$id]
                    ->set($this->weightKey, $value['weight']);
                $this->entities[$id]
                    ->save();
            }
        }
    }
    
    /**
     * Returns the form builder.
     *
     * @return \Drupal\Core\Form\FormBuilderInterface
     *   The form builder.
     */
    protected function formBuilder() {
        if (!$this->formBuilder) {
            $this->formBuilder = \Drupal::formBuilder();
        }
        return $this->formBuilder;
    }

}