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