/**
* {@inheritDoc}
*/
protected function traverseInputs(InputFilterInterface $inputFilter, $values, $callback)
{
$returnValues = null;
foreach ($values as $name => $value) {
if (!$inputFilter->has($name)) {
continue;
}
$input = $inputFilter->get($name);
if ($input instanceof InputFilterInterface && is_array($value)) {
if ($input instanceof CollectionInputFilter) {
$filter = $input->getInputFilter();
foreach ($value as $key => $subValue) {
$filter->setData($subValue);
$returnValues[$name][$key] = (array) $this->traverseInputs($filter, $subValue, $callback);
}
$filter->setData([]);
continue;
}
$retVal = $this->traverseInputs($input, $value, $callback);
if (null !== $retVal) {
$returnValues[$name] = $retVal;
}
continue;
}
$retVal = $callback($input, $value);
if (null !== $retVal) {
$returnValues[$name] = $retVal;
}
}
return $returnValues;
}
/**
* @param InputFilterInterface $inputFilter
* @return array
*/
private function extractErrorMessages(InputFilterInterface $inputFilter)
{
$errorMessages = $inputFilter->getMessages();
array_walk($errorMessages, function (&$value, $key) use($inputFilter) {
if ($inputFilter->has($key) && $inputFilter->get($key) instanceof InputFilterInterface) {
$value = $this->extractErrorMessages($inputFilter->get($key));
} else {
$value = array_values($value);
}
});
return $errorMessages;
}
/**
* Get all validators for a given element
*
* @param InputFilterInterface $inputFilter
* @param ElementInterface $element
* @return mixed
*/
static function getValidatorsForElement(InputFilterInterface $inputFilter, ElementInterface $element)
{
// Check if we are dealing with a fieldset element
if (preg_match('/^.*\\[(.*)\\]$/', $element->getName(), $matches)) {
$elementName = $matches[1];
} else {
$elementName = $element->getName();
}
if (!$inputFilter->has($elementName)) {
return;
}
$input = $inputFilter->get($elementName);
// Make sure NotEmpty validator is added when input is required
// $input->isValid();
$chain = $input->getValidatorChain();
return $chain->getValidators();
}
/**
* Traverse the InputFilter and run a callback against each Input and associated value
*
* @param InputFilterInterface $inputFilter
* @param array $values
* @param callable $callback
* @return array|null
*/
protected function traverseInputs(InputFilterInterface $inputFilter, $values, $callback)
{
$returnValues = null;
foreach ($values as $name => $value) {
if (!$inputFilter->has($name)) {
continue;
}
$input = $inputFilter->get($name);
if ($input instanceof InputFilterInterface && is_array($value)) {
$retVal = $this->traverseInputs($input, $value, $callback);
if (null !== $retVal) {
$returnValues[$name] = $retVal;
}
continue;
}
$retVal = $callback($input, $value);
if (null !== $retVal) {
$returnValues[$name] = $retVal;
}
}
return $returnValues;
}
/**
* Attach defaults provided by the elements to the input filter
*
* @param InputFilterInterface $inputFilter
* @param FieldsetInterface $fieldset Fieldset to traverse when looking for default inputs
* @return void
*/
public function attachInputFilterDefaults(InputFilterInterface $inputFilter, FieldsetInterface $fieldset)
{
$formFactory = $this->getFormFactory();
$inputFactory = $formFactory->getInputFilterFactory();
if ($this instanceof InputFilterProviderInterface) {
foreach ($this->getInputFilterSpecification() as $name => $spec) {
$input = $inputFactory->createInput($spec);
$inputFilter->add($input, $name);
}
}
foreach ($fieldset->getElements() as $element) {
$name = $element->getName();
if ($this->preferFormInputFilter && $inputFilter->has($name)) {
continue;
}
if (!$element instanceof InputProviderInterface) {
if ($inputFilter->has($name)) {
continue;
}
// Create a new empty default input for this element
$spec = array('name' => $name, 'required' => false);
} else {
// Create an input based on the specification returned from the element
$spec = $element->getInputSpecification();
}
$input = $inputFactory->createInput($spec);
$inputFilter->add($input, $name);
}
foreach ($fieldset->getFieldsets() as $fieldset) {
$name = $fieldset->getName();
if (!$fieldset instanceof InputFilterProviderInterface) {
if (!$inputFilter->has($name)) {
// Add a new empty input filter if it does not exist (or the fieldset's object input filter),
// so that elements of nested fieldsets can be recursively added
if ($fieldset->getObject() instanceof InputFilterAwareInterface) {
$inputFilter->add($fieldset->getObject()->getInputFilter(), $name);
} else {
$inputFilter->add(new InputFilter(), $name);
}
}
$fieldsetFilter = $inputFilter->get($name);
if (!$fieldsetFilter instanceof InputFilterInterface) {
// Input attached for fieldset, not input filter; nothing more to do.
continue;
}
// Traverse the elements of the fieldset, and attach any
// defaults to the fieldset's input filter
$this->attachInputFilterDefaults($fieldsetFilter, $fieldset);
continue;
}
if ($inputFilter->has($name)) {
// if we already have an input/filter by this name, use it
continue;
}
// Create an input filter based on the specification returned from the fieldset
$spec = $fieldset->getInputFilterSpecification();
$filter = $inputFactory->createInputFilter($spec);
$inputFilter->add($filter, $name);
// Recursively attach sub filters
$this->attachInputFilterDefaults($filter, $fieldset);
}
}
/**
* Attach defaults provided by the elements to the input filter
*
* @param InputFilterInterface $inputFilter
* @param FieldsetInterface $fieldset Fieldset to traverse when looking for default inputs
* @return void
*/
public function attachInputFilterDefaults(InputFilterInterface $inputFilter, FieldsetInterface $fieldset)
{
$formFactory = $this->getFormFactory();
$inputFactory = $formFactory->getInputFilterFactory();
if ($fieldset instanceof Collection && $fieldset->getTargetElement() instanceof FieldsetInterface) {
$elements = $fieldset->getTargetElement()->getElements();
} else {
$elements = $fieldset->getElements();
}
if (!$fieldset instanceof Collection || !$fieldset->getTargetElement() instanceof FieldsetInterface || $inputFilter instanceof CollectionInputFilter) {
foreach ($elements as $name => $element) {
if ($this->preferFormInputFilter && $inputFilter->has($name)) {
continue;
}
if (!$element instanceof InputProviderInterface) {
if ($inputFilter->has($name)) {
continue;
}
// Create a new empty default input for this element
$spec = array('name' => $name, 'required' => false);
$input = $inputFactory->createInput($spec);
} else {
// Create an input based on the specification returned from the element
$spec = $element->getInputSpecification();
$input = $inputFactory->createInput($spec);
if ($inputFilter->has($name) && $inputFilter instanceof ReplaceableInputInterface) {
$input->merge($inputFilter->get($name));
$inputFilter->replace($input, $name);
continue;
}
}
// Add element input filter to CollectionInputFilter
if ($inputFilter instanceof CollectionInputFilter && !$inputFilter->getInputFilter()->has($name)) {
$inputFilter->getInputFilter()->add($input, $name);
} else {
$inputFilter->add($input, $name);
}
}
if ($fieldset === $this && $fieldset instanceof InputFilterProviderInterface) {
foreach ($fieldset->getInputFilterSpecification() as $name => $spec) {
$input = $inputFactory->createInput($spec);
$inputFilter->add($input, $name);
}
}
}
foreach ($fieldset->getFieldsets() as $name => $childFieldset) {
if (!$childFieldset instanceof InputFilterProviderInterface) {
if (!$inputFilter->has($name)) {
// Add a new empty input filter if it does not exist (or the fieldset's object input filter),
// so that elements of nested fieldsets can be recursively added
if ($childFieldset->getObject() instanceof InputFilterAwareInterface) {
$inputFilter->add($childFieldset->getObject()->getInputFilter(), $name);
} else {
// Add input filter for collections via getInputFilterSpecification()
if ($childFieldset instanceof Collection && $childFieldset->getTargetElement() instanceof InputFilterProviderInterface && $childFieldset->getTargetElement()->getInputFilterSpecification()) {
$collectionContainerFilter = new CollectionInputFilter();
$spec = $childFieldset->getTargetElement()->getInputFilterSpecification();
$filter = $inputFactory->createInputFilter($spec);
$collectionContainerFilter->setInputFilter($filter);
$inputFilter->add($collectionContainerFilter, $name);
// We need to copy the inputs to the collection input filter
if ($inputFilter instanceof CollectionInputFilter) {
$inputFilter = $this->addInputsToCollectionInputFilter($inputFilter);
}
// Add child elements from target element
$childFieldset = $childFieldset->getTargetElement();
} else {
$inputFilter->add(new InputFilter(), $name);
}
}
}
$fieldsetFilter = $inputFilter->get($name);
if (!$fieldsetFilter instanceof InputFilterInterface) {
// Input attached for fieldset, not input filter; nothing more to do.
continue;
}
// Traverse the elements of the fieldset, and attach any
// defaults to the fieldset's input filter
$this->attachInputFilterDefaults($fieldsetFilter, $childFieldset);
continue;
}
if ($inputFilter->has($name)) {
// if we already have an input/filter by this name, use it
continue;
}
// Create an input filter based on the specification returned from the fieldset
$spec = $childFieldset->getInputFilterSpecification();
$filter = $inputFactory->createInputFilter($spec);
$inputFilter->add($filter, $name);
// Recursively attach sub filters
$this->attachInputFilterDefaults($filter, $childFieldset);
// We need to copy the inputs to the collection input filter to ensure that all sub filters are added
if ($inputFilter instanceof CollectionInputFilter) {
$inputFilter = $this->addInputsToCollectionInputFilter($inputFilter);
}
}
}
/**
* @param $association
* @param $inputFilter
*
* @return InputFilterInterface
*/
protected function getAssociatedEntityInputFilter($association, InputFilterInterface $inputFilter)
{
// Skip handling associations that aren't in the data
// Ensure the collection value has an input filter
if (!$inputFilter->has($association)) {
/*
* Value must not have been in the inputFilter and wasn't stripped out.
* Treat as hostile and stop execution.
*/
throw new InvalidArgumentException('Non-validated input detected: ' . $association);
}
$childInputFilter = $inputFilter->get($association);
if ($childInputFilter instanceof CollectionInputFilter) {
return $childInputFilter->getInputFilter();
} else {
return $childInputFilter;
}
}
/**
* Attach defaults provided by the elements to the input filter
*
* @param InputFilterInterface $inputFilter
* @param FieldsetInterface $fieldset Fieldset to traverse when looking for default inputs
* @return void
*/
public function attachInputFilterDefaults(InputFilterInterface $inputFilter, FieldsetInterface $fieldset)
{
$formFactory = $this->getFormFactory();
$inputFactory = $formFactory->getInputFilterFactory();
foreach ($fieldset->getElements() as $element) {
if (!$element instanceof InputProviderInterface) {
// only interested in the element if it provides input information
continue;
}
$name = $element->getName();
// Create an input based on the specification returned from the element
$spec = $element->getInputSpecification();
$input = $inputFactory->createInput($spec);
$inputFilter->add($input, $name);
}
foreach ($fieldset->getFieldsets() as $fieldset) {
$name = $fieldset->getName();
if (!$fieldset instanceof InputFilterProviderInterface) {
if (!$inputFilter->has($name)) {
// Add a new empty input filter if it does not exist, so that elements of nested fieldsets can be
// recursively added
$inputFilter->add(new InputFilter(), $name);
}
$fieldsetFilter = $inputFilter->get($name);
if (!$fieldsetFilter instanceof InputFilterInterface) {
// Input attached for fieldset, not input filter; nothing more to do.
continue;
}
// Traverse the elements of the fieldset, and attach any
// defaults to the fieldset's input filter
$this->attachInputFilterDefaults($fieldsetFilter, $fieldset);
continue;
}
if ($inputFilter->has($name)) {
// if we already have an input/filter by this name, use it
continue;
}
// Create an input filter based on the specification returned from the fieldset
$spec = $fieldset->getInputFilterSpecification();
$filter = $inputFactory->createInputFilter($spec);
$inputFilter->add($filter, $name);
// Recursively attach sub filters
$this->attachInputFilterDefaults($filter, $fieldset);
}
}
/**
* Build the InputFilter, validators and filters from form fields
*
* @param InputFilterInterface $inputFilter
*/
private function buildInputFilterFromForm(InputFilterInterface $inputFilter)
{
foreach ($this->getNodeList() as $name => $node) {
if ($inputFilter->has($name)) {
continue;
}
// Detect element type
$type = $node->getAttribute('type');
if ($node->tagName === 'textarea') {
$type = 'textarea';
} elseif ($node->tagName === 'select') {
$type = 'select';
}
// Add validation
if (array_key_exists($type, $this->formElements)) {
$elementClass = $this->formElements[$type];
} else {
// Create a default validator
$elementClass = $this->formElements['text'];
}
/** @var \Zend\InputFilter\InputProviderInterface $element */
$element = new $elementClass($node, $this->document);
$input = $this->factory->createInput($element);
$inputFilter->add($input, $name);
}
}
/**
* Attach defaults provided by the elements to the input filter
*
* @param InputFilterInterface $inputFilter
* @param FieldsetInterface $fieldset Fieldset to traverse when looking for default inputs
* @return void
*/
public function attachInputFilterDefaults(InputFilterInterface $inputFilter, FieldsetInterface $fieldset)
{
$formFactory = $this->getFormFactory();
$inputFactory = $formFactory->getInputFilterFactory();
foreach ($fieldset->getElements() as $element) {
if (!$element instanceof InputProviderInterface) {
// only interested in the element if it provides input information
continue;
}
$name = $element->getName();
if ($inputFilter->has($name)) {
// if we already have an input by this name, use it
continue;
}
// Create an input based on the specification returned from the element
$spec = $element->getInputSpecification();
$input = $inputFactory->createInput($spec);
$inputFilter->add($input, $name);
}
foreach ($fieldset->getFieldsets() as $fieldset) {
$name = $fieldset->getName();
if (!$fieldset instanceof InputFilterProviderInterface) {
if (!$inputFilter->has($name)) {
// Not an input filter provider, and no matching input for this fieldset.
// Nothing more to do for this one.
continue;
}
$fieldsetFilter = $inputFilter->get($name);
if (!$fieldsetFilter instanceof InputFilterInterface) {
// Input attached for fieldset, not input filter; nothing more to do.
continue;
}
// Traverse the elements of the fieldset, and attach any
// defaults to the fieldset's input filter
$this->attachInputFilterDefaults($fieldsetFilter, $fieldset);
continue;
}
if ($inputFilter->has($name)) {
// if we already have an input/filter by this name, use it
continue;
}
// Create an inputfilter based on the specification returned from the fieldset
$spec = $fieldset->getInputFilterSpecification();
$filter = $inputFactory->createInputFilter($spec);
$inputFilter->add($filter, $name);
}
}
