/**
* Reflect css properties
*
* @param \Zend\Form\FieldsetInterface $fieldset
* @param string $selector
* @return \Zend\Form\FieldsetInterface
*/
protected function reflectCss(FieldsetInterface $fieldset, $selector)
{
foreach ($fieldset->getFieldsets() as $subFieldset) {
if (!$subFieldset instanceof Collection) {
$this->reflectCss($subFieldset, $selector);
}
}
foreach ($fieldset->getElements() as $name => $element) {
$types = array_filter(preg_split('/\\s+/', trim($element->getAttribute('data-js-type'))));
$types[] = 'js.paragraph.reflectCss';
$element->setAttributes(array('data-js-type' => implode(' ', $types), 'data-js-reflectcss-selector' => $selector, 'data-js-reflectcss-property' => String::decamelize($name)));
}
return $fieldset;
}
/**
* Iterate through all the elements and retrieve their validators
*
* @param FieldsetInterface $formOrFieldset
* @param InputFilterInterface $inputFilter
* @return array
*/
public function extractValidatorsForForm(FieldsetInterface $formOrFieldset, InputFilterInterface $inputFilter)
{
$foundValidators = array();
foreach ($formOrFieldset->getElements() as $element) {
$validators = $this->getValidatorsForElement($inputFilter, $element);
if (count($validators) > 0) {
$foundValidators[] = array('element' => $element, 'validators' => $validators);
}
}
foreach ($formOrFieldset->getFieldsets() as $key => $fieldset) {
if ($inputFilter->has($key)) {
$foundValidators = array_merge($foundValidators, $this->extractValidatorsForForm($fieldset, $inputFilter->get($key)));
}
}
return $foundValidators;
}
/**
* 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);
}
}
}
/**
* Helper method. Retrieves all elements from fieldset the $element belongs to.
*
* @param ElementInterface $element
* @param FieldsetInterface $fieldset
* @return array|\Traversable
*/
protected function getFieldsetElements(ElementInterface $element, FieldsetInterface $fieldset)
{
$elementName = $this->normalizeElementName($element->getName());
if ($fieldset->has($elementName) && $fieldset->get($elementName) === $element) {
return array_merge($fieldset->getElements(), $fieldset->getFieldsets());
}
if ($fieldset instanceof Element\Collection && (($elements = $this->getFieldsetElements($element, $fieldset->getTargetElement())) || ($template = $fieldset->getTemplateElement()) && ($elements = $this->getFieldsetElements($element, $template)))) {
return $elements;
}
foreach ($fieldset->getFieldsets() as $fieldsetElement) {
if ($elements = $this->getFieldsetElements($element, $fieldsetElement)) {
return $elements;
}
}
return [];
}
/**
* 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);
}
}
/**
* Iterate through all the elements and retrieve their validators
*
* @param FieldsetInterface $formOrFieldset
* @param InputFilterInterface $inputFilter
* @return array
*/
private function getElementAndRules(FieldsetInterface $formOrFieldset, InputFilterInterface $inputFilter)
{
$elements = array();
foreach ($formOrFieldset->getElements() as $element) {
$validators = Filter::getValidatorsForElement($inputFilter, $element);
if (count($validators) > 0 && !empty($element)) {
$rules = array();
foreach ($validators as $validator) {
$rule = $this->getServiceLocator()->get('Rule')->getRule($validator['instance']);
if (!is_null($rule)) {
$rules[] = $rule;
}
}
$elements[] = array('element' => $element, 'rules' => $rules);
}
}
foreach ($formOrFieldset->getFieldsets() as $key => $fieldset) {
$elements = array_merge($elements, $this->getElementAndRules($fieldset, $inputFilter->get($key)));
}
return $elements;
}
/**
* 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);
}
}
