mirror of
https://github.com/Icinga/icingaweb2.git
synced 2025-10-31 03:14:31 +01:00
2279 lines
61 KiB
PHP
2279 lines
61 KiB
PHP
<?php
|
|
/**
|
|
* Zend Framework
|
|
*
|
|
* LICENSE
|
|
*
|
|
* This source file is subject to the new BSD license that is bundled
|
|
* with this package in the file LICENSE.txt.
|
|
* It is also available through the world-wide-web at this URL:
|
|
* http://framework.zend.com/license/new-bsd
|
|
* If you did not receive a copy of the license and are unable to
|
|
* obtain it through the world-wide-web, please send an email
|
|
* to license@zend.com so we can send you a copy immediately.
|
|
*
|
|
* @category Zend
|
|
* @package Zend_Form
|
|
* @copyright Copyright (c) 2005-2014 Zend Technologies USA Inc. (http://www.zend.com)
|
|
* @license http://framework.zend.com/license/new-bsd New BSD License
|
|
*/
|
|
|
|
/** @see Zend_Filter */
|
|
|
|
/** @see Zend_Form */
|
|
|
|
/** @see Zend_Validate_Interface */
|
|
|
|
/** @see Zend_Validate_Abstract */
|
|
|
|
/**
|
|
* Zend_Form_Element
|
|
*
|
|
* @category Zend
|
|
* @package Zend_Form
|
|
* @subpackage Element
|
|
* @copyright Copyright (c) 2005-2014 Zend Technologies USA Inc. (http://www.zend.com)
|
|
* @license http://framework.zend.com/license/new-bsd New BSD License
|
|
* @version $Id$
|
|
*/
|
|
class Zend_Form_Element implements Zend_Validate_Interface
|
|
{
|
|
/**
|
|
* Element Constants
|
|
*/
|
|
const DECORATOR = 'DECORATOR';
|
|
const FILTER = 'FILTER';
|
|
const VALIDATE = 'VALIDATE';
|
|
|
|
/**
|
|
* Default view helper to use
|
|
* @var string
|
|
*/
|
|
public $helper = 'formText';
|
|
|
|
/**
|
|
* 'Allow empty' flag
|
|
* @var bool
|
|
*/
|
|
protected $_allowEmpty = true;
|
|
|
|
/**
|
|
* Flag indicating whether or not to insert NotEmpty validator when element is required
|
|
* @var bool
|
|
*/
|
|
protected $_autoInsertNotEmptyValidator = true;
|
|
|
|
/**
|
|
* Array to which element belongs
|
|
* @var string
|
|
*/
|
|
protected $_belongsTo;
|
|
|
|
/**
|
|
* Element decorators
|
|
* @var array
|
|
*/
|
|
protected $_decorators = array();
|
|
|
|
/**
|
|
* Element description
|
|
* @var string
|
|
*/
|
|
protected $_description;
|
|
|
|
/**
|
|
* Should we disable loading the default decorators?
|
|
* @var bool
|
|
*/
|
|
protected $_disableLoadDefaultDecorators = false;
|
|
|
|
/**
|
|
* Custom error messages
|
|
* @var array
|
|
*/
|
|
protected $_errorMessages = array();
|
|
|
|
/**
|
|
* Validation errors
|
|
* @var array
|
|
*/
|
|
protected $_errors = array();
|
|
|
|
/**
|
|
* Separator to use when concatenating aggregate error messages (for
|
|
* elements having array values)
|
|
* @var string
|
|
*/
|
|
protected $_errorMessageSeparator = '; ';
|
|
|
|
/**
|
|
* Element filters
|
|
* @var array
|
|
*/
|
|
protected $_filters = array();
|
|
|
|
/**
|
|
* Ignore flag (used when retrieving values at form level)
|
|
* @var bool
|
|
*/
|
|
protected $_ignore = false;
|
|
|
|
/**
|
|
* Does the element represent an array?
|
|
* @var bool
|
|
*/
|
|
protected $_isArray = false;
|
|
|
|
/**
|
|
* Is the error marked as in an invalid state?
|
|
* @var bool
|
|
*/
|
|
protected $_isError = false;
|
|
|
|
/**
|
|
* Has the element been manually marked as invalid?
|
|
* @var bool
|
|
*/
|
|
protected $_isErrorForced = false;
|
|
|
|
/**
|
|
* Element label
|
|
* @var string
|
|
*/
|
|
protected $_label;
|
|
|
|
/**
|
|
* Plugin loaders for filter and validator chains
|
|
* @var array
|
|
*/
|
|
protected $_loaders = array();
|
|
|
|
/**
|
|
* Formatted validation error messages
|
|
* @var array
|
|
*/
|
|
protected $_messages = array();
|
|
|
|
/**
|
|
* Element name
|
|
* @var string
|
|
*/
|
|
protected $_name;
|
|
|
|
/**
|
|
* Order of element
|
|
* @var int
|
|
*/
|
|
protected $_order;
|
|
|
|
/**
|
|
* Required flag
|
|
* @var bool
|
|
*/
|
|
protected $_required = false;
|
|
|
|
/**
|
|
* @var Zend_Translate
|
|
*/
|
|
protected $_translator;
|
|
|
|
/**
|
|
* Is translation disabled?
|
|
* @var bool
|
|
*/
|
|
protected $_translatorDisabled = false;
|
|
|
|
/**
|
|
* Element type
|
|
* @var string
|
|
*/
|
|
protected $_type;
|
|
|
|
/**
|
|
* Array of initialized validators
|
|
* @var array Validators
|
|
*/
|
|
protected $_validators = array();
|
|
|
|
/**
|
|
* Array of un-initialized validators
|
|
* @var array
|
|
*/
|
|
protected $_validatorRules = array();
|
|
|
|
/**
|
|
* Element value
|
|
* @var mixed
|
|
*/
|
|
protected $_value;
|
|
|
|
/**
|
|
* @var Zend_View_Interface
|
|
*/
|
|
protected $_view;
|
|
|
|
/**
|
|
* Is a specific decorator being rendered via the magic renderDecorator()?
|
|
*
|
|
* This is to allow execution of logic inside the render() methods of child
|
|
* elements during the magic call while skipping the parent render() method.
|
|
*
|
|
* @var bool
|
|
*/
|
|
protected $_isPartialRendering = false;
|
|
|
|
/**
|
|
* Use one error message for array elements with concatenated values
|
|
*
|
|
* @var bool
|
|
*/
|
|
protected $_concatJustValuesInErrorMessage = false;
|
|
|
|
/**
|
|
* Constructor
|
|
*
|
|
* $spec may be:
|
|
* - string: name of element
|
|
* - array: options with which to configure element
|
|
* - Zend_Config: Zend_Config with options for configuring element
|
|
*
|
|
* @param string|array|Zend_Config $spec
|
|
* @param array|Zend_Config $options
|
|
* @return void
|
|
* @throws Zend_Form_Exception if no element name after initialization
|
|
*/
|
|
public function __construct($spec, $options = null)
|
|
{
|
|
if (is_string($spec)) {
|
|
$this->setName($spec);
|
|
} elseif (is_array($spec)) {
|
|
$this->setOptions($spec);
|
|
} elseif ($spec instanceof Zend_Config) {
|
|
$this->setConfig($spec);
|
|
}
|
|
|
|
if (is_string($spec) && is_array($options)) {
|
|
$this->setOptions($options);
|
|
} elseif (is_string($spec) && ($options instanceof Zend_Config)) {
|
|
$this->setConfig($options);
|
|
}
|
|
|
|
if (null === $this->getName()) {
|
|
throw new Zend_Form_Exception('Zend_Form_Element requires each element to have a name');
|
|
}
|
|
|
|
/**
|
|
* Extensions
|
|
*/
|
|
$this->init();
|
|
|
|
/**
|
|
* Register ViewHelper decorator by default
|
|
*/
|
|
$this->loadDefaultDecorators();
|
|
}
|
|
|
|
/**
|
|
* Initialize object; used by extending classes
|
|
*
|
|
* @return void
|
|
*/
|
|
public function init()
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Set flag to disable loading default decorators
|
|
*
|
|
* @param bool $flag
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setDisableLoadDefaultDecorators($flag)
|
|
{
|
|
$this->_disableLoadDefaultDecorators = (bool) $flag;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Should we load the default decorators?
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function loadDefaultDecoratorsIsDisabled()
|
|
{
|
|
return $this->_disableLoadDefaultDecorators;
|
|
}
|
|
|
|
/**
|
|
* Load default decorators
|
|
*
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function loadDefaultDecorators()
|
|
{
|
|
if ($this->loadDefaultDecoratorsIsDisabled()) {
|
|
return $this;
|
|
}
|
|
|
|
$decorators = $this->getDecorators();
|
|
if (empty($decorators)) {
|
|
$this->addDecorator('ViewHelper')
|
|
->addDecorator('Errors')
|
|
->addDecorator('Description', array('tag' => 'p', 'class' => 'description'))
|
|
->addDecorator('HtmlTag', array(
|
|
'tag' => 'dd',
|
|
'id' => array('callback' => array(get_class($this), 'resolveElementId'))
|
|
))
|
|
->addDecorator('Label', array('tag' => 'dt'));
|
|
}
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Used to resolve and return an element ID
|
|
*
|
|
* Passed to the HtmlTag decorator as a callback in order to provide an ID.
|
|
*
|
|
* @param Zend_Form_Decorator_Interface $decorator
|
|
* @return string
|
|
*/
|
|
public static function resolveElementId(Zend_Form_Decorator_Interface $decorator)
|
|
{
|
|
return $decorator->getElement()->getId() . '-element';
|
|
}
|
|
|
|
/**
|
|
* Set object state from options array
|
|
*
|
|
* @param array $options
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setOptions(array $options)
|
|
{
|
|
if (isset($options['prefixPath'])) {
|
|
$this->addPrefixPaths($options['prefixPath']);
|
|
unset($options['prefixPath']);
|
|
}
|
|
|
|
if (isset($options['disableTranslator'])) {
|
|
$this->setDisableTranslator($options['disableTranslator']);
|
|
unset($options['disableTranslator']);
|
|
}
|
|
|
|
unset($options['options']);
|
|
unset($options['config']);
|
|
|
|
foreach ($options as $key => $value) {
|
|
$method = 'set' . ucfirst($key);
|
|
|
|
if (in_array($method, array('setTranslator', 'setPluginLoader', 'setView'))) {
|
|
if (!is_object($value)) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (method_exists($this, $method)) {
|
|
// Setter exists; use it
|
|
$this->$method($value);
|
|
} else {
|
|
// Assume it's metadata
|
|
$this->setAttrib($key, $value);
|
|
}
|
|
}
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Set object state from Zend_Config object
|
|
*
|
|
* @param Zend_Config $config
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setConfig(Zend_Config $config)
|
|
{
|
|
return $this->setOptions($config->toArray());
|
|
}
|
|
|
|
|
|
// Localization:
|
|
|
|
/**
|
|
* Set translator object for localization
|
|
*
|
|
* @param Zend_Translate|null $translator
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setTranslator($translator = null)
|
|
{
|
|
if (null === $translator) {
|
|
$this->_translator = null;
|
|
} elseif ($translator instanceof Zend_Translate_Adapter) {
|
|
$this->_translator = $translator;
|
|
} elseif ($translator instanceof Zend_Translate) {
|
|
$this->_translator = $translator->getAdapter();
|
|
} else {
|
|
throw new Zend_Form_Exception('Invalid translator specified');
|
|
}
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Retrieve localization translator object
|
|
*
|
|
* @return Zend_Translate_Adapter|null
|
|
*/
|
|
public function getTranslator()
|
|
{
|
|
if ($this->translatorIsDisabled()) {
|
|
return null;
|
|
}
|
|
|
|
if (null === $this->_translator) {
|
|
return Zend_Form::getDefaultTranslator();
|
|
}
|
|
return $this->_translator;
|
|
}
|
|
|
|
/**
|
|
* Does this element have its own specific translator?
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function hasTranslator()
|
|
{
|
|
return (bool)$this->_translator;
|
|
}
|
|
|
|
/**
|
|
* Indicate whether or not translation should be disabled
|
|
*
|
|
* @param bool $flag
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setDisableTranslator($flag)
|
|
{
|
|
$this->_translatorDisabled = (bool) $flag;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Is translation disabled?
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function translatorIsDisabled()
|
|
{
|
|
return $this->_translatorDisabled;
|
|
}
|
|
|
|
// Metadata
|
|
|
|
/**
|
|
* Filter a name to only allow valid variable characters
|
|
*
|
|
* @param string $value
|
|
* @param bool $allowBrackets
|
|
* @return string
|
|
*/
|
|
public function filterName($value, $allowBrackets = false)
|
|
{
|
|
$charset = '^a-zA-Z0-9_\x7f-\xff';
|
|
if ($allowBrackets) {
|
|
$charset .= '\[\]';
|
|
}
|
|
return preg_replace('/[' . $charset . ']/', '', (string) $value);
|
|
}
|
|
|
|
/**
|
|
* Set element name
|
|
*
|
|
* @param string $name
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setName($name)
|
|
{
|
|
$name = $this->filterName($name);
|
|
if ('' === $name) {
|
|
throw new Zend_Form_Exception('Invalid name provided; must contain only valid variable characters and be non-empty');
|
|
}
|
|
|
|
$this->_name = $name;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Return element name
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getName()
|
|
{
|
|
return $this->_name;
|
|
}
|
|
|
|
/**
|
|
* Get fully qualified name
|
|
*
|
|
* Places name as subitem of array and/or appends brackets.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getFullyQualifiedName()
|
|
{
|
|
$name = $this->getName();
|
|
|
|
if (null !== ($belongsTo = $this->getBelongsTo())) {
|
|
$name = $belongsTo . '[' . $name . ']';
|
|
}
|
|
|
|
if ($this->isArray()) {
|
|
$name .= '[]';
|
|
}
|
|
|
|
return $name;
|
|
}
|
|
|
|
/**
|
|
* Get element id
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getId()
|
|
{
|
|
if (isset($this->id)) {
|
|
return $this->id;
|
|
}
|
|
|
|
$id = $this->getFullyQualifiedName();
|
|
|
|
// Bail early if no array notation detected
|
|
if (!strstr($id, '[')) {
|
|
return $id;
|
|
}
|
|
|
|
// Strip array notation
|
|
if ('[]' == substr($id, -2)) {
|
|
$id = substr($id, 0, strlen($id) - 2);
|
|
}
|
|
$id = str_replace('][', '-', $id);
|
|
$id = str_replace(array(']', '['), '-', $id);
|
|
$id = trim($id, '-');
|
|
|
|
return $id;
|
|
}
|
|
|
|
/**
|
|
* Set element value
|
|
*
|
|
* @param mixed $value
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setValue($value)
|
|
{
|
|
$this->_value = $value;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Filter a value
|
|
*
|
|
* @param string $value
|
|
* @param string $key
|
|
* @return void
|
|
*/
|
|
protected function _filterValue(&$value, &$key)
|
|
{
|
|
foreach ($this->getFilters() as $filter) {
|
|
$value = $filter->filter($value);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retrieve filtered element value
|
|
*
|
|
* @return mixed
|
|
*/
|
|
public function getValue()
|
|
{
|
|
$valueFiltered = $this->_value;
|
|
|
|
if ($this->isArray() && is_array($valueFiltered)) {
|
|
array_walk_recursive($valueFiltered, array($this, '_filterValue'));
|
|
} else {
|
|
$this->_filterValue($valueFiltered, $valueFiltered);
|
|
}
|
|
|
|
return $valueFiltered;
|
|
}
|
|
|
|
/**
|
|
* Retrieve unfiltered element value
|
|
*
|
|
* @return mixed
|
|
*/
|
|
public function getUnfilteredValue()
|
|
{
|
|
return $this->_value;
|
|
}
|
|
|
|
/**
|
|
* Set element label
|
|
*
|
|
* @param string $label
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setLabel($label)
|
|
{
|
|
$this->_label = (string) $label;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Retrieve element label
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getLabel()
|
|
{
|
|
$translator = $this->getTranslator();
|
|
if (null !== $translator) {
|
|
return $translator->translate($this->_label);
|
|
}
|
|
|
|
return $this->_label;
|
|
}
|
|
|
|
/**
|
|
* Set element order
|
|
*
|
|
* @param int $order
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setOrder($order)
|
|
{
|
|
$this->_order = (int) $order;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Retrieve element order
|
|
*
|
|
* @return int
|
|
*/
|
|
public function getOrder()
|
|
{
|
|
return $this->_order;
|
|
}
|
|
|
|
/**
|
|
* Set required flag
|
|
*
|
|
* @param bool $flag Default value is true
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setRequired($flag = true)
|
|
{
|
|
$this->_required = (bool) $flag;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Is the element required?
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function isRequired()
|
|
{
|
|
return $this->_required;
|
|
}
|
|
|
|
/**
|
|
* Set flag indicating whether a NotEmpty validator should be inserted when element is required
|
|
*
|
|
* @param bool $flag
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setAutoInsertNotEmptyValidator($flag)
|
|
{
|
|
$this->_autoInsertNotEmptyValidator = (bool) $flag;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get flag indicating whether a NotEmpty validator should be inserted when element is required
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function autoInsertNotEmptyValidator()
|
|
{
|
|
return $this->_autoInsertNotEmptyValidator;
|
|
}
|
|
|
|
/**
|
|
* Set element description
|
|
*
|
|
* @param string $description
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setDescription($description)
|
|
{
|
|
$this->_description = (string) $description;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Retrieve element description
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getDescription()
|
|
{
|
|
return $this->_description;
|
|
}
|
|
|
|
/**
|
|
* Set 'allow empty' flag
|
|
*
|
|
* When the allow empty flag is enabled and the required flag is false, the
|
|
* element will validate with empty values.
|
|
*
|
|
* @param bool $flag
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setAllowEmpty($flag)
|
|
{
|
|
$this->_allowEmpty = (bool) $flag;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get 'allow empty' flag
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function getAllowEmpty()
|
|
{
|
|
return $this->_allowEmpty;
|
|
}
|
|
|
|
/**
|
|
* Set ignore flag (used when retrieving values at form level)
|
|
*
|
|
* @param bool $flag
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setIgnore($flag)
|
|
{
|
|
$this->_ignore = (bool) $flag;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get ignore flag (used when retrieving values at form level)
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function getIgnore()
|
|
{
|
|
return $this->_ignore;
|
|
}
|
|
|
|
/**
|
|
* Set flag indicating if element represents an array
|
|
*
|
|
* @param bool $flag
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setIsArray($flag)
|
|
{
|
|
$this->_isArray = (bool) $flag;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Is the element representing an array?
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function isArray()
|
|
{
|
|
return $this->_isArray;
|
|
}
|
|
|
|
/**
|
|
* Set array to which element belongs
|
|
*
|
|
* @param string $array
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setBelongsTo($array)
|
|
{
|
|
$array = $this->filterName($array, true);
|
|
if (!empty($array)) {
|
|
$this->_belongsTo = $array;
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Return array name to which element belongs
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getBelongsTo()
|
|
{
|
|
return $this->_belongsTo;
|
|
}
|
|
|
|
/**
|
|
* Return element type
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getType()
|
|
{
|
|
if (null === $this->_type) {
|
|
$this->_type = get_class($this);
|
|
}
|
|
|
|
return $this->_type;
|
|
}
|
|
|
|
/**
|
|
* Set element attribute
|
|
*
|
|
* @param string $name
|
|
* @param mixed $value
|
|
* @return Zend_Form_Element
|
|
* @throws Zend_Form_Exception for invalid $name values
|
|
*/
|
|
public function setAttrib($name, $value)
|
|
{
|
|
$name = (string) $name;
|
|
if ('_' == $name[0]) {
|
|
throw new Zend_Form_Exception(sprintf('Invalid attribute "%s"; must not contain a leading underscore', $name));
|
|
}
|
|
|
|
if (null === $value) {
|
|
unset($this->$name);
|
|
} else {
|
|
$this->$name = $value;
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Set multiple attributes at once
|
|
*
|
|
* @param array $attribs
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setAttribs(array $attribs)
|
|
{
|
|
foreach ($attribs as $key => $value) {
|
|
$this->setAttrib($key, $value);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Retrieve element attribute
|
|
*
|
|
* @param string $name
|
|
* @return string
|
|
*/
|
|
public function getAttrib($name)
|
|
{
|
|
$name = (string) $name;
|
|
if (isset($this->$name)) {
|
|
return $this->$name;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Return all attributes
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getAttribs()
|
|
{
|
|
$attribs = get_object_vars($this);
|
|
unset($attribs['helper']);
|
|
foreach ($attribs as $key => $value) {
|
|
if ('_' == substr($key, 0, 1)) {
|
|
unset($attribs[$key]);
|
|
}
|
|
}
|
|
|
|
return $attribs;
|
|
}
|
|
|
|
/**
|
|
* Use one error message for array elements with concatenated values
|
|
*
|
|
* @param boolean $concatJustValuesInErrorMessage
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setConcatJustValuesInErrorMessage($concatJustValuesInErrorMessage)
|
|
{
|
|
$this->_concatJustValuesInErrorMessage = $concatJustValuesInErrorMessage;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Use one error message for array elements with concatenated values
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function getConcatJustValuesInErrorMessage()
|
|
{
|
|
return $this->_concatJustValuesInErrorMessage;
|
|
}
|
|
|
|
/**
|
|
* Overloading: retrieve object property
|
|
*
|
|
* Prevents access to properties beginning with '_'.
|
|
*
|
|
* @param string $key
|
|
* @return mixed
|
|
*/
|
|
public function __get($key)
|
|
{
|
|
if ('_' == $key[0]) {
|
|
throw new Zend_Form_Exception(sprintf('Cannot retrieve value for protected/private property "%s"', $key));
|
|
}
|
|
|
|
if (!isset($this->$key)) {
|
|
return null;
|
|
}
|
|
|
|
return $this->$key;
|
|
}
|
|
|
|
/**
|
|
* Overloading: set object property
|
|
*
|
|
* @param string $key
|
|
* @param mixed $value
|
|
* @return voide
|
|
*/
|
|
public function __set($key, $value)
|
|
{
|
|
$this->setAttrib($key, $value);
|
|
}
|
|
|
|
/**
|
|
* Overloading: allow rendering specific decorators
|
|
*
|
|
* Call renderDecoratorName() to render a specific decorator.
|
|
*
|
|
* @param string $method
|
|
* @param array $args
|
|
* @return string
|
|
* @throws Zend_Form_Exception for invalid decorator or invalid method call
|
|
*/
|
|
public function __call($method, $args)
|
|
{
|
|
if ('render' == substr($method, 0, 6)) {
|
|
$this->_isPartialRendering = true;
|
|
$this->render();
|
|
$this->_isPartialRendering = false;
|
|
$decoratorName = substr($method, 6);
|
|
if (false !== ($decorator = $this->getDecorator($decoratorName))) {
|
|
$decorator->setElement($this);
|
|
$seed = '';
|
|
if (0 < count($args)) {
|
|
$seed = array_shift($args);
|
|
}
|
|
return $decorator->render($seed);
|
|
}
|
|
|
|
throw new Zend_Form_Element_Exception(sprintf('Decorator by name %s does not exist', $decoratorName));
|
|
}
|
|
|
|
throw new Zend_Form_Element_Exception(sprintf('Method %s does not exist', $method));
|
|
}
|
|
|
|
// Loaders
|
|
|
|
/**
|
|
* Set plugin loader to use for validator or filter chain
|
|
*
|
|
* @param Zend_Loader_PluginLoader_Interface $loader
|
|
* @param string $type 'decorator', 'filter', or 'validate'
|
|
* @return Zend_Form_Element
|
|
* @throws Zend_Form_Exception on invalid type
|
|
*/
|
|
public function setPluginLoader(Zend_Loader_PluginLoader_Interface $loader, $type)
|
|
{
|
|
$type = strtoupper($type);
|
|
switch ($type) {
|
|
case self::DECORATOR:
|
|
case self::FILTER:
|
|
case self::VALIDATE:
|
|
$this->_loaders[$type] = $loader;
|
|
return $this;
|
|
default:
|
|
throw new Zend_Form_Exception(sprintf('Invalid type "%s" provided to setPluginLoader()', $type));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retrieve plugin loader for validator or filter chain
|
|
*
|
|
* Instantiates with default rules if none available for that type. Use
|
|
* 'decorator', 'filter', or 'validate' for $type.
|
|
*
|
|
* @param string $type
|
|
* @return Zend_Loader_PluginLoader
|
|
* @throws Zend_Loader_Exception on invalid type.
|
|
*/
|
|
public function getPluginLoader($type)
|
|
{
|
|
$type = strtoupper($type);
|
|
switch ($type) {
|
|
case self::FILTER:
|
|
case self::VALIDATE:
|
|
$prefixSegment = ucfirst(strtolower($type));
|
|
$pathSegment = $prefixSegment;
|
|
case self::DECORATOR:
|
|
if (!isset($prefixSegment)) {
|
|
$prefixSegment = 'Form_Decorator';
|
|
$pathSegment = 'Form/Decorator';
|
|
}
|
|
if (!isset($this->_loaders[$type])) {
|
|
$this->_loaders[$type] = new Zend_Loader_PluginLoader(
|
|
array('Zend_' . $prefixSegment . '_' => 'Zend/' . $pathSegment . '/')
|
|
);
|
|
}
|
|
return $this->_loaders[$type];
|
|
default:
|
|
throw new Zend_Form_Exception(sprintf('Invalid type "%s" provided to getPluginLoader()', $type));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add prefix path for plugin loader
|
|
*
|
|
* If no $type specified, assumes it is a base path for both filters and
|
|
* validators, and sets each according to the following rules:
|
|
* - decorators: $prefix = $prefix . '_Decorator'
|
|
* - filters: $prefix = $prefix . '_Filter'
|
|
* - validators: $prefix = $prefix . '_Validate'
|
|
*
|
|
* Otherwise, the path prefix is set on the appropriate plugin loader.
|
|
*
|
|
* @param string $prefix
|
|
* @param string $path
|
|
* @param string $type
|
|
* @return Zend_Form_Element
|
|
* @throws Zend_Form_Exception for invalid type
|
|
*/
|
|
public function addPrefixPath($prefix, $path, $type = null)
|
|
{
|
|
$type = strtoupper($type);
|
|
switch ($type) {
|
|
case self::DECORATOR:
|
|
case self::FILTER:
|
|
case self::VALIDATE:
|
|
$loader = $this->getPluginLoader($type);
|
|
$loader->addPrefixPath($prefix, $path);
|
|
return $this;
|
|
case null:
|
|
$nsSeparator = (false !== strpos($prefix, '\\'))?'\\':'_';
|
|
$prefix = rtrim($prefix, $nsSeparator) . $nsSeparator;
|
|
$path = rtrim($path, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR;
|
|
foreach (array(self::DECORATOR, self::FILTER, self::VALIDATE) as $type) {
|
|
$cType = ucfirst(strtolower($type));
|
|
$loader = $this->getPluginLoader($type);
|
|
$loader->addPrefixPath($prefix . $cType, $path . $cType . DIRECTORY_SEPARATOR);
|
|
}
|
|
return $this;
|
|
default:
|
|
throw new Zend_Form_Exception(sprintf('Invalid type "%s" provided to getPluginLoader()', $type));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add many prefix paths at once
|
|
*
|
|
* @param array $spec
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function addPrefixPaths(array $spec)
|
|
{
|
|
if (isset($spec['prefix']) && isset($spec['path'])) {
|
|
return $this->addPrefixPath($spec['prefix'], $spec['path']);
|
|
}
|
|
foreach ($spec as $type => $paths) {
|
|
if (is_numeric($type) && is_array($paths)) {
|
|
$type = null;
|
|
if (isset($paths['prefix']) && isset($paths['path'])) {
|
|
if (isset($paths['type'])) {
|
|
$type = $paths['type'];
|
|
}
|
|
$this->addPrefixPath($paths['prefix'], $paths['path'], $type);
|
|
}
|
|
} elseif (!is_numeric($type)) {
|
|
if (!isset($paths['prefix']) || !isset($paths['path'])) {
|
|
foreach ($paths as $prefix => $spec) {
|
|
if (is_array($spec)) {
|
|
foreach ($spec as $path) {
|
|
if (!is_string($path)) {
|
|
continue;
|
|
}
|
|
$this->addPrefixPath($prefix, $path, $type);
|
|
}
|
|
} elseif (is_string($spec)) {
|
|
$this->addPrefixPath($prefix, $spec, $type);
|
|
}
|
|
}
|
|
} else {
|
|
$this->addPrefixPath($paths['prefix'], $paths['path'], $type);
|
|
}
|
|
}
|
|
}
|
|
return $this;
|
|
}
|
|
|
|
// Validation
|
|
|
|
/**
|
|
* Add validator to validation chain
|
|
*
|
|
* Note: will overwrite existing validators if they are of the same class.
|
|
*
|
|
* @param string|Zend_Validate_Interface $validator
|
|
* @param bool $breakChainOnFailure
|
|
* @param array $options
|
|
* @return Zend_Form_Element
|
|
* @throws Zend_Form_Exception if invalid validator type
|
|
*/
|
|
public function addValidator($validator, $breakChainOnFailure = false, $options = array())
|
|
{
|
|
if ($validator instanceof Zend_Validate_Interface) {
|
|
$name = get_class($validator);
|
|
|
|
if (!isset($validator->zfBreakChainOnFailure)) {
|
|
$validator->zfBreakChainOnFailure = $breakChainOnFailure;
|
|
}
|
|
} elseif (is_string($validator)) {
|
|
$name = $validator;
|
|
$validator = array(
|
|
'validator' => $validator,
|
|
'breakChainOnFailure' => $breakChainOnFailure,
|
|
'options' => $options,
|
|
);
|
|
} else {
|
|
throw new Zend_Form_Exception('Invalid validator provided to addValidator; must be string or Zend_Validate_Interface');
|
|
}
|
|
|
|
|
|
$this->_validators[$name] = $validator;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Add multiple validators
|
|
*
|
|
* @param array $validators
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function addValidators(array $validators)
|
|
{
|
|
foreach ($validators as $validatorInfo) {
|
|
if (is_string($validatorInfo)) {
|
|
$this->addValidator($validatorInfo);
|
|
} elseif ($validatorInfo instanceof Zend_Validate_Interface) {
|
|
$this->addValidator($validatorInfo);
|
|
} elseif (is_array($validatorInfo)) {
|
|
$argc = count($validatorInfo);
|
|
$breakChainOnFailure = false;
|
|
$options = array();
|
|
if (isset($validatorInfo['validator'])) {
|
|
$validator = $validatorInfo['validator'];
|
|
if (isset($validatorInfo['breakChainOnFailure'])) {
|
|
$breakChainOnFailure = $validatorInfo['breakChainOnFailure'];
|
|
}
|
|
if (isset($validatorInfo['options'])) {
|
|
$options = $validatorInfo['options'];
|
|
}
|
|
$this->addValidator($validator, $breakChainOnFailure, $options);
|
|
} else {
|
|
switch (true) {
|
|
case (0 == $argc):
|
|
break;
|
|
case (1 <= $argc):
|
|
$validator = array_shift($validatorInfo);
|
|
case (2 <= $argc):
|
|
$breakChainOnFailure = array_shift($validatorInfo);
|
|
case (3 <= $argc):
|
|
$options = array_shift($validatorInfo);
|
|
default:
|
|
$this->addValidator($validator, $breakChainOnFailure, $options);
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
throw new Zend_Form_Exception('Invalid validator passed to addValidators()');
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Set multiple validators, overwriting previous validators
|
|
*
|
|
* @param array $validators
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setValidators(array $validators)
|
|
{
|
|
$this->clearValidators();
|
|
return $this->addValidators($validators);
|
|
}
|
|
|
|
/**
|
|
* Retrieve a single validator by name
|
|
*
|
|
* @param string $name
|
|
* @return Zend_Validate_Interface|false False if not found, validator otherwise
|
|
*/
|
|
public function getValidator($name)
|
|
{
|
|
if (!isset($this->_validators[$name])) {
|
|
$len = strlen($name);
|
|
foreach ($this->_validators as $localName => $validator) {
|
|
if ($len > strlen($localName)) {
|
|
continue;
|
|
}
|
|
if (0 === substr_compare($localName, $name, -$len, $len, true)) {
|
|
if (is_array($validator)) {
|
|
return $this->_loadValidator($validator);
|
|
}
|
|
return $validator;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
if (is_array($this->_validators[$name])) {
|
|
return $this->_loadValidator($this->_validators[$name]);
|
|
}
|
|
|
|
return $this->_validators[$name];
|
|
}
|
|
|
|
/**
|
|
* Retrieve all validators
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getValidators()
|
|
{
|
|
$validators = array();
|
|
foreach ($this->_validators as $key => $value) {
|
|
if ($value instanceof Zend_Validate_Interface) {
|
|
$validators[$key] = $value;
|
|
continue;
|
|
}
|
|
$validator = $this->_loadValidator($value);
|
|
$validators[get_class($validator)] = $validator;
|
|
}
|
|
return $validators;
|
|
}
|
|
|
|
/**
|
|
* Remove a single validator by name
|
|
*
|
|
* @param string $name
|
|
* @return bool
|
|
*/
|
|
public function removeValidator($name)
|
|
{
|
|
if (isset($this->_validators[$name])) {
|
|
unset($this->_validators[$name]);
|
|
} else {
|
|
$len = strlen($name);
|
|
foreach (array_keys($this->_validators) as $validator) {
|
|
if ($len > strlen($validator)) {
|
|
continue;
|
|
}
|
|
if (0 === substr_compare($validator, $name, -$len, $len, true)) {
|
|
unset($this->_validators[$validator]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Clear all validators
|
|
*
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function clearValidators()
|
|
{
|
|
$this->_validators = array();
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Validate element value
|
|
*
|
|
* If a translation adapter is registered, any error messages will be
|
|
* translated according to the current locale, using the given error code;
|
|
* if no matching translation is found, the original message will be
|
|
* utilized.
|
|
*
|
|
* Note: The *filtered* value is validated.
|
|
*
|
|
* @param mixed $value
|
|
* @param mixed $context
|
|
* @return boolean
|
|
*/
|
|
public function isValid($value, $context = null)
|
|
{
|
|
$this->setValue($value);
|
|
$value = $this->getValue();
|
|
|
|
if ((('' === $value) || (null === $value))
|
|
&& !$this->isRequired()
|
|
&& $this->getAllowEmpty()
|
|
) {
|
|
return true;
|
|
}
|
|
|
|
if ($this->isRequired()
|
|
&& $this->autoInsertNotEmptyValidator()
|
|
&& !$this->getValidator('NotEmpty'))
|
|
{
|
|
$validators = $this->getValidators();
|
|
$notEmpty = array('validator' => 'NotEmpty', 'breakChainOnFailure' => true);
|
|
array_unshift($validators, $notEmpty);
|
|
$this->setValidators($validators);
|
|
}
|
|
|
|
// Find the correct translator. Zend_Validate_Abstract::getDefaultTranslator()
|
|
// will get either the static translator attached to Zend_Validate_Abstract
|
|
// or the 'Zend_Translate' from Zend_Registry.
|
|
if (Zend_Validate_Abstract::hasDefaultTranslator() &&
|
|
!Zend_Form::hasDefaultTranslator())
|
|
{
|
|
$translator = Zend_Validate_Abstract::getDefaultTranslator();
|
|
if ($this->hasTranslator()) {
|
|
// only pick up this element's translator if it was attached directly.
|
|
$translator = $this->getTranslator();
|
|
}
|
|
} else {
|
|
$translator = $this->getTranslator();
|
|
}
|
|
|
|
$this->_messages = array();
|
|
$this->_errors = array();
|
|
$result = true;
|
|
$isArray = $this->isArray();
|
|
foreach ($this->getValidators() as $key => $validator) {
|
|
if (method_exists($validator, 'setTranslator')) {
|
|
if (method_exists($validator, 'hasTranslator')) {
|
|
if (!$validator->hasTranslator()) {
|
|
$validator->setTranslator($translator);
|
|
}
|
|
} else {
|
|
$validator->setTranslator($translator);
|
|
}
|
|
}
|
|
|
|
if (method_exists($validator, 'setDisableTranslator')) {
|
|
$validator->setDisableTranslator($this->translatorIsDisabled());
|
|
}
|
|
|
|
if ($isArray && is_array($value)) {
|
|
$messages = array();
|
|
$errors = array();
|
|
if (empty($value)) {
|
|
if ($this->isRequired()
|
|
|| (!$this->isRequired() && !$this->getAllowEmpty())
|
|
) {
|
|
$value = '';
|
|
}
|
|
}
|
|
foreach ((array)$value as $val) {
|
|
if (!$validator->isValid($val, $context)) {
|
|
$result = false;
|
|
if ($this->_hasErrorMessages()) {
|
|
$messages = $this->_getErrorMessages();
|
|
$errors = $messages;
|
|
} else {
|
|
$messages = array_merge($messages, $validator->getMessages());
|
|
$errors = array_merge($errors, $validator->getErrors());
|
|
}
|
|
}
|
|
}
|
|
if ($result) {
|
|
continue;
|
|
}
|
|
} elseif ($validator->isValid($value, $context)) {
|
|
continue;
|
|
} else {
|
|
$result = false;
|
|
if ($this->_hasErrorMessages()) {
|
|
$messages = $this->_getErrorMessages();
|
|
$errors = $messages;
|
|
} else {
|
|
$messages = $validator->getMessages();
|
|
$errors = array_keys($messages);
|
|
}
|
|
}
|
|
|
|
$result = false;
|
|
$this->_messages = array_merge($this->_messages, $messages);
|
|
$this->_errors = array_merge($this->_errors, $errors);
|
|
|
|
if ($validator->zfBreakChainOnFailure) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If element manually flagged as invalid, return false
|
|
if ($this->_isErrorForced) {
|
|
return false;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Add a custom error message to return in the event of failed validation
|
|
*
|
|
* @param string $message
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function addErrorMessage($message)
|
|
{
|
|
$this->_errorMessages[] = (string) $message;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Add multiple custom error messages to return in the event of failed validation
|
|
*
|
|
* @param array $messages
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function addErrorMessages(array $messages)
|
|
{
|
|
foreach ($messages as $message) {
|
|
$this->addErrorMessage($message);
|
|
}
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Same as addErrorMessages(), but clears custom error message stack first
|
|
*
|
|
* @param array $messages
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setErrorMessages(array $messages)
|
|
{
|
|
$this->clearErrorMessages();
|
|
return $this->addErrorMessages($messages);
|
|
}
|
|
|
|
/**
|
|
* Retrieve custom error messages
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getErrorMessages()
|
|
{
|
|
return $this->_errorMessages;
|
|
}
|
|
|
|
/**
|
|
* Clear custom error messages stack
|
|
*
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function clearErrorMessages()
|
|
{
|
|
$this->_errorMessages = array();
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get errorMessageSeparator
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getErrorMessageSeparator()
|
|
{
|
|
return $this->_errorMessageSeparator;
|
|
}
|
|
|
|
/**
|
|
* Set errorMessageSeparator
|
|
*
|
|
* @param string $separator
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setErrorMessageSeparator($separator)
|
|
{
|
|
$this->_errorMessageSeparator = $separator;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Mark the element as being in a failed validation state
|
|
*
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function markAsError()
|
|
{
|
|
$messages = $this->getMessages();
|
|
$customMessages = $this->_getErrorMessages();
|
|
$messages = $messages + $customMessages;
|
|
if (empty($messages)) {
|
|
$this->_isError = true;
|
|
} else {
|
|
$this->_messages = $messages;
|
|
}
|
|
$this->_isErrorForced = true;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Add an error message and mark element as failed validation
|
|
*
|
|
* @param string $message
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function addError($message)
|
|
{
|
|
$this->addErrorMessage($message);
|
|
$this->markAsError();
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Add multiple error messages and flag element as failed validation
|
|
*
|
|
* @param array $messages
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function addErrors(array $messages)
|
|
{
|
|
foreach ($messages as $message) {
|
|
$this->addError($message);
|
|
}
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Overwrite any previously set error messages and flag as failed validation
|
|
*
|
|
* @param array $messages
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setErrors(array $messages)
|
|
{
|
|
$this->clearErrorMessages();
|
|
return $this->addErrors($messages);
|
|
}
|
|
|
|
/**
|
|
* Are there errors registered?
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function hasErrors()
|
|
{
|
|
return (!empty($this->_messages) || $this->_isError);
|
|
}
|
|
|
|
/**
|
|
* Retrieve validator chain errors
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getErrors()
|
|
{
|
|
return $this->_errors;
|
|
}
|
|
|
|
/**
|
|
* Retrieve error messages
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getMessages()
|
|
{
|
|
return $this->_messages;
|
|
}
|
|
|
|
|
|
// Filtering
|
|
|
|
/**
|
|
* Add a filter to the element
|
|
*
|
|
* @param string|Zend_Filter_Interface $filter
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function addFilter($filter, $options = array())
|
|
{
|
|
if ($filter instanceof Zend_Filter_Interface) {
|
|
$name = get_class($filter);
|
|
} elseif (is_string($filter)) {
|
|
$name = $filter;
|
|
$filter = array(
|
|
'filter' => $filter,
|
|
'options' => $options,
|
|
);
|
|
$this->_filters[$name] = $filter;
|
|
} else {
|
|
throw new Zend_Form_Exception('Invalid filter provided to addFilter; must be string or Zend_Filter_Interface');
|
|
}
|
|
|
|
$this->_filters[$name] = $filter;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Add filters to element
|
|
*
|
|
* @param array $filters
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function addFilters(array $filters)
|
|
{
|
|
foreach ($filters as $filterInfo) {
|
|
if (is_string($filterInfo)) {
|
|
$this->addFilter($filterInfo);
|
|
} elseif ($filterInfo instanceof Zend_Filter_Interface) {
|
|
$this->addFilter($filterInfo);
|
|
} elseif (is_array($filterInfo)) {
|
|
$argc = count($filterInfo);
|
|
$options = array();
|
|
if (isset($filterInfo['filter'])) {
|
|
$filter = $filterInfo['filter'];
|
|
if (isset($filterInfo['options'])) {
|
|
$options = $filterInfo['options'];
|
|
}
|
|
$this->addFilter($filter, $options);
|
|
} else {
|
|
switch (true) {
|
|
case (0 == $argc):
|
|
break;
|
|
case (1 <= $argc):
|
|
$filter = array_shift($filterInfo);
|
|
case (2 <= $argc):
|
|
$options = array_shift($filterInfo);
|
|
default:
|
|
$this->addFilter($filter, $options);
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
throw new Zend_Form_Exception('Invalid filter passed to addFilters()');
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Add filters to element, overwriting any already existing
|
|
*
|
|
* @param array $filters
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setFilters(array $filters)
|
|
{
|
|
$this->clearFilters();
|
|
return $this->addFilters($filters);
|
|
}
|
|
|
|
/**
|
|
* Retrieve a single filter by name
|
|
*
|
|
* @param string $name
|
|
* @return Zend_Filter_Interface
|
|
*/
|
|
public function getFilter($name)
|
|
{
|
|
if (!isset($this->_filters[$name])) {
|
|
$len = strlen($name);
|
|
foreach ($this->_filters as $localName => $filter) {
|
|
if ($len > strlen($localName)) {
|
|
continue;
|
|
}
|
|
|
|
if (0 === substr_compare($localName, $name, -$len, $len, true)) {
|
|
if (is_array($filter)) {
|
|
return $this->_loadFilter($filter);
|
|
}
|
|
return $filter;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
if (is_array($this->_filters[$name])) {
|
|
return $this->_loadFilter($this->_filters[$name]);
|
|
}
|
|
|
|
return $this->_filters[$name];
|
|
}
|
|
|
|
/**
|
|
* Get all filters
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getFilters()
|
|
{
|
|
$filters = array();
|
|
foreach ($this->_filters as $key => $value) {
|
|
if ($value instanceof Zend_Filter_Interface) {
|
|
$filters[$key] = $value;
|
|
continue;
|
|
}
|
|
$filter = $this->_loadFilter($value);
|
|
$filters[get_class($filter)] = $filter;
|
|
}
|
|
return $filters;
|
|
}
|
|
|
|
/**
|
|
* Remove a filter by name
|
|
*
|
|
* @param string $name
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function removeFilter($name)
|
|
{
|
|
if (isset($this->_filters[$name])) {
|
|
unset($this->_filters[$name]);
|
|
} else {
|
|
$len = strlen($name);
|
|
foreach (array_keys($this->_filters) as $filter) {
|
|
if ($len > strlen($filter)) {
|
|
continue;
|
|
}
|
|
if (0 === substr_compare($filter, $name, -$len, $len, true)) {
|
|
unset($this->_filters[$filter]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Clear all filters
|
|
*
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function clearFilters()
|
|
{
|
|
$this->_filters = array();
|
|
return $this;
|
|
}
|
|
|
|
// Rendering
|
|
|
|
/**
|
|
* Set view object
|
|
*
|
|
* @param Zend_View_Interface $view
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setView(Zend_View_Interface $view = null)
|
|
{
|
|
$this->_view = $view;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Retrieve view object
|
|
*
|
|
* Retrieves from ViewRenderer if none previously set.
|
|
*
|
|
* @return null|Zend_View_Interface
|
|
*/
|
|
public function getView()
|
|
{
|
|
if (null === $this->_view) {
|
|
$viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper('viewRenderer');
|
|
$this->setView($viewRenderer->view);
|
|
}
|
|
return $this->_view;
|
|
}
|
|
|
|
/**
|
|
* Instantiate a decorator based on class name or class name fragment
|
|
*
|
|
* @param string $name
|
|
* @param null|array $options
|
|
* @return Zend_Form_Decorator_Interface
|
|
*/
|
|
protected function _getDecorator($name, $options)
|
|
{
|
|
$class = $this->getPluginLoader(self::DECORATOR)->load($name);
|
|
if (null === $options) {
|
|
$decorator = new $class;
|
|
} else {
|
|
$decorator = new $class($options);
|
|
}
|
|
|
|
return $decorator;
|
|
}
|
|
|
|
/**
|
|
* Add a decorator for rendering the element
|
|
*
|
|
* @param string|Zend_Form_Decorator_Interface $decorator
|
|
* @param array|Zend_Config $options Options with which to initialize decorator
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function addDecorator($decorator, $options = null)
|
|
{
|
|
if ($decorator instanceof Zend_Form_Decorator_Interface) {
|
|
$name = get_class($decorator);
|
|
} elseif (is_string($decorator)) {
|
|
$name = $decorator;
|
|
$decorator = array(
|
|
'decorator' => $name,
|
|
'options' => $options,
|
|
);
|
|
} elseif (is_array($decorator)) {
|
|
foreach ($decorator as $name => $spec) {
|
|
break;
|
|
}
|
|
if (is_numeric($name)) {
|
|
throw new Zend_Form_Exception('Invalid alias provided to addDecorator; must be alphanumeric string');
|
|
}
|
|
if (is_string($spec)) {
|
|
$decorator = array(
|
|
'decorator' => $spec,
|
|
'options' => $options,
|
|
);
|
|
} elseif ($spec instanceof Zend_Form_Decorator_Interface) {
|
|
$decorator = $spec;
|
|
}
|
|
} else {
|
|
throw new Zend_Form_Exception('Invalid decorator provided to addDecorator; must be string or Zend_Form_Decorator_Interface');
|
|
}
|
|
|
|
$this->_decorators[$name] = $decorator;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Add many decorators at once
|
|
*
|
|
* @param array $decorators
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function addDecorators(array $decorators)
|
|
{
|
|
foreach ($decorators as $decoratorName => $decoratorInfo) {
|
|
if (is_string($decoratorInfo) ||
|
|
$decoratorInfo instanceof Zend_Form_Decorator_Interface) {
|
|
if (!is_numeric($decoratorName)) {
|
|
$this->addDecorator(array($decoratorName => $decoratorInfo));
|
|
} else {
|
|
$this->addDecorator($decoratorInfo);
|
|
}
|
|
} elseif (is_array($decoratorInfo)) {
|
|
$argc = count($decoratorInfo);
|
|
$options = array();
|
|
if (isset($decoratorInfo['decorator'])) {
|
|
$decorator = $decoratorInfo['decorator'];
|
|
if (isset($decoratorInfo['options'])) {
|
|
$options = $decoratorInfo['options'];
|
|
}
|
|
$this->addDecorator($decorator, $options);
|
|
} else {
|
|
switch (true) {
|
|
case (0 == $argc):
|
|
break;
|
|
case (1 <= $argc):
|
|
$decorator = array_shift($decoratorInfo);
|
|
case (2 <= $argc):
|
|
$options = array_shift($decoratorInfo);
|
|
default:
|
|
$this->addDecorator($decorator, $options);
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
throw new Zend_Form_Exception('Invalid decorator passed to addDecorators()');
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Overwrite all decorators
|
|
*
|
|
* @param array $decorators
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function setDecorators(array $decorators)
|
|
{
|
|
$this->clearDecorators();
|
|
return $this->addDecorators($decorators);
|
|
}
|
|
|
|
/**
|
|
* Retrieve a registered decorator
|
|
*
|
|
* @param string $name
|
|
* @return false|Zend_Form_Decorator_Abstract
|
|
*/
|
|
public function getDecorator($name)
|
|
{
|
|
if (!isset($this->_decorators[$name])) {
|
|
$len = strlen($name);
|
|
foreach ($this->_decorators as $localName => $decorator) {
|
|
if ($len > strlen($localName)) {
|
|
continue;
|
|
}
|
|
|
|
if (0 === substr_compare($localName, $name, -$len, $len, true)) {
|
|
if (is_array($decorator)) {
|
|
return $this->_loadDecorator($decorator, $localName);
|
|
}
|
|
return $decorator;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
if (is_array($this->_decorators[$name])) {
|
|
return $this->_loadDecorator($this->_decorators[$name], $name);
|
|
}
|
|
|
|
return $this->_decorators[$name];
|
|
}
|
|
|
|
/**
|
|
* Retrieve all decorators
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getDecorators()
|
|
{
|
|
foreach ($this->_decorators as $key => $value) {
|
|
if (is_array($value)) {
|
|
$this->_loadDecorator($value, $key);
|
|
}
|
|
}
|
|
return $this->_decorators;
|
|
}
|
|
|
|
/**
|
|
* Remove a single decorator
|
|
*
|
|
* @param string $name
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function removeDecorator($name)
|
|
{
|
|
if (isset($this->_decorators[$name])) {
|
|
unset($this->_decorators[$name]);
|
|
} else {
|
|
$len = strlen($name);
|
|
foreach (array_keys($this->_decorators) as $decorator) {
|
|
if ($len > strlen($decorator)) {
|
|
continue;
|
|
}
|
|
if (0 === substr_compare($decorator, $name, -$len, $len, true)) {
|
|
unset($this->_decorators[$decorator]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Clear all decorators
|
|
*
|
|
* @return Zend_Form_Element
|
|
*/
|
|
public function clearDecorators()
|
|
{
|
|
$this->_decorators = array();
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Render form element
|
|
*
|
|
* @param Zend_View_Interface $view
|
|
* @return string
|
|
*/
|
|
public function render(Zend_View_Interface $view = null)
|
|
{
|
|
if ($this->_isPartialRendering) {
|
|
return '';
|
|
}
|
|
|
|
if (null !== $view) {
|
|
$this->setView($view);
|
|
}
|
|
|
|
$content = '';
|
|
foreach ($this->getDecorators() as $decorator) {
|
|
$decorator->setElement($this);
|
|
$content = $decorator->render($content);
|
|
}
|
|
return $content;
|
|
}
|
|
|
|
/**
|
|
* String representation of form element
|
|
*
|
|
* Proxies to {@link render()}.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function __toString()
|
|
{
|
|
try {
|
|
$return = $this->render();
|
|
return $return;
|
|
} catch (Exception $e) {
|
|
trigger_error($e->getMessage(), E_USER_WARNING);
|
|
return '';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Lazy-load a filter
|
|
*
|
|
* @param array $filter
|
|
* @return Zend_Filter_Interface
|
|
*/
|
|
protected function _loadFilter(array $filter)
|
|
{
|
|
$origName = $filter['filter'];
|
|
$name = $this->getPluginLoader(self::FILTER)->load($filter['filter']);
|
|
|
|
if (array_key_exists($name, $this->_filters)) {
|
|
throw new Zend_Form_Exception(sprintf('Filter instance already exists for filter "%s"', $origName));
|
|
}
|
|
|
|
if (empty($filter['options'])) {
|
|
$instance = new $name;
|
|
} else {
|
|
$r = new ReflectionClass($name);
|
|
if ($r->hasMethod('__construct')) {
|
|
$instance = $r->newInstanceArgs((array) $filter['options']);
|
|
} else {
|
|
$instance = $r->newInstance();
|
|
}
|
|
}
|
|
|
|
if ($origName != $name) {
|
|
$filterNames = array_keys($this->_filters);
|
|
$order = array_flip($filterNames);
|
|
$order[$name] = $order[$origName];
|
|
$filtersExchange = array();
|
|
unset($order[$origName]);
|
|
asort($order);
|
|
foreach ($order as $key => $index) {
|
|
if ($key == $name) {
|
|
$filtersExchange[$key] = $instance;
|
|
continue;
|
|
}
|
|
$filtersExchange[$key] = $this->_filters[$key];
|
|
}
|
|
$this->_filters = $filtersExchange;
|
|
} else {
|
|
$this->_filters[$name] = $instance;
|
|
}
|
|
|
|
return $instance;
|
|
}
|
|
|
|
/**
|
|
* Lazy-load a validator
|
|
*
|
|
* @param array $validator Validator definition
|
|
* @return Zend_Validate_Interface
|
|
*/
|
|
protected function _loadValidator(array $validator)
|
|
{
|
|
$origName = $validator['validator'];
|
|
$name = $this->getPluginLoader(self::VALIDATE)->load($validator['validator']);
|
|
|
|
if (array_key_exists($name, $this->_validators)) {
|
|
throw new Zend_Form_Exception(sprintf('Validator instance already exists for validator "%s"', $origName));
|
|
}
|
|
|
|
$messages = false;
|
|
if (isset($validator['options']) && array_key_exists('messages', (array)$validator['options'])) {
|
|
$messages = $validator['options']['messages'];
|
|
unset($validator['options']['messages']);
|
|
}
|
|
|
|
if (empty($validator['options'])) {
|
|
$instance = new $name;
|
|
} else {
|
|
$r = new ReflectionClass($name);
|
|
if ($r->hasMethod('__construct')) {
|
|
$numeric = false;
|
|
if (is_array($validator['options'])) {
|
|
$keys = array_keys($validator['options']);
|
|
foreach($keys as $key) {
|
|
if (is_numeric($key)) {
|
|
$numeric = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($numeric) {
|
|
$instance = $r->newInstanceArgs((array) $validator['options']);
|
|
} else {
|
|
$instance = $r->newInstance($validator['options']);
|
|
}
|
|
} else {
|
|
$instance = $r->newInstance();
|
|
}
|
|
}
|
|
|
|
if ($messages) {
|
|
if (is_array($messages)) {
|
|
$instance->setMessages($messages);
|
|
} elseif (is_string($messages)) {
|
|
$instance->setMessage($messages);
|
|
}
|
|
}
|
|
$instance->zfBreakChainOnFailure = $validator['breakChainOnFailure'];
|
|
|
|
if ($origName != $name) {
|
|
$validatorNames = array_keys($this->_validators);
|
|
$order = array_flip($validatorNames);
|
|
$order[$name] = $order[$origName];
|
|
$validatorsExchange = array();
|
|
unset($order[$origName]);
|
|
asort($order);
|
|
foreach ($order as $key => $index) {
|
|
if ($key == $name) {
|
|
$validatorsExchange[$key] = $instance;
|
|
continue;
|
|
}
|
|
$validatorsExchange[$key] = $this->_validators[$key];
|
|
}
|
|
$this->_validators = $validatorsExchange;
|
|
} else {
|
|
$this->_validators[$name] = $instance;
|
|
}
|
|
|
|
return $instance;
|
|
}
|
|
|
|
/**
|
|
* Lazy-load a decorator
|
|
*
|
|
* @param array $decorator Decorator type and options
|
|
* @param mixed $name Decorator name or alias
|
|
* @return Zend_Form_Decorator_Interface
|
|
*/
|
|
protected function _loadDecorator(array $decorator, $name)
|
|
{
|
|
$sameName = false;
|
|
if ($name == $decorator['decorator']) {
|
|
$sameName = true;
|
|
}
|
|
|
|
$instance = $this->_getDecorator($decorator['decorator'], $decorator['options']);
|
|
if ($sameName) {
|
|
$newName = get_class($instance);
|
|
$decoratorNames = array_keys($this->_decorators);
|
|
$order = array_flip($decoratorNames);
|
|
$order[$newName] = $order[$name];
|
|
$decoratorsExchange = array();
|
|
unset($order[$name]);
|
|
asort($order);
|
|
foreach ($order as $key => $index) {
|
|
if ($key == $newName) {
|
|
$decoratorsExchange[$key] = $instance;
|
|
continue;
|
|
}
|
|
$decoratorsExchange[$key] = $this->_decorators[$key];
|
|
}
|
|
$this->_decorators = $decoratorsExchange;
|
|
} else {
|
|
$this->_decorators[$name] = $instance;
|
|
}
|
|
|
|
return $instance;
|
|
}
|
|
|
|
/**
|
|
* Retrieve error messages and perform translation and value substitution
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function _getErrorMessages()
|
|
{
|
|
$translator = $this->getTranslator();
|
|
$messages = $this->getErrorMessages();
|
|
$value = $this->getValue();
|
|
foreach ($messages as $key => $message) {
|
|
if (null !== $translator) {
|
|
$message = $translator->translate($message);
|
|
}
|
|
if ($this->isArray() || is_array($value)) {
|
|
$aggregateMessages = array();
|
|
foreach ($value as $val) {
|
|
$aggregateMessages[] = str_replace('%value%', $val, $message);
|
|
}
|
|
if (count($aggregateMessages)) {
|
|
if ($this->_concatJustValuesInErrorMessage) {
|
|
$values = implode($this->getErrorMessageSeparator(), $value);
|
|
$messages[$key] = str_replace('%value%', $values, $message);
|
|
} else {
|
|
$messages[$key] = implode($this->getErrorMessageSeparator(), $aggregateMessages);
|
|
}
|
|
}
|
|
} else {
|
|
$messages[$key] = str_replace('%value%', $value, $message);
|
|
}
|
|
}
|
|
return $messages;
|
|
}
|
|
|
|
/**
|
|
* Are there custom error messages registered?
|
|
*
|
|
* @return bool
|
|
*/
|
|
protected function _hasErrorMessages()
|
|
{
|
|
return !empty($this->_errorMessages);
|
|
}
|
|
}
|