interface/modules/zend_modules/library/Zend/InputFilter/CollectionInputFilter.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\InputFilter;
  11
  12 use Traversable;
  13
  14 class CollectionInputFilter extends InputFilter
  15 {
  16     /*
  17      * @var array
  18      */
  19     protected $collectionData;
  20
  21     /*
  22      * @var array
  23      */
  24     protected $collectionValidInputs;
  25
  26     /*
  27      * @var array
  28      */
  29     protected $collectionInvalidInputs;
  30
  31     /*
  32      * @var bool
  33      */
  34     protected $isRequired = false;
  35
  36     /*
  37      * @var int
  38      */
  39     protected $count = null;
  40
  41     /*
  42      * @var array
  43      */
  44     protected $collectionValues = array();
  45
  46     /*
  47      * @var array
  48      */
  49     protected $collectionRawValues = array();
  50
  51     /**
  52      * @var BaseInputFilter
  53      */
  54     protected $inputFilter;
  55
  56     /**
  57      * Set the input filter to use when looping the data
  58      *
  59      * @param BaseInputFilter|array|Traversable $inputFilter
  60      * @return CollectionInputFilter
  61      */
  62     public function setInputFilter($inputFilter)
  63     {
  64         if (is_array($inputFilter) || $inputFilter instanceof Traversable) {
  65             $inputFilter = $this->getFactory()->createInputFilter($inputFilter);
  66         }
  67
  68         if (!$inputFilter instanceof BaseInputFilter) {
  69             throw new Exception\RuntimeException(sprintf(
  70                 '%s expects an instance of %s; received "%s"',
  71                 __METHOD__,
  72                 'Zend\InputFilter\BaseInputFilter',
  73                 (is_object($inputFilter) ? get_class($inputFilter) : gettype($inputFilter))
  74             ));
  75         }
  76
  77         $this->inputFilter = $inputFilter;
  78         $this->inputs = $inputFilter->getInputs();
  79         return $this;
  80     }
  81
  82     /**
  83      * Get the input filter used when looping the data
  84      *
  85      * @return BaseInputFilter
  86      */
  87     public function getInputFilter()
  88     {
  89         if (null === $this->inputFilter) {
  90             $this->setInputFilter(new InputFilter());
  91         }
  92         return $this->inputFilter;
  93     }
  94
  95     /**
  96      * Set if the collection can be empty
  97      *
  98      * @param bool $isRequired
  99      * @return CollectionInputFilter
 100      */
 101     public function setIsRequired($isRequired)
 102     {
 103         $this->isRequired = $isRequired;
 104         return $this;
 105     }
 106
 107     /**
 108      * Get if collection can be empty
 109      *
 110      * @return bool
 111      */
 112     public function getIsRequired()
 113     {
 114         return $this->isRequired;
 115     }
 116
 117
 118     /**
 119      * Set the count of data to validate
 120      *
 121      * @param int $count
 122      * @return CollectionInputFilter
 123      */
 124     public function setCount($count)
 125     {
 126         $this->count = $count > 0 ? $count : 0;
 127         return $this;
 128     }
 129
 130     /**
 131      * Get the count of data to validate, use the count of data by default
 132      *
 133      * @return int
 134      */
 135     public function getCount()
 136     {
 137         if (null === $this->count) {
 138             $this->count = count($this->collectionData);
 139         }
 140         return $this->count;
 141     }
 142
 143     /**
 144      * {@inheritdoc}
 145      */
 146     public function setData($data)
 147     {
 148         $this->collectionData = $data;
 149     }
 150
 151     /**
 152      * {@inheritdoc}
 153      */
 154     public function isValid()
 155     {
 156         $valid = true;
 157
 158         if ($this->getCount() < 1) {
 159             if ($this->isRequired) {
 160                 $valid = false;
 161             }
 162             return $valid;
 163         }
 164
 165         if (count($this->collectionData) < $this->getCount()) {
 166             $valid = false;
 167         }
 168
 169         $inputs = $this->validationGroup ?: array_keys($this->inputs);
 170         foreach ($this->collectionData as $key => $data) {
 171             if (!is_array($data)) {
 172                 $data = array();
 173             }
 174             $this->data = $data;
 175             $this->populate();
 176
 177             if ($this->validateInputs($inputs)) {
 178                 $this->collectionValidInputs[$key] = $this->validInputs;
 179             } else {
 180                 $this->collectionInvalidInputs[$key] = $this->invalidInputs;
 181                 $valid = false;
 182             }
 183
 184             $values    = array();
 185             $rawValues = array();
 186             foreach ($inputs as $name) {
 187                 $input = $this->inputs[$name];
 188
 189                 if ($input instanceof InputFilterInterface) {
 190                     $values[$name]    = $input->getValues();
 191                     $rawValues[$name] = $input->getRawValues();
 192                     continue;
 193                 }
 194                 $values[$name]    = $input->getValue($this->data);
 195                 $rawValues[$name] = $input->getRawValue();
 196             }
 197             $this->collectionValues[$key]    = $values;
 198             $this->collectionRawValues[$key] = $rawValues;
 199         }
 200
 201         return $valid;
 202     }
 203
 204     /**
 205      * {@inheritdoc}
 206      */
 207     public function setValidationGroup($name)
 208     {
 209         if ($name === self::VALIDATE_ALL) {
 210             $this->validationGroup = null;
 211             return $this;
 212         }
 213
 214         if (is_array($name)) {
 215             // Best effort check if the validation group was set by a form for BC
 216             if (count($name) == count($this->collectionData) && is_array(reset($name))) {
 217                 return parent::setValidationGroup(reset($name));
 218             }
 219             return parent::setValidationGroup($name);
 220         }
 221
 222         return parent::setValidationGroup(func_get_args());
 223     }
 224
 225     /**
 226      * {@inheritdoc}
 227      */
 228     public function getInvalidInput()
 229     {
 230         return (is_array($this->collectionInvalidInputs) ? $this->collectionInvalidInputs : array());
 231     }
 232
 233     /**
 234      * {@inheritdoc}
 235      */
 236     public function getValidInput()
 237     {
 238         return (is_array($this->collectionValidInputs) ? $this->collectionValidInputs : array());
 239     }
 240
 241     /**
 242      * {@inheritdoc}
 243      */
 244     public function getValues()
 245     {
 246         return $this->collectionValues;
 247     }
 248
 249     /**
 250      * {@inheritdoc}
 251      */
 252     public function getRawValues()
 253     {
 254         return $this->collectionRawValues;
 255     }
 256
 257     /**
 258      * {@inheritdoc}
 259      */
 260     public function getMessages()
 261     {
 262         $messages = array();
 263         foreach ($this->getInvalidInput() as $key => $inputs) {
 264             foreach ($inputs as $name => $input) {
 265                 $messages[$key][$name] = $input->getMessages();
 266             }
 267         }
 268         return $messages;
 269     }
 270 }