FormTestStorageForm.php

<?php

namespace Drupal\form_test\Form;

use Drupal\Component\Utility\Html;
use Drupal\Core\Form\FormBase;
use Drupal\Core\Form\FormStateInterface;

/**
 * A multistep form for testing the form storage.
 *
 * It uses two steps for editing a virtual "thing". Any changes to it are saved
 * in the form storage and have to be present during any step. By setting the
 * request parameter "cache" the form can be tested with caching enabled, as
 * it would be the case, if the form would contain some #ajax callbacks.
 *
 * @internal
 */
class FormTestStorageForm extends FormBase {

  /**
   * {@inheritdoc}
   */
  public function getFormId() {
    return 'form_test_storage_form';
  }

  /**
   * {@inheritdoc}
   */
  public function buildForm(array $form, FormStateInterface $form_state) {
    if ($form_state
      ->isRebuilding()) {
      $form_state
        ->setUserInput([]);
    }

    // Initialize
    $storage = $form_state
      ->getStorage();
    $session = $this
      ->getRequest()
      ->getSession();
    if (empty($storage)) {
      $user_input = $form_state
        ->getUserInput();
      if (empty($user_input)) {
        $session
          ->set('constructions', 0);
      }

      // Put the initial thing into the storage
      $storage = [
        'thing' => [
          'title' => 'none',
          'value' => '',
        ],
      ];
      $form_state
        ->setStorage($storage);
    }

    // Count how often the form is constructed.
    $counter = $session
      ->get('constructions');
    $session
      ->set('constructions', ++$counter);
    $this
      ->messenger()
      ->addStatus("Form constructions: " . $counter);
    $form['title'] = [
      '#type' => 'textfield',
      '#title' => 'Title',
      '#default_value' => $storage['thing']['title'],
      '#required' => TRUE,
    ];
    $form['value'] = [
      '#type' => 'textfield',
      '#title' => 'Value',
      '#default_value' => $storage['thing']['value'],
      '#element_validate' => [
        '::elementValidateValueCached',
      ],
    ];
    $form['continue_button'] = [
      '#type' => 'button',
      '#value' => 'Reset',
    ];
    $form['continue_submit'] = [
      '#type' => 'submit',
      '#value' => 'Continue submit',
      '#submit' => [
        '::continueSubmitForm',
      ],
    ];
    $form['submit'] = [
      '#type' => 'submit',
      '#value' => 'Save',
    ];

    // @todo Remove this in https://www.drupal.org/node/2524408, because form
    //   cache immutability is no longer necessary, because we no longer cache
    //   forms during safe HTTP methods. In the meantime, because
    //   Drupal\system\Tests\Form still has test coverage for a poisoned form
    //   cache following a GET request, trick $form_state into caching the form
    //   to keep that test working until we either remove it or change it in
    //   that issue.
    if ($this
      ->getRequest()
      ->get('immutable')) {
      $form_state
        ->addBuildInfo('immutable', TRUE);
      if ($this
        ->getRequest()
        ->get('cache') && $this
        ->getRequest()
        ->isMethodCacheable()) {
        $form_state
          ->setRequestMethod('FAKE');
        $form_state
          ->setCached();
      }
    }
    return $form;
  }

  /**
   * {@inheritdoc}
   */
  public function validateForm(array &$form, FormStateInterface $form_state) {
    if ($this
      ->getRequest()
      ->get('cache')) {

      // Manually activate caching, so we can test that the storage keeps working
      // when it's enabled.
      $form_state
        ->setCached();
    }
  }

  /**
   * Form element validation handler for 'value' element.
   *
   * Tests updating of cached form storage during validation.
   */
  public function elementValidateValueCached($element, FormStateInterface $form_state) {

    // If caching is enabled and we receive a certain value, change the storage.
    // This presumes that another submitted form value triggers a validation error
    // elsewhere in the form. Form API should still update the cached form storage
    // though.
    if ($this
      ->getRequest()
      ->get('cache') && $form_state
      ->getValue('value') == 'change_title') {
      $form_state
        ->set([
        'thing',
        'changed',
      ], TRUE);
    }
  }

  /**
   * {@inheritdoc}
   */
  public function continueSubmitForm(array &$form, FormStateInterface $form_state) {
    $form_state
      ->set([
      'thing',
      'title',
    ], $form_state
      ->getValue('title'));
    $form_state
      ->set([
      'thing',
      'value',
    ], $form_state
      ->getValue('value'));
    $form_state
      ->setRebuild();
  }

  /**
   * {@inheritdoc}
   */
  public function submitForm(array &$form, FormStateInterface $form_state) {
    $this
      ->messenger()
      ->addStatus("Title: " . Html::escape($form_state
      ->getValue('title')));
    $this
      ->messenger()
      ->addStatus("Form constructions: " . $this
      ->getRequest()
      ->getSession()
      ->get('constructions'));
    if ($form_state
      ->has([
      'thing',
      'changed',
    ])) {
      $this
        ->messenger()
        ->addStatus("The thing has been changed.");
    }
    $form_state
      ->setRedirect('<front>');
  }

}