PHP FormStateInterface::setValues方法代码示例

 /**
  * Submit handler for the customer select form.
  *
  * @param array $form
  *   The parent form.
  * @param \Drupal\Core\Form\FormStateInterface $form_state
  *   The current state of the form.
  */
 public function submitCustomerForm(array &$form, FormStateInterface $form_state)
 {
     $values = $form_state->getValues();
     if ($values['customer_type'] == 'existing') {
         $values['mail'] = User::load($values['uid'])->getEmail();
     } else {
         $user = User::create(['name' => $values['mail'], 'mail' => $values['mail'], 'pass' => $values['generate'] ? user_password() : $values['pass'], 'status' => TRUE]);
         $user->save();
         $values['uid'] = $user->id();
     }
     $form_state->setValues($values);
 }

 /**
  * {@inheritdoc}
  */
 public static function submitForm(array &$form, FormStateInterface $form_state, $form_id = NULL)
 {
     $values = $form_state->getValues();
     // Extract the regions from individual dynamic settings.
     $regex = '/^region_well-/';
     $region_wells = [];
     foreach ($values as $key => $value) {
         if (!preg_match($regex, $key)) {
             continue;
         }
         $region_wells[preg_replace($regex, '', $key)] = $value;
         unset($values[$key]);
     }
     // Store the new values.
     $values['region_wells'] = $region_wells;
     $form_state->setValues($values);
 }

 public function resetForm(&$form, FormStateInterface $form_state)
 {
     // _SESSION is not defined for users who are not logged in.
     // If filters are not overridden, store the 'remember' settings on the
     // default display. If they are, store them on this display. This way,
     // multiple displays in the same view can share the same filters and
     // remember settings.
     $display_id = $this->view->display_handler->isDefaulted('filters') ? 'default' : $this->view->current_display;
     if (isset($_SESSION['views'][$this->view->storage->id()][$display_id])) {
         unset($_SESSION['views'][$this->view->storage->id()][$display_id]);
     }
     // Set the form to allow redirect.
     if (empty($this->view->live_preview) && !\Drupal::request()->isXmlHttpRequest()) {
         $form_state->disableRedirect(FALSE);
     } else {
         $form_state->setRebuild();
         $this->view->exposed_data = array();
     }
     $form_state->setRedirect('<current>');
     $form_state->setValues([]);
 }

 /**
  * {@inheritdoc}
  */
 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);
         // \Drupal\Component\Utility\Html::getUniqueId() maintains a cache of
         // element IDs it has seen, so it can prevent duplicates. We want to be
         // sure we reset that cache when a form is processed, so scenarios that
         // result in the form being built behind the scenes and again for the
         // browser don't increment all the element IDs needlessly.
         if (!FormState::hasAnyErrors()) {
             // In case of errors, do not break HTML IDs of other forms.
             Html::resetSeenIds();
         }
         // 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);
     }
 }

 /**
  * Back button handler submit handler.
  *
  * @param array $form
  *   An associative array containing the structure of the form.
  * @param \Drupal\Core\Form\FormStateInterface $form_state
  *   The current state of the form.
  */
 public function pageTwoBackSubmit(array &$form, FormStateInterface &$form_state) {
   $form_state->setValues($form_state->get(['page_values', 1]));
   $form_state->set('page_num', 1);
   $form_state->setRebuild();
 }

 /**
  * Handles validation errors for forms with limited validation.
  *
  * If validation errors are limited then remove any non validated form values,
  * so that only values that passed validation are left for submit callbacks.
  *
  * @param array $form
  *   An associative array containing the structure of the form.
  * @param \Drupal\Core\Form\FormStateInterface $form_state
  *   The current state of the form.
  * @param string $form_id
  *   The unique string identifying the form.
  */
 protected function handleErrorsWithLimitedValidation(&$form, FormStateInterface &$form_state, $form_id)
 {
     // If validation errors are limited then remove any non validated form values,
     // so that only values that passed validation are left for submit callbacks.
     $triggering_element = $form_state->getTriggeringElement();
     if (isset($triggering_element['#limit_validation_errors']) && $triggering_element['#limit_validation_errors'] !== FALSE) {
         $values = array();
         foreach ($triggering_element['#limit_validation_errors'] as $section) {
             // If the section exists within $form_state->getValues(), even if the
             // value is NULL, copy it to $values.
             $section_exists = NULL;
             $value = NestedArray::getValue($form_state->getValues(), $section, $section_exists);
             if ($section_exists) {
                 NestedArray::setValue($values, $section, $value);
             }
         }
         // A button's #value does not require validation, so for convenience we
         // allow the value of the clicked button to be retained in its normal
         // $form_state->getValues() locations, even if these locations are not
         // included in #limit_validation_errors.
         if (!empty($triggering_element['#is_button'])) {
             $button_value = $triggering_element['#value'];
             // Like all input controls, the button value may be in the location
             // dictated by #parents. If it is, copy it to $values, but do not
             // override what may already be in $values.
             $parents = $triggering_element['#parents'];
             if (!NestedArray::keyExists($values, $parents) && NestedArray::getValue($form_state->getValues(), $parents) === $button_value) {
                 NestedArray::setValue($values, $parents, $button_value);
             }
             // Additionally, self::doBuildForm() places the button value in
             // $form_state->getValue(BUTTON_NAME). If it's still there, after
             // validation handlers have run, copy it to $values, but do not override
             // what may already be in $values.
             $name = $triggering_element['#name'];
             if (!isset($values[$name]) && $form_state->getValue($name) === $button_value) {
                 $values[$name] = $button_value;
             }
         }
         $form_state->setValues($values);
     }
 }

 /**
  * {@inheritdoc}
  */
 public function submitConfigurationForm(array &$form, FormStateInterface $form_state)
 {
     $values = $form_state->getValues();
     // Remove the unnecessary form_state values, so no overhead is stored.
     unset($values['actions']);
     if (!empty($values['fields'])) {
         foreach ($values['fields'] as &$field_definition) {
             unset($field_definition['type_descriptions'], $field_definition['actions']);
             $field_definition['fields'] = array_values(array_filter($field_definition['fields']));
         }
     } else {
         $values['fields'] = array();
     }
     $form_state->setValues($values);
     parent::submitConfigurationForm($form, $form_state);
 }

 /**
  * {@inheritdoc}
  */
 public function setValues(array $values)
 {
     $this->decoratedFormState->setValues($values);
     return $this;
 }

 /**
  * @covers ::setValues
  */
 public function testSetValues()
 {
     $values = ['foo' => 'Foo', 'bar' => ['Bar']];
     $this->decoratedFormState->setValues($values)->shouldBeCalled();
     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setValues($values));
 }