private function serializeForm(FormInterface $form)
{
if (!$form->all()) {
return $form->getViewData();
}
$data = null;
foreach ($form->all() as $child) {
$name = $child->getConfig()->getName();
$data[$name] = $this->serializeForm($child);
}
return $data;
}
/**
* @dataProvider getValidInputs
*/
public function testSubmit($submitted, $expected)
{
$this->sut->submit($submitted);
$msg = '';
if (!$this->sut->isValid()) {
$msg = print_r($this->sut->getErrors(), true);
foreach ($this->sut->all() as $child) {
$msg .= "\n" . print_r($child->getErrors(), true);
}
}
$this->assertTrue($this->sut->isValid(), $msg);
$this->assertEquals($expected, $this->sut->getData());
}
public function interactWith(FormInterface $form, HelperSet $helperSet, InputInterface $input, OutputInterface $output)
{
if (!$form->isRoot()) {
throw new CanNotInteractWithForm('This interactor only works with root forms');
}
if ($input->isInteractive()) {
throw new CanNotInteractWithForm('This interactor only works with non-interactive input');
}
/*
* We need to adjust the input values for repeated types by copying the provided value to both of the repeated
* fields. We only loop through the top-level fields, since there are no command options for deeper lying fields
* anyway.
*
* The fix was provided by @craigh
*
* P.S. If we need to add another fix like this, we should move this out to dedicated "input fixer" classes.
*/
foreach ($form->all() as $child) {
$config = $child->getConfig();
$name = $child->getName();
if ($config->getType()->getInnerType() instanceof RepeatedType && $input->hasOption($name)) {
$input->setOption($name, [$config->getOption('first_name') => $input->getOption($name), $config->getOption('second_name') => $input->getOption($name)]);
}
}
// use the original input as the submitted data
return $input;
}
/**
* Merges constraints from the form with constraints in the class metaData
*
* @param FormInterface $form
*/
public function mergeConstraints(FormInterface &$form)
{
$metaData = null;
$dataClass = $form->getConfig()->getDataClass();
if ($dataClass != '') {
$metaData = $this->validator->getMetadataFor($dataClass);
}
if ($metaData instanceof ClassMetadata) {
/**
* @var FormInterface $child
*/
foreach ($form->all() as $child) {
$options = $child->getConfig()->getOptions();
$name = $child->getConfig()->getName();
$type = $child->getConfig()->getType()->getName();
if (isset($options['constraints'])) {
$existingConstraints = $options['constraints'];
$extractedConstraints = $this->extractPropertyConstraints($name, $metaData);
// Merge all constraints
$options['constraints'] = array_merge($existingConstraints, $extractedConstraints);
}
$form->add($name, $type, $options);
}
}
}
public function transform(FormInterface $form, $extensions = [])
{
$data = [];
$order = 1;
$required = [];
foreach ($form->all() as $name => $field) {
$transformedChild = $this->resolver->resolve($field)->transform($field, $extensions);
$transformedChild['propertyOrder'] = $order;
$data[$name] = $transformedChild;
$order++;
if ($this->resolver->resolve($field)->isRequired($field)) {
$required[] = $field->getName();
}
}
$schema = ['title' => $form->getConfig()->getOption('label'), 'type' => 'object', 'properties' => $data];
if (!empty($required)) {
$schema['required'] = $required;
}
$innerType = $form->getConfig()->getType()->getInnerType();
if (method_exists($innerType, 'buildLiform')) {
$schema['liform'] = $innerType->buildLiform($form);
}
$this->addCommonSpecs($form, $schema, $extensions);
return $schema;
}
/**
* @param FormInterface $form
* @param array $results
*
* @return array
*/
private function formatFormErrors(FormInterface $form, &$results = array())
{
/*
* first check if there are any errors bound for this element
*/
$errors = $form->getErrors();
if (count($errors)) {
$messages = [];
foreach ($errors as $error) {
if ($error instanceof FormError) {
$messages[] = $this->translator->trans($error->getMessage(), $error->getMessageParameters(), 'validators');
}
$results[] = ['property_path' => $this->formatPropertyPath($error), 'message' => join(', ', $messages)];
}
}
/*
* Then, check if there are any children. If yes, then parse them
*/
$children = $form->all();
if (count($children)) {
foreach ($children as $child) {
if ($child instanceof FormInterface) {
$this->formatFormErrors($child, $results);
}
}
}
return $results;
}
/**
* {@inheritDoc}
*/
public function buildView(FormView $view, FormInterface $form, array $options)
{
$children = $form->all();
$view->vars['value']['type'] = $children['type']->getViewData();
$view->vars['value']['value'] = $children['value']->getViewData();
$view->vars['show_filter'] = $options['show_filter'];
}
/**
* {@inheritdoc}
*
* @param FormView $view
* @param FormInterface $form
* @param array $options
*/
public function buildView(FormView $view, FormInterface $form, array $options)
{
if ($form->count() == 0) {
return;
}
array_map(array($this, 'validateButton'), $form->all());
}
/**
* Returns an array with form fields errors
*
* @param FormInterface $form
* @param bool|false $useLabels
* @param array $errors
* @return array
*/
public function getErrorMessages(FormInterface $form, $useLabels = false, $errors = array())
{
if ($form->count() > 0) {
foreach ($form->all() as $child) {
if (!$child->isValid()) {
$errors = $this->getErrorMessages($child, $useLabels, $errors);
}
}
}
foreach ($form->getErrors() as $error) {
if ($useLabels) {
$fieldNameData = $this->getErrorFormLabel($form);
} else {
$fieldNameData = $this->getErrorFormId($form);
}
$fieldName = $fieldNameData;
if ($useLabels) {
/**
* @ignore
*/
$fieldName = $this->translator->trans($fieldNameData['label'], array(), $fieldNameData['domain']);
}
$errors[$fieldName] = $error->getMessage();
}
return $errors;
}
public function finishView(FormView $view, FormInterface $form, array $options)
{
foreach ($form->all() as $identifier => $child) {
if (false === $child->getConfig()->getOption('serialize_only')) {
continue;
}
unset($view->children[$identifier]);
}
}
public function __construct(FormInterface $form)
{
$this->name = $form->getName();
foreach ($form->getErrors() as $error) {
$this->errors[] = $error;
}
foreach ($form->all() as $child) {
$this->children[] = new static($child);
}
}
/**
* @param InputInterface $input
* @param FormInterface $form
*
* @return array
*/
private function convertInputToSubmittedData(InputInterface $input, FormInterface $form)
{
$submittedData = [];
// we don't need to do this recursively, since command options are one-dimensional (or are they?)
foreach ($form->all() as $name => $field) {
if ($input->hasOption($name)) {
$submittedData[$name] = $input->getOption($name);
}
}
return $submittedData;
}
/**
* @param FormInterface $form
* @return array
*/
protected function getFormChildErrorMessages(FormInterface $form)
{
$errors = [];
foreach ($form->all() as $child) {
if (!empty($child) && !$child->isValid()) {
foreach ($this->getErrorMessages($child) as $error) {
$errors[] = $error;
}
}
}
return $errors;
}
/**
* @param FormInterface $form
* @return array
*/
protected function getFormChildErrorMessages(FormInterface $form)
{
$errors = [];
foreach ($form->all() as $child) {
if ($this->shouldAddChildErrorMessage($child)) {
foreach ($this->getErrorMessages($child) as $error) {
$errors[] = $error;
}
}
}
return $errors;
}
/**
* @param mixed $data
* @param FormInterface $form
*
* @return mixed
*
* @throws \InvalidArgumentException
*/
public function getFullAddress($data, FormInterface $form)
{
$fields = array();
foreach ($form->all() as $field) {
$options = $field->getConfig()->getOptions();
if (isset($options['geo_code_field']) && true == $options['geo_code_field']) {
$fields[] = $data[$field->getName()];
}
}
if (count($fields)) {
return implode(' ', $fields);
}
throw new \InvalidArgumentException('GeoDataAdapter address field mismatch');
}
/**
* @param FormInterface $form
* @return string All form's error messages concatenated into one string
*/
protected function getFormErrors(FormInterface $form)
{
$errors = '';
/** @var FormError $error */
foreach ($form->getErrors() as $error) {
$errors .= $error->getMessage() . "\n";
}
foreach ($form->all() as $key => $child) {
if ($err = $this->getFormErrors($child)) {
$errors .= sprintf("%s: %s\n", $key, $err);
}
}
return $errors;
}
/**
* Helper for extracting errors from form child elements
*/
public function getFormErrors(FormInterface $form)
{
$errors = array();
foreach ($form->all() as $field) {
$childErrors = $this->getFormErrors($field);
if ($childErrors) {
$errors[$field->getName()] = $childErrors;
}
}
foreach ($form->getErrors() as $error) {
$errors['errors'] = $error->getMessage();
}
return $errors;
}
/**
* Helper for extracting errors from form child elements
*/
public static function getErrors(FormInterface $form)
{
$errors = array();
foreach ($form->all() as $field) {
$childErrors = self::getErrors($field);
if ($childErrors) {
$errors[$form->getName() . '_' . $field->getName()][] = $childErrors;
}
}
foreach ($form->getErrors() as $error) {
$errors[] = $error->getMessage();
}
return $errors;
}
/**
* @param FormInterface $form
* @return \Symfony\Component\Form\FormError[]
*/
protected function getAllErrors(FormInterface $form)
{
$errors = $form->getErrors();
$children = $form->all();
if (!count($errors) && !count($children)) {
return null;
}
$section = ['field' => $form->getName()];
if (count($errors)) {
$section['errors'] = array_map(function (FormError $error) {
return ['message' => $error->getMessage(), 'parameters' => $error->getMessageParameters()];
}, iterator_to_array($form->getErrors()));
}
if (count($children)) {
$section['children'] = array_values(array_filter(array_map(function (FormInterface $field) {
return $this->getAllErrors($field);
}, $form->all())));
if (!count($errors) && !count($section['children'])) {
return null;
}
}
return $section;
}
public function formErrorsToArray(FormInterface $form)
{
$errors = array();
foreach ($form->getErrors() as $error) {
$errors[] = $error->getMessage();
}
/* @var $child \Symfony\Component\Form\Form */
foreach ($form->all() as $child) {
if (!$child->isValid()) {
$errors[$child->getName()] = $this->formErrorsToArray($child);
}
}
return $errors;
}
/**
* {@inheritdoc}
*/
public function handleRequest(FormInterface $form, $request = null)
{
if (null !== $request) {
throw new UnexpectedTypeException($request, 'null');
}
$name = $form->getName();
$method = $form->getConfig()->getMethod();
if ($method !== self::getRequestMethod()) {
return;
}
if ('GET' === $method) {
if ('' === $name) {
$data = $_GET;
} else {
// Don't submit GET requests if the form's name does not exist
// in the request
if (!isset($_GET[$name])) {
return;
}
$data = $_GET[$name];
}
} else {
$fixedFiles = array();
foreach ($_FILES as $name => $file) {
$fixedFiles[$name] = self::stripEmptyFiles(self::fixPhpFilesArray($file));
}
if ('' === $name) {
$params = $_POST;
$files = $fixedFiles;
} elseif (array_key_exists($name, $_POST) || array_key_exists($name, $fixedFiles)) {
$default = $form->getConfig()->getCompound() ? array() : null;
$params = array_key_exists($name, $_POST) ? $_POST[$name] : $default;
$files = array_key_exists($name, $fixedFiles) ? $fixedFiles[$name] : $default;
} else {
// Don't submit the form if it is not present in the request
return;
}
if (is_array($params) && is_array($files)) {
$data = array_replace_recursive($params, $files);
} else {
$data = $params ?: $files;
}
}
// Don't auto-submit the form unless at least one field is present.
if ('' === $name && count(array_intersect_key($data, $form->all())) <= 0) {
return;
}
$form->submit($data, 'PATCH' !== $method);
}
/**
* Collects errors from form
*
* @param FormInterface $form
* @return array
*/
public function getErrorsFromForm(FormInterface $form)
{
$errors = array();
foreach ($form->getErrors() as $error) {
$errors[] = $error->getMessage();
}
foreach ($form->all() as $childForm) {
if ($childForm instanceof FormInterface) {
if ($childErrors = $this->getErrorsFromForm($childForm)) {
$errors[$childForm->getName()] = $childErrors;
}
}
}
return $errors;
}
/**
* Returns the form's data like $form->submit() expects it
*
* @param FormInterface $form
* @return array
*/
protected function unbind(FormInterface $form)
{
if ($form->count() > 0) {
$ary = array();
foreach ($form->all() as $name => $child) {
$value = $this->unbind($child);
if (null !== $value || (is_array($value) || $value instanceof Collection) && count($value) > 0) {
$ary[$name] = $value;
}
}
return $ary;
} else {
$data = $form->getViewData();
return $data instanceof Collection ? $data->toArray() : $data;
}
}
function it_does_not_handle_form_when_the_form_is_invalid(Request $request, FormFactoryInterface $formFactory, FormBuilderInterface $formBuilder, FormInterface $form, FormError $formError, FormInterface $child)
{
$formFactory->createNamedBuilder('', 'kreta_dummy_type', null, [])->shouldBeCalled()->willReturn($formBuilder);
$formBuilder->getForm()->shouldBeCalled()->willReturn($form);
$request->isMethod('POST')->shouldBeCalled()->willReturn(true);
$form->handleRequest($request)->shouldBeCalled()->willReturn($form);
$form->isValid()->shouldBeCalled()->willReturn(false);
$form->getErrors()->shouldBeCalled()->willReturn([$formError]);
$formError->getMessage()->shouldBeCalled()->willReturn('Form error');
$form->all()->shouldBeCalled()->willReturn([$child]);
$child->isValid()->shouldBeCalled()->willReturn(false);
$child->getName()->shouldBeCalled()->willReturn('Child form error');
$child->getErrors()->shouldBeCalled()->willReturn([]);
$child->all()->shouldBeCalled()->willReturn([]);
$this->shouldThrow(new InvalidFormException(['Form error', 'Child form error' => []]))->during('handleForm', [$request]);
}
/**
* @param FormInterface $form
* @return array
*/
protected function getErrorMessages(FormInterface $form)
{
$errors = array();
foreach ($form->getErrors() as $key => $error) {
$errors[] = $this->translator->trans($error->getMessage());
}
foreach ($form->all() as $child) {
if (!$child->isValid()) {
$childErrors = $this->getErrorMessages($child);
foreach ($childErrors as $childError) {
$errors[] = $childError;
}
}
}
return $errors;
}
/**
* Collect form errors.
*
* @param FormInterface $form
*
* @return array
*/
protected function getFormErrors(FormInterface $form)
{
$errors = [];
foreach ($form->getErrors() as $error) {
$errors[] = $error->getMessage();
}
foreach ($form->all() as $childForm) {
if ($childForm instanceof FormInterface) {
$childErrors = $this->getFormErrors($childForm);
if ($childErrors) {
$errors[$childForm->getName()] = $childErrors;
}
}
}
return $errors;
}
/**
* Gets all the errors in the current $field and adds them to $_errors, to
* get all errors in the form and its children recursively.
* Also adds display name to error-message.
*
* @param FormInterface $field Field to get Errors from
*/
protected function _getErrors(FormInterface $field)
{
if ($field->getConfig()->getOption('label')) {
$label = $this->_translator->trans($field->getConfig()->getOption('label'));
} else {
$label = ucfirst(trim(strtolower(preg_replace(array('/([A-Z])/', '/[_\\s]+/'), array('_$1', ' '), $field->getName()))));
}
$fieldErrors = array();
foreach ($field->getErrors() as $error) {
// don't show label if error is on the whole form
$fieldErrors[] = $field->isRoot() ? $error->getMessage() : $label . ': ' . $error->getMessage();
}
$this->_errors[] = $fieldErrors;
foreach ($field->all() as $child) {
$this->_getErrors($child);
}
}
public function transform(FormInterface $form, $extensions = [])
{
$children = [];
//$entryType = $form->getConfig()->getAttribute('prototype');
//$children[] = $this->resolver->resolve($entryType)->transform($entryType, $extensions);
//$children[0]['title'] = 'prototype';
foreach ($form->all() as $name => $field) {
$transformedChild = $this->resolver->resolve($field)->transform($field, $extensions);
$children[] = $transformedChild;
if ($this->resolver->resolve($field)->isRequired($field)) {
$required[] = $field->getName();
}
}
$schema = ['type' => 'array', 'title' => $form->getConfig()->getOption('label'), 'items' => $children];
$this->addCommonSpecs($form, $schema, $extensions);
return $schema;
}
/**
* {@inheritdoc}
*/
public function handleRequest(FormInterface $form, $request = null)
{
if (!$request instanceof Request) {
throw new UnexpectedTypeException($request, 'Symfony\\Component\\HttpFoundation\\Request');
}
$name = $form->getName();
$method = $form->getConfig()->getMethod();
if ($method !== $request->getMethod()) {
return;
}
if ('GET' === $method) {
if ('' === $name) {
$data = $request->query->all();
} else {
// Don't submit GET requests if the form's name does not exist
// in the request
if (!$request->query->has($name)) {
return;
}
$data = $request->query->get($name);
}
} else {
if ('' === $name) {
$params = $request->request->all();
$files = $request->files->all();
} elseif ($request->request->has($name) || $request->files->has($name)) {
$default = $form->getConfig()->getCompound() ? array() : null;
$params = $request->request->get($name, $default);
$files = $request->files->get($name, $default);
} else {
// Don't submit the form if it is not present in the request
return;
}
if (is_array($params) && is_array($files)) {
$data = array_replace_recursive($params, $files);
} else {
$data = $params ?: $files;
}
}
// Don't auto-submit the form unless at least one field is present.
if ('' === $name && count(array_intersect_key($data, $form->all())) <= 0) {
return;
}
$form->submit($data, 'PATCH' !== $method);
}
protected function getErrorsFromForm(FormInterface $form)
{
$errors = array();
foreach ($form->getErrors() as $error) {
if ($error->getCause()) {
$errors[$error->getCause()->getPropertyPath()] = $error->getMessage();
} else {
$errors[] = $error->getMessage();
}
}
foreach ($form->all() as $childForm) {
if ($childForm instanceof FormInterface) {
if ($childErrors = $this->getErrorsFromForm($childForm)) {
$errors[$childForm->getName()] = $childErrors;
}
}
}
return $errors;
}