interface/modules/zend_modules/library/Zend/Feed/Writer/Extension/ITunes/Feed.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\Feed\Writer\Extension\ITunes;
  11
  12 use Zend\Feed\Uri;
  13 use Zend\Feed\Writer;
  14 use Zend\Stdlib\StringUtils;
  15 use Zend\Stdlib\StringWrapper\StringWrapperInterface;
  16
  17 /**
  18 */
  19 class Feed
  20 {
  21     /**
  22      * Array of Feed data for rendering by Extension's renderers
  23      *
  24      * @var array
  25      */
  26     protected $data = array();
  27
  28     /**
  29      * Encoding of all text values
  30      *
  31      * @var string
  32      */
  33     protected $encoding = 'UTF-8';
  34
  35     /**
  36      * The used string wrapper supporting encoding
  37      *
  38      * @var StringWrapperInterface
  39      */
  40     protected $stringWrapper;
  41
  42     /**
  43      * Constructor
  44      */
  45     public function __construct()
  46     {
  47         $this->stringWrapper = StringUtils::getWrapper($this->encoding);
  48     }
  49
  50     /**
  51      * Set feed encoding
  52      *
  53      * @param  string $enc
  54      * @return Feed
  55      */
  56     public function setEncoding($enc)
  57     {
  58         $this->stringWrapper = StringUtils::getWrapper($enc);
  59         $this->encoding      = $enc;
  60         return $this;
  61     }
  62
  63     /**
  64      * Get feed encoding
  65      *
  66      * @return string
  67      */
  68     public function getEncoding()
  69     {
  70         return $this->encoding;
  71     }
  72
  73     /**
  74      * Set a block value of "yes" or "no". You may also set an empty string.
  75      *
  76      * @param  string
  77      * @return Feed
  78      * @throws Writer\Exception\InvalidArgumentException
  79      */
  80     public function setItunesBlock($value)
  81     {
  82         if (!ctype_alpha($value) && strlen($value) > 0) {
  83             throw new Writer\Exception\InvalidArgumentException('invalid parameter: "block" may only'
  84             . ' contain alphabetic characters');
  85         }
  86         if ($this->stringWrapper->strlen($value) > 255) {
  87             throw new Writer\Exception\InvalidArgumentException('invalid parameter: "block" may only'
  88             . ' contain a maximum of 255 characters');
  89         }
  90         $this->data['block'] = $value;
  91         return $this;
  92     }
  93
  94     /**
  95      * Add feed authors
  96      *
  97      * @param  array $values
  98      * @return Feed
  99      */
 100     public function addItunesAuthors(array $values)
 101     {
 102         foreach ($values as $value) {
 103             $this->addItunesAuthor($value);
 104         }
 105         return $this;
 106     }
 107
 108     /**
 109      * Add feed author
 110      *
 111      * @param  string $value
 112      * @return Feed
 113      * @throws Writer\Exception\InvalidArgumentException
 114      */
 115     public function addItunesAuthor($value)
 116     {
 117         if ($this->stringWrapper->strlen($value) > 255) {
 118             throw new Writer\Exception\InvalidArgumentException('invalid parameter: any "author" may only'
 119             . ' contain a maximum of 255 characters each');
 120         }
 121         if (!isset($this->data['authors'])) {
 122             $this->data['authors'] = array();
 123         }
 124         $this->data['authors'][] = $value;
 125         return $this;
 126     }
 127
 128     /**
 129      * Set feed categories
 130      *
 131      * @param  array $values
 132      * @return Feed
 133      * @throws Writer\Exception\InvalidArgumentException
 134      */
 135     public function setItunesCategories(array $values)
 136     {
 137         if (!isset($this->data['categories'])) {
 138             $this->data['categories'] = array();
 139         }
 140         foreach ($values as $key => $value) {
 141             if (!is_array($value)) {
 142                 if ($this->stringWrapper->strlen($value) > 255) {
 143                     throw new Writer\Exception\InvalidArgumentException('invalid parameter: any "category" may only'
 144                     . ' contain a maximum of 255 characters each');
 145                 }
 146                 $this->data['categories'][] = $value;
 147             } else {
 148                 if ($this->stringWrapper->strlen($key) > 255) {
 149                     throw new Writer\Exception\InvalidArgumentException('invalid parameter: any "category" may only'
 150                     . ' contain a maximum of 255 characters each');
 151                 }
 152                 $this->data['categories'][$key] = array();
 153                 foreach ($value as $val) {
 154                     if ($this->stringWrapper->strlen($val) > 255) {
 155                         throw new Writer\Exception\InvalidArgumentException('invalid parameter: any "category" may only'
 156                         . ' contain a maximum of 255 characters each');
 157                     }
 158                     $this->data['categories'][$key][] = $val;
 159                 }
 160             }
 161         }
 162         return $this;
 163     }
 164
 165     /**
 166      * Set feed image (icon)
 167      *
 168      * @param  string $value
 169      * @return Feed
 170      * @throws Writer\Exception\InvalidArgumentException
 171      */
 172     public function setItunesImage($value)
 173     {
 174         if (!Uri::factory($value)->isValid()) {
 175             throw new Writer\Exception\InvalidArgumentException('invalid parameter: "image" may only'
 176             . ' be a valid URI/IRI');
 177         }
 178         if (!in_array(substr($value, -3), array('jpg', 'png'))) {
 179             throw new Writer\Exception\InvalidArgumentException('invalid parameter: "image" may only'
 180             . ' use file extension "jpg" or "png" which must be the last three'
 181             . ' characters of the URI (i.e. no query string or fragment)');
 182         }
 183         $this->data['image'] = $value;
 184         return $this;
 185     }
 186
 187     /**
 188      * Set feed cumulative duration
 189      *
 190      * @param  string $value
 191      * @return Feed
 192      * @throws Writer\Exception\InvalidArgumentException
 193      */
 194     public function setItunesDuration($value)
 195     {
 196         $value = (string) $value;
 197         if (!ctype_digit($value)
 198             && !preg_match("/^\d+:[0-5]{1}[0-9]{1}$/", $value)
 199             && !preg_match("/^\d+:[0-5]{1}[0-9]{1}:[0-5]{1}[0-9]{1}$/", $value)
 200         ) {
 201             throw new Writer\Exception\InvalidArgumentException('invalid parameter: "duration" may only'
 202             . ' be of a specified [[HH:]MM:]SS format');
 203         }
 204         $this->data['duration'] = $value;
 205         return $this;
 206     }
 207
 208     /**
 209      * Set "explicit" flag
 210      *
 211      * @param  bool $value
 212      * @return Feed
 213      * @throws Writer\Exception\InvalidArgumentException
 214      */
 215     public function setItunesExplicit($value)
 216     {
 217         if (!in_array($value, array('yes', 'no', 'clean'))) {
 218             throw new Writer\Exception\InvalidArgumentException('invalid parameter: "explicit" may only'
 219             . ' be one of "yes", "no" or "clean"');
 220         }
 221         $this->data['explicit'] = $value;
 222         return $this;
 223     }
 224
 225     /**
 226      * Set feed keywords
 227      *
 228      * @param  array $value
 229      * @return Feed
 230      * @throws Writer\Exception\InvalidArgumentException
 231      */
 232     public function setItunesKeywords(array $value)
 233     {
 234         if (count($value) > 12) {
 235             throw new Writer\Exception\InvalidArgumentException('invalid parameter: "keywords" may only'
 236             . ' contain a maximum of 12 terms');
 237         }
 238         $concat = implode(',', $value);
 239         if ($this->stringWrapper->strlen($concat) > 255) {
 240             throw new Writer\Exception\InvalidArgumentException('invalid parameter: "keywords" may only'
 241             . ' have a concatenated length of 255 chars where terms are delimited'
 242             . ' by a comma');
 243         }
 244         $this->data['keywords'] = $value;
 245         return $this;
 246     }
 247
 248     /**
 249      * Set new feed URL
 250      *
 251      * @param  string $value
 252      * @return Feed
 253      * @throws Writer\Exception\InvalidArgumentException
 254      */
 255     public function setItunesNewFeedUrl($value)
 256     {
 257         if (!Uri::factory($value)->isValid()) {
 258             throw new Writer\Exception\InvalidArgumentException('invalid parameter: "newFeedUrl" may only'
 259             . ' be a valid URI/IRI');
 260         }
 261         $this->data['newFeedUrl'] = $value;
 262         return $this;
 263     }
 264
 265     /**
 266      * Add feed owners
 267      *
 268      * @param  array $values
 269      * @return Feed
 270      */
 271     public function addItunesOwners(array $values)
 272     {
 273         foreach ($values as $value) {
 274             $this->addItunesOwner($value);
 275         }
 276         return $this;
 277     }
 278
 279     /**
 280      * Add feed owner
 281      *
 282      * @param  array $value
 283      * @return Feed
 284      * @throws Writer\Exception\InvalidArgumentException
 285      */
 286     public function addItunesOwner(array $value)
 287     {
 288         if (!isset($value['name']) || !isset($value['email'])) {
 289             throw new Writer\Exception\InvalidArgumentException('invalid parameter: any "owner" must'
 290             . ' be an array containing keys "name" and "email"');
 291         }
 292         if ($this->stringWrapper->strlen($value['name']) > 255
 293             || $this->stringWrapper->strlen($value['email']) > 255
 294         ) {
 295             throw new Writer\Exception\InvalidArgumentException('invalid parameter: any "owner" may only'
 296             . ' contain a maximum of 255 characters each for "name" and "email"');
 297         }
 298         if (!isset($this->data['owners'])) {
 299             $this->data['owners'] = array();
 300         }
 301         $this->data['owners'][] = $value;
 302         return $this;
 303     }
 304
 305     /**
 306      * Set feed subtitle
 307      *
 308      * @param  string $value
 309      * @return Feed
 310      * @throws Writer\Exception\InvalidArgumentException
 311      */
 312     public function setItunesSubtitle($value)
 313     {
 314         if ($this->stringWrapper->strlen($value) > 255) {
 315             throw new Writer\Exception\InvalidArgumentException('invalid parameter: "subtitle" may only'
 316             . ' contain a maximum of 255 characters');
 317         }
 318         $this->data['subtitle'] = $value;
 319         return $this;
 320     }
 321
 322     /**
 323      * Set feed summary
 324      *
 325      * @param  string $value
 326      * @return Feed
 327      * @throws Writer\Exception\InvalidArgumentException
 328      */
 329     public function setItunesSummary($value)
 330     {
 331         if ($this->stringWrapper->strlen($value) > 4000) {
 332             throw new Writer\Exception\InvalidArgumentException('invalid parameter: "summary" may only'
 333             . ' contain a maximum of 4000 characters');
 334         }
 335         $this->data['summary'] = $value;
 336         return $this;
 337     }
 338
 339     /**
 340      * Overloading: proxy to internal setters
 341      *
 342      * @param  string $method
 343      * @param  array $params
 344      * @return mixed
 345      * @throws Writer\Exception\BadMethodCallException
 346      */
 347     public function __call($method, array $params)
 348     {
 349         $point = lcfirst(substr($method, 9));
 350         if (!method_exists($this, 'setItunes' . ucfirst($point))
 351             && !method_exists($this, 'addItunes' . ucfirst($point))
 352         ) {
 353             throw new Writer\Exception\BadMethodCallException(
 354                 'invalid method: ' . $method
 355             );
 356         }
 357         if (!array_key_exists($point, $this->data) || empty($this->data[$point])) {
 358             return null;
 359         }
 360         return $this->data[$point];
 361     }
 362 }