public function FormBuilder::processForm

File

core/lib/Drupal/Core/Form/FormBuilder.php, line 556

Class

FormBuilder

Provides form building and processing.

Namespace

Code

public function processForm($form_id, &$form, FormStateInterface &$form_state) {
  $form_state
    ->setValues([]);

  // With GET, these forms are always submitted if requested.
  if ($form_state
    ->isMethodType('get') && $form_state
    ->getAlwaysProcess()) {
    $input = $form_state
      ->getUserInput();
    if (!isset($input['form_build_id'])) {
      $input['form_build_id'] = $form['#build_id'];
    }
    if (!isset($input['form_id'])) {
      $input['form_id'] = $form_id;
    }
    if (!isset($input['form_token']) && isset($form['#token'])) {
      $input['form_token'] = $this->csrfToken
        ->get($form['#token']);
    }
    $form_state
      ->setUserInput($input);
  }

  // self::doBuildForm() finishes building the form by calling element
  // #process functions and mapping user input, if any, to #value properties,
  // and also storing the values in $form_state->getValues(). We need to
  // retain the unprocessed $form in case it needs to be cached.
  $unprocessed_form = $form;
  $form = $this
    ->doBuildForm($form_id, $form, $form_state);

  // Only process the input if we have a correct form submission.
  if ($form_state
    ->isProcessingInput()) {

    // Form values for programmed form submissions typically do not include a
    // value for the submit button. But without a triggering element, a
    // potentially existing #limit_validation_errors property on the primary
    // submit button is not taken account. Therefore, check whether there is
    // exactly one submit button in the form, and if so, automatically use it
    // as triggering_element.
    $buttons = $form_state
      ->getButtons();
    if ($form_state
      ->isProgrammed() && !$form_state
      ->getTriggeringElement() && count($buttons) == 1) {
      $form_state
        ->setTriggeringElement(reset($buttons));
    }
    $this->formValidator
      ->validateForm($form_id, $form, $form_state);

    // If there are no errors and the form is not rebuilding, submit the form.
    if (!$form_state
      ->isRebuilding() && !FormState::hasAnyErrors()) {
      $submit_response = $this->formSubmitter
        ->doSubmitForm($form, $form_state);

      // If this form was cached, delete it from the cache after submission.
      if ($form_state
        ->isCached()) {
        $this
          ->deleteCache($form['#build_id']);
      }

      // If the form submission directly returned a response, return it now.
      if ($submit_response) {
        return $submit_response;
      }
    }

    // Don't rebuild or cache form submissions invoked via self::submitForm().
    if ($form_state
      ->isProgrammed()) {
      return;
    }

    // If $form_state->isRebuilding() has been set and input has been
    // processed without validation errors, we are in a multi-step workflow
    // that is not yet complete. A new $form needs to be constructed based on
    // the changes made to $form_state during this request. Normally, a submit
    // handler sets $form_state->isRebuilding() if a fully executed form
    // requires another step. However, for forms that have not been fully
    // executed (e.g., Ajax submissions triggered by non-buttons), there is no
    // submit handler to set $form_state->isRebuilding(). It would not make
    // sense to redisplay the identical form without an error for the user to
    // correct, so we also rebuild error-free non-executed forms, regardless
    // of $form_state->isRebuilding().
    // @todo Simplify this logic; considering Ajax and non-HTML front-ends,
    //   along with element-level #submit properties, it makes no sense to
    //   have divergent form execution based on whether the triggering element
    //   has #executes_submit_callback set to TRUE.
    if (($form_state
      ->isRebuilding() || !$form_state
      ->isExecuted()) && !FormState::hasAnyErrors()) {

      // Form building functions (e.g., self::handleInputElement()) may use
      // $form_state->isRebuilding() to determine if they are running in the
      // context of a rebuild, so ensure it is set.
      $form_state
        ->setRebuild();
      $form = $this
        ->rebuildForm($form_id, $form_state, $form);
    }
  }

  // After processing the form, the form builder or a #process callback may
  // have called $form_state->setCached() to indicate that the form and form
  // state shall be cached. But the form may only be cached if
  // $form_state->disableCache() is not called. Only cache $form as it was
  // prior to self::doBuildForm(), because self::doBuildForm() must run for
  // each request to accommodate new user input. Rebuilt forms are not cached
  // here, because self::rebuildForm() already takes care of that.
  if (!$form_state
    ->isRebuilding() && $form_state
    ->isCached()) {
    $this
      ->setCache($form['#build_id'], $unprocessed_form, $form_state);
  }
}