/**
* 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));
}