]>
Commit | Line | Data |
---|---|---|
1 | <?php | |
2 | /** | |
3 | * SimplePie | |
4 | * | |
5 | * A PHP-Based RSS and Atom Feed Framework. | |
6 | * Takes the hard work out of managing a complete RSS/Atom solution. | |
7 | * | |
8 | * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors | |
9 | * All rights reserved. | |
10 | * | |
11 | * Redistribution and use in source and binary forms, with or without modification, are | |
12 | * permitted provided that the following conditions are met: | |
13 | * | |
14 | * * Redistributions of source code must retain the above copyright notice, this list of | |
15 | * conditions and the following disclaimer. | |
16 | * | |
17 | * * Redistributions in binary form must reproduce the above copyright notice, this list | |
18 | * of conditions and the following disclaimer in the documentation and/or other materials | |
19 | * provided with the distribution. | |
20 | * | |
21 | * * Neither the name of the SimplePie Team nor the names of its contributors may be used | |
22 | * to endorse or promote products derived from this software without specific prior | |
23 | * written permission. | |
24 | * | |
25 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS | |
26 | * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY | |
27 | * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS | |
28 | * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | |
29 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |
30 | * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
31 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR | |
32 | * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
33 | * POSSIBILITY OF SUCH DAMAGE. | |
34 | * | |
35 | * @package SimplePie | |
36 | * @version 1.3.1 | |
37 | * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue | |
38 | * @author Ryan Parman | |
39 | * @author Geoffrey Sneddon | |
40 | * @author Ryan McCue | |
41 | * @link http://simplepie.org/ SimplePie | |
42 | * @license http://www.opensource.org/licenses/bsd-license.php BSD License | |
43 | */ | |
44 | ||
45 | ||
46 | /** | |
47 | * Manages all item-related data | |
48 | * | |
49 | * Used by {@see SimplePie::get_item()} and {@see SimplePie::get_items()} | |
50 | * | |
51 | * This class can be overloaded with {@see SimplePie::set_item_class()} | |
52 | * | |
53 | * @package SimplePie | |
54 | * @subpackage API | |
55 | */ | |
56 | class SimplePie_Item | |
57 | { | |
58 | /** | |
59 | * Parent feed | |
60 | * | |
61 | * @access private | |
62 | * @var SimplePie | |
63 | */ | |
64 | var $feed; | |
65 | ||
66 | /** | |
67 | * Raw data | |
68 | * | |
69 | * @access private | |
70 | * @var array | |
71 | */ | |
72 | var $data = array(); | |
73 | ||
74 | /** | |
75 | * Registry object | |
76 | * | |
77 | * @see set_registry | |
78 | * @var SimplePie_Registry | |
79 | */ | |
80 | protected $registry; | |
81 | ||
82 | /** | |
83 | * Create a new item object | |
84 | * | |
85 | * This is usually used by {@see SimplePie::get_items} and | |
86 | * {@see SimplePie::get_item}. Avoid creating this manually. | |
87 | * | |
88 | * @param SimplePie $feed Parent feed | |
89 | * @param array $data Raw data | |
90 | */ | |
91 | public function __construct($feed, $data) | |
92 | { | |
93 | $this->feed = $feed; | |
94 | $this->data = $data; | |
95 | } | |
96 | ||
97 | /** | |
98 | * Set the registry handler | |
99 | * | |
100 | * This is usually used by {@see SimplePie_Registry::create} | |
101 | * | |
102 | * @since 1.3 | |
103 | * @param SimplePie_Registry $registry | |
104 | */ | |
105 | public function set_registry(SimplePie_Registry $registry) | |
106 | { | |
107 | $this->registry = $registry; | |
108 | } | |
109 | ||
110 | /** | |
111 | * Get a string representation of the item | |
112 | * | |
113 | * @return string | |
114 | */ | |
115 | public function __toString() | |
116 | { | |
117 | return md5(serialize($this->data)); | |
118 | } | |
119 | ||
120 | /** | |
121 | * Remove items that link back to this before destroying this object | |
122 | */ | |
123 | public function __destruct() | |
124 | { | |
125 | if ((version_compare(PHP_VERSION, '5.3', '<') || !gc_enabled()) && !ini_get('zend.ze1_compatibility_mode')) | |
126 | { | |
127 | unset($this->feed); | |
128 | } | |
129 | } | |
130 | ||
131 | /** | |
132 | * Get data for an item-level element | |
133 | * | |
134 | * This method allows you to get access to ANY element/attribute that is a | |
135 | * sub-element of the item/entry tag. | |
136 | * | |
137 | * See {@see SimplePie::get_feed_tags()} for a description of the return value | |
138 | * | |
139 | * @since 1.0 | |
140 | * @see http://simplepie.org/wiki/faq/supported_xml_namespaces | |
141 | * @param string $namespace The URL of the XML namespace of the elements you're trying to access | |
142 | * @param string $tag Tag name | |
143 | * @return array | |
144 | */ | |
145 | public function get_item_tags($namespace, $tag) | |
146 | { | |
147 | if (isset($this->data['child'][$namespace][$tag])) | |
148 | { | |
149 | return $this->data['child'][$namespace][$tag]; | |
150 | } | |
151 | else | |
152 | { | |
153 | return null; | |
154 | } | |
155 | } | |
156 | ||
157 | /** | |
158 | * Get the base URL value from the parent feed | |
159 | * | |
160 | * Uses `<xml:base>` | |
161 | * | |
162 | * @param array $element | |
163 | * @return string | |
164 | */ | |
165 | public function get_base($element = array()) | |
166 | { | |
167 | return $this->feed->get_base($element); | |
168 | } | |
169 | ||
170 | /** | |
171 | * Sanitize feed data | |
172 | * | |
173 | * @access private | |
174 | * @see SimplePie::sanitize() | |
175 | * @param string $data Data to sanitize | |
176 | * @param int $type One of the SIMPLEPIE_CONSTRUCT_* constants | |
177 | * @param string $base Base URL to resolve URLs against | |
178 | * @return string Sanitized data | |
179 | */ | |
180 | public function sanitize($data, $type, $base = '') | |
181 | { | |
182 | return $this->feed->sanitize($data, $type, $base); | |
183 | } | |
184 | ||
185 | /** | |
186 | * Get the parent feed | |
187 | * | |
188 | * Note: this may not work as you think for multifeeds! | |
189 | * | |
190 | * @link http://simplepie.org/faq/typical_multifeed_gotchas#missing_data_from_feed | |
191 | * @since 1.0 | |
192 | * @return SimplePie | |
193 | */ | |
194 | public function get_feed() | |
195 | { | |
196 | return $this->feed; | |
197 | } | |
198 | ||
199 | /** | |
200 | * Get the unique identifier for the item | |
201 | * | |
202 | * This is usually used when writing code to check for new items in a feed. | |
203 | * | |
204 | * Uses `<atom:id>`, `<guid>`, `<dc:identifier>` or the `about` attribute | |
205 | * for RDF. If none of these are supplied (or `$hash` is true), creates an | |
206 | * MD5 hash based on the permalink and title. If either of those are not | |
207 | * supplied, creates a hash based on the full feed data. | |
208 | * | |
209 | * @since Beta 2 | |
210 | * @param boolean $hash Should we force using a hash instead of the supplied ID? | |
211 | * @return string | |
212 | */ | |
213 | public function get_id($hash = false) | |
214 | { | |
215 | if (!$hash) | |
216 | { | |
217 | if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'id')) | |
218 | { | |
219 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
220 | } | |
221 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'id')) | |
222 | { | |
223 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
224 | } | |
225 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'guid')) | |
226 | { | |
227 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
228 | } | |
229 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'identifier')) | |
230 | { | |
231 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
232 | } | |
233 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'identifier')) | |
234 | { | |
235 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
236 | } | |
237 | elseif (isset($this->data['attribs'][SIMPLEPIE_NAMESPACE_RDF]['about'])) | |
238 | { | |
239 | return $this->sanitize($this->data['attribs'][SIMPLEPIE_NAMESPACE_RDF]['about'], SIMPLEPIE_CONSTRUCT_TEXT); | |
240 | } | |
241 | elseif (($return = $this->get_permalink()) !== null) | |
242 | { | |
243 | return $return; | |
244 | } | |
245 | elseif (($return = $this->get_title()) !== null) | |
246 | { | |
247 | return $return; | |
248 | } | |
249 | } | |
250 | if ($this->get_permalink() !== null || $this->get_title() !== null) | |
251 | { | |
252 | return md5($this->get_permalink() . $this->get_title()); | |
253 | } | |
254 | else | |
255 | { | |
256 | return md5(serialize($this->data)); | |
257 | } | |
258 | } | |
259 | ||
260 | /** | |
261 | * Get the title of the item | |
262 | * | |
263 | * Uses `<atom:title>`, `<title>` or `<dc:title>` | |
264 | * | |
265 | * @since Beta 2 (previously called `get_item_title` since 0.8) | |
266 | * @return string|null | |
267 | */ | |
268 | public function get_title() | |
269 | { | |
270 | if (!isset($this->data['title'])) | |
271 | { | |
272 | if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'title')) | |
273 | { | |
274 | $this->data['title'] = $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); | |
275 | } | |
276 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'title')) | |
277 | { | |
278 | $this->data['title'] = $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); | |
279 | } | |
280 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'title')) | |
281 | { | |
282 | $this->data['title'] = $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0])); | |
283 | } | |
284 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'title')) | |
285 | { | |
286 | $this->data['title'] = $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0])); | |
287 | } | |
288 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'title')) | |
289 | { | |
290 | $this->data['title'] = $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0])); | |
291 | } | |
292 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'title')) | |
293 | { | |
294 | $this->data['title'] = $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
295 | } | |
296 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'title')) | |
297 | { | |
298 | $this->data['title'] = $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
299 | } | |
300 | else | |
301 | { | |
302 | $this->data['title'] = null; | |
303 | } | |
304 | } | |
305 | return $this->data['title']; | |
306 | } | |
307 | ||
308 | /** | |
309 | * Get the content for the item | |
310 | * | |
311 | * Prefers summaries over full content , but will return full content if a | |
312 | * summary does not exist. | |
313 | * | |
314 | * To prefer full content instead, use {@see get_content} | |
315 | * | |
316 | * Uses `<atom:summary>`, `<description>`, `<dc:description>` or | |
317 | * `<itunes:subtitle>` | |
318 | * | |
319 | * @since 0.8 | |
320 | * @param boolean $description_only Should we avoid falling back to the content? | |
321 | * @return string|null | |
322 | */ | |
323 | public function get_description($description_only = false) | |
324 | { | |
325 | if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'summary')) | |
326 | { | |
327 | return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); | |
328 | } | |
329 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'summary')) | |
330 | { | |
331 | return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); | |
332 | } | |
333 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'description')) | |
334 | { | |
335 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0])); | |
336 | } | |
337 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'description')) | |
338 | { | |
339 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0])); | |
340 | } | |
341 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'description')) | |
342 | { | |
343 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
344 | } | |
345 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'description')) | |
346 | { | |
347 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
348 | } | |
349 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'summary')) | |
350 | { | |
351 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0])); | |
352 | } | |
353 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'subtitle')) | |
354 | { | |
355 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
356 | } | |
357 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'description')) | |
358 | { | |
359 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML); | |
360 | } | |
361 | ||
362 | elseif (!$description_only) | |
363 | { | |
364 | return $this->get_content(true); | |
365 | } | |
366 | else | |
367 | { | |
368 | return null; | |
369 | } | |
370 | } | |
371 | ||
372 | /** | |
373 | * Get the content for the item | |
374 | * | |
375 | * Prefers full content over summaries, but will return a summary if full | |
376 | * content does not exist. | |
377 | * | |
378 | * To prefer summaries instead, use {@see get_description} | |
379 | * | |
380 | * Uses `<atom:content>` or `<content:encoded>` (RSS 1.0 Content Module) | |
381 | * | |
382 | * @since 1.0 | |
383 | * @param boolean $content_only Should we avoid falling back to the description? | |
384 | * @return string|null | |
385 | */ | |
386 | public function get_content($content_only = false) | |
387 | { | |
388 | if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'content')) | |
389 | { | |
390 | return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_content_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); | |
391 | } | |
392 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'content')) | |
393 | { | |
394 | return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); | |
395 | } | |
396 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_10_MODULES_CONTENT, 'encoded')) | |
397 | { | |
398 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0])); | |
399 | } | |
400 | elseif (!$content_only) | |
401 | { | |
402 | return $this->get_description(true); | |
403 | } | |
404 | else | |
405 | { | |
406 | return null; | |
407 | } | |
408 | } | |
409 | ||
410 | /** | |
411 | * Get a category for the item | |
412 | * | |
413 | * @since Beta 3 (previously called `get_categories()` since Beta 2) | |
414 | * @param int $key The category that you want to return. Remember that arrays begin with 0, not 1 | |
415 | * @return SimplePie_Category|null | |
416 | */ | |
417 | public function get_category($key = 0) | |
418 | { | |
419 | $categories = $this->get_categories(); | |
420 | if (isset($categories[$key])) | |
421 | { | |
422 | return $categories[$key]; | |
423 | } | |
424 | else | |
425 | { | |
426 | return null; | |
427 | } | |
428 | } | |
429 | ||
430 | /** | |
431 | * Get all categories for the item | |
432 | * | |
433 | * Uses `<atom:category>`, `<category>` or `<dc:subject>` | |
434 | * | |
435 | * @since Beta 3 | |
436 | * @return array|null List of {@see SimplePie_Category} objects | |
437 | */ | |
438 | public function get_categories() | |
439 | { | |
440 | $categories = array(); | |
441 | ||
442 | foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'category') as $category) | |
443 | { | |
444 | $term = null; | |
445 | $scheme = null; | |
446 | $label = null; | |
447 | if (isset($category['attribs']['']['term'])) | |
448 | { | |
449 | $term = $this->sanitize($category['attribs']['']['term'], SIMPLEPIE_CONSTRUCT_TEXT); | |
450 | } | |
451 | if (isset($category['attribs']['']['scheme'])) | |
452 | { | |
453 | $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT); | |
454 | } | |
455 | if (isset($category['attribs']['']['label'])) | |
456 | { | |
457 | $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT); | |
458 | } | |
459 | $categories[] = $this->registry->create('Category', array($term, $scheme, $label)); | |
460 | } | |
461 | foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'category') as $category) | |
462 | { | |
463 | // This is really the label, but keep this as the term also for BC. | |
464 | // Label will also work on retrieving because that falls back to term. | |
465 | $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
466 | if (isset($category['attribs']['']['domain'])) | |
467 | { | |
468 | $scheme = $this->sanitize($category['attribs']['']['domain'], SIMPLEPIE_CONSTRUCT_TEXT); | |
469 | } | |
470 | else | |
471 | { | |
472 | $scheme = null; | |
473 | } | |
474 | $categories[] = $this->registry->create('Category', array($term, $scheme, null)); | |
475 | } | |
476 | foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'subject') as $category) | |
477 | { | |
478 | $categories[] = $this->registry->create('Category', array($this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null)); | |
479 | } | |
480 | foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'subject') as $category) | |
481 | { | |
482 | $categories[] = $this->registry->create('Category', array($this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null)); | |
483 | } | |
484 | ||
485 | if (!empty($categories)) | |
486 | { | |
487 | return array_unique($categories); | |
488 | } | |
489 | else | |
490 | { | |
491 | return null; | |
492 | } | |
493 | } | |
494 | ||
495 | /** | |
496 | * Get an author for the item | |
497 | * | |
498 | * @since Beta 2 | |
499 | * @param int $key The author that you want to return. Remember that arrays begin with 0, not 1 | |
500 | * @return SimplePie_Author|null | |
501 | */ | |
502 | public function get_author($key = 0) | |
503 | { | |
504 | $authors = $this->get_authors(); | |
505 | if (isset($authors[$key])) | |
506 | { | |
507 | return $authors[$key]; | |
508 | } | |
509 | else | |
510 | { | |
511 | return null; | |
512 | } | |
513 | } | |
514 | ||
515 | /** | |
516 | * Get a contributor for the item | |
517 | * | |
518 | * @since 1.1 | |
519 | * @param int $key The contrbutor that you want to return. Remember that arrays begin with 0, not 1 | |
520 | * @return SimplePie_Author|null | |
521 | */ | |
522 | public function get_contributor($key = 0) | |
523 | { | |
524 | $contributors = $this->get_contributors(); | |
525 | if (isset($contributors[$key])) | |
526 | { | |
527 | return $contributors[$key]; | |
528 | } | |
529 | else | |
530 | { | |
531 | return null; | |
532 | } | |
533 | } | |
534 | ||
535 | /** | |
536 | * Get all contributors for the item | |
537 | * | |
538 | * Uses `<atom:contributor>` | |
539 | * | |
540 | * @since 1.1 | |
541 | * @return array|null List of {@see SimplePie_Author} objects | |
542 | */ | |
543 | public function get_contributors() | |
544 | { | |
545 | $contributors = array(); | |
546 | foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'contributor') as $contributor) | |
547 | { | |
548 | $name = null; | |
549 | $uri = null; | |
550 | $email = null; | |
551 | if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'])) | |
552 | { | |
553 | $name = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
554 | } | |
555 | if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'])) | |
556 | { | |
557 | $uri = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0])); | |
558 | } | |
559 | if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'])) | |
560 | { | |
561 | $email = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
562 | } | |
563 | if ($name !== null || $email !== null || $uri !== null) | |
564 | { | |
565 | $contributors[] = $this->registry->create('Author', array($name, $uri, $email)); | |
566 | } | |
567 | } | |
568 | foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'contributor') as $contributor) | |
569 | { | |
570 | $name = null; | |
571 | $url = null; | |
572 | $email = null; | |
573 | if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'])) | |
574 | { | |
575 | $name = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
576 | } | |
577 | if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'])) | |
578 | { | |
579 | $url = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0])); | |
580 | } | |
581 | if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'])) | |
582 | { | |
583 | $email = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
584 | } | |
585 | if ($name !== null || $email !== null || $url !== null) | |
586 | { | |
587 | $contributors[] = $this->registry->create('Author', array($name, $url, $email)); | |
588 | } | |
589 | } | |
590 | ||
591 | if (!empty($contributors)) | |
592 | { | |
593 | return array_unique($contributors); | |
594 | } | |
595 | else | |
596 | { | |
597 | return null; | |
598 | } | |
599 | } | |
600 | ||
601 | /** | |
602 | * Get all authors for the item | |
603 | * | |
604 | * Uses `<atom:author>`, `<author>`, `<dc:creator>` or `<itunes:author>` | |
605 | * | |
606 | * @since Beta 2 | |
607 | * @return array|null List of {@see SimplePie_Author} objects | |
608 | */ | |
609 | public function get_authors() | |
610 | { | |
611 | $authors = array(); | |
612 | foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'author') as $author) | |
613 | { | |
614 | $name = null; | |
615 | $uri = null; | |
616 | $email = null; | |
617 | if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'])) | |
618 | { | |
619 | $name = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
620 | } | |
621 | if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'])) | |
622 | { | |
623 | $uri = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0])); | |
624 | } | |
625 | if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'])) | |
626 | { | |
627 | $email = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
628 | } | |
629 | if ($name !== null || $email !== null || $uri !== null) | |
630 | { | |
631 | $authors[] = $this->registry->create('Author', array($name, $uri, $email)); | |
632 | } | |
633 | } | |
634 | if ($author = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'author')) | |
635 | { | |
636 | $name = null; | |
637 | $url = null; | |
638 | $email = null; | |
639 | if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'])) | |
640 | { | |
641 | $name = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
642 | } | |
643 | if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'])) | |
644 | { | |
645 | $url = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0])); | |
646 | } | |
647 | if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'])) | |
648 | { | |
649 | $email = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
650 | } | |
651 | if ($name !== null || $email !== null || $url !== null) | |
652 | { | |
653 | $authors[] = $this->registry->create('Author', array($name, $url, $email)); | |
654 | } | |
655 | } | |
656 | if ($author = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'author')) | |
657 | { | |
658 | $authors[] = $this->registry->create('Author', array(null, null, $this->sanitize($author[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT))); | |
659 | } | |
660 | foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'creator') as $author) | |
661 | { | |
662 | $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null)); | |
663 | } | |
664 | foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'creator') as $author) | |
665 | { | |
666 | $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null)); | |
667 | } | |
668 | foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'author') as $author) | |
669 | { | |
670 | $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null)); | |
671 | } | |
672 | ||
673 | if (!empty($authors)) | |
674 | { | |
675 | return array_unique($authors); | |
676 | } | |
677 | elseif (($source = $this->get_source()) && ($authors = $source->get_authors())) | |
678 | { | |
679 | return $authors; | |
680 | } | |
681 | elseif ($authors = $this->feed->get_authors()) | |
682 | { | |
683 | return $authors; | |
684 | } | |
685 | else | |
686 | { | |
687 | return null; | |
688 | } | |
689 | } | |
690 | ||
691 | /** | |
692 | * Get the copyright info for the item | |
693 | * | |
694 | * Uses `<atom:rights>` or `<dc:rights>` | |
695 | * | |
696 | * @since 1.1 | |
697 | * @return string | |
698 | */ | |
699 | public function get_copyright() | |
700 | { | |
701 | if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'rights')) | |
702 | { | |
703 | return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); | |
704 | } | |
705 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'rights')) | |
706 | { | |
707 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
708 | } | |
709 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'rights')) | |
710 | { | |
711 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
712 | } | |
713 | else | |
714 | { | |
715 | return null; | |
716 | } | |
717 | } | |
718 | ||
719 | /** | |
720 | * Get the posting date/time for the item | |
721 | * | |
722 | * Uses `<atom:published>`, `<atom:updated>`, `<atom:issued>`, | |
723 | * `<atom:modified>`, `<pubDate>` or `<dc:date>` | |
724 | * | |
725 | * Note: obeys PHP's timezone setting. To get a UTC date/time, use | |
726 | * {@see get_gmdate} | |
727 | * | |
728 | * @since Beta 2 (previously called `get_item_date` since 0.8) | |
729 | * | |
730 | * @param string $date_format Supports any PHP date format from {@see http://php.net/date} (empty for the raw data) | |
731 | * @return int|string|null | |
732 | */ | |
733 | public function get_date($date_format = 'j F Y, g:i a') | |
734 | { | |
735 | if (!isset($this->data['date'])) | |
736 | { | |
737 | if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'published')) | |
738 | { | |
739 | $this->data['date']['raw'] = $return[0]['data']; | |
740 | } | |
741 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'updated')) | |
742 | { | |
743 | $this->data['date']['raw'] = $return[0]['data']; | |
744 | } | |
745 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'issued')) | |
746 | { | |
747 | $this->data['date']['raw'] = $return[0]['data']; | |
748 | } | |
749 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'created')) | |
750 | { | |
751 | $this->data['date']['raw'] = $return[0]['data']; | |
752 | } | |
753 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'modified')) | |
754 | { | |
755 | $this->data['date']['raw'] = $return[0]['data']; | |
756 | } | |
757 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'pubDate')) | |
758 | { | |
759 | $this->data['date']['raw'] = $return[0]['data']; | |
760 | } | |
761 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'date')) | |
762 | { | |
763 | $this->data['date']['raw'] = $return[0]['data']; | |
764 | } | |
765 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'date')) | |
766 | { | |
767 | $this->data['date']['raw'] = $return[0]['data']; | |
768 | } | |
769 | ||
770 | if (!empty($this->data['date']['raw'])) | |
771 | { | |
772 | $parser = $this->registry->call('Parse_Date', 'get'); | |
773 | $this->data['date']['parsed'] = $parser->parse($this->data['date']['raw']); | |
774 | } | |
775 | else | |
776 | { | |
777 | $this->data['date'] = null; | |
778 | } | |
779 | } | |
780 | if ($this->data['date']) | |
781 | { | |
782 | $date_format = (string) $date_format; | |
783 | switch ($date_format) | |
784 | { | |
785 | case '': | |
786 | return $this->sanitize($this->data['date']['raw'], SIMPLEPIE_CONSTRUCT_TEXT); | |
787 | ||
788 | case 'U': | |
789 | return $this->data['date']['parsed']; | |
790 | ||
791 | default: | |
792 | return date($date_format, $this->data['date']['parsed']); | |
793 | } | |
794 | } | |
795 | else | |
796 | { | |
797 | return null; | |
798 | } | |
799 | } | |
800 | ||
801 | /** | |
802 | * Get the update date/time for the item | |
803 | * | |
804 | * Uses `<atom:updated>` | |
805 | * | |
806 | * Note: obeys PHP's timezone setting. To get a UTC date/time, use | |
807 | * {@see get_gmdate} | |
808 | * | |
809 | * @param string $date_format Supports any PHP date format from {@see http://php.net/date} (empty for the raw data) | |
810 | * @return int|string|null | |
811 | */ | |
812 | public function get_updated_date($date_format = 'j F Y, g:i a') | |
813 | { | |
814 | if (!isset($this->data['updated'])) | |
815 | { | |
816 | if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'updated')) | |
817 | { | |
818 | $this->data['updated']['raw'] = $return[0]['data']; | |
819 | } | |
820 | ||
821 | if (!empty($this->data['updated']['raw'])) | |
822 | { | |
823 | $parser = $this->registry->call('Parse_Date', 'get'); | |
824 | $this->data['updated']['parsed'] = $parser->parse($this->data['date']['raw']); | |
825 | } | |
826 | else | |
827 | { | |
828 | $this->data['updated'] = null; | |
829 | } | |
830 | } | |
831 | if ($this->data['updated']) | |
832 | { | |
833 | $date_format = (string) $date_format; | |
834 | switch ($date_format) | |
835 | { | |
836 | case '': | |
837 | return $this->sanitize($this->data['updated']['raw'], SIMPLEPIE_CONSTRUCT_TEXT); | |
838 | ||
839 | case 'U': | |
840 | return $this->data['updated']['parsed']; | |
841 | ||
842 | default: | |
843 | return date($date_format, $this->data['updated']['parsed']); | |
844 | } | |
845 | } | |
846 | else | |
847 | { | |
848 | return null; | |
849 | } | |
850 | } | |
851 | ||
852 | /** | |
853 | * Get the localized posting date/time for the item | |
854 | * | |
855 | * Returns the date formatted in the localized language. To display in | |
856 | * languages other than the server's default, you need to change the locale | |
857 | * with {@link http://php.net/setlocale setlocale()}. The available | |
858 | * localizations depend on which ones are installed on your web server. | |
859 | * | |
860 | * @since 1.0 | |
861 | * | |
862 | * @param string $date_format Supports any PHP date format from {@see http://php.net/strftime} (empty for the raw data) | |
863 | * @return int|string|null | |
864 | */ | |
865 | public function get_local_date($date_format = '%c') | |
866 | { | |
867 | if (!$date_format) | |
868 | { | |
869 | return $this->sanitize($this->get_date(''), SIMPLEPIE_CONSTRUCT_TEXT); | |
870 | } | |
871 | elseif (($date = $this->get_date('U')) !== null && $date !== false) | |
872 | { | |
873 | return strftime($date_format, $date); | |
874 | } | |
875 | else | |
876 | { | |
877 | return null; | |
878 | } | |
879 | } | |
880 | ||
881 | /** | |
882 | * Get the posting date/time for the item (UTC time) | |
883 | * | |
884 | * @see get_date | |
885 | * @param string $date_format Supports any PHP date format from {@see http://php.net/date} | |
886 | * @return int|string|null | |
887 | */ | |
888 | public function get_gmdate($date_format = 'j F Y, g:i a') | |
889 | { | |
890 | $date = $this->get_date('U'); | |
891 | if ($date === null) | |
892 | { | |
893 | return null; | |
894 | } | |
895 | ||
896 | return gmdate($date_format, $date); | |
897 | } | |
898 | ||
899 | /** | |
900 | * Get the update date/time for the item (UTC time) | |
901 | * | |
902 | * @see get_updated_date | |
903 | * @param string $date_format Supports any PHP date format from {@see http://php.net/date} | |
904 | * @return int|string|null | |
905 | */ | |
906 | public function get_updated_gmdate($date_format = 'j F Y, g:i a') | |
907 | { | |
908 | $date = $this->get_updated_date('U'); | |
909 | if ($date === null) | |
910 | { | |
911 | return null; | |
912 | } | |
913 | ||
914 | return gmdate($date_format, $date); | |
915 | } | |
916 | ||
917 | /** | |
918 | * Get the permalink for the item | |
919 | * | |
920 | * Returns the first link available with a relationship of "alternate". | |
921 | * Identical to {@see get_link()} with key 0 | |
922 | * | |
923 | * @see get_link | |
924 | * @since 0.8 | |
925 | * @return string|null Permalink URL | |
926 | */ | |
927 | public function get_permalink() | |
928 | { | |
929 | $link = $this->get_link(); | |
930 | $enclosure = $this->get_enclosure(0); | |
931 | if ($link !== null) | |
932 | { | |
933 | return $link; | |
934 | } | |
935 | elseif ($enclosure !== null) | |
936 | { | |
937 | return $enclosure->get_link(); | |
938 | } | |
939 | else | |
940 | { | |
941 | return null; | |
942 | } | |
943 | } | |
944 | ||
945 | /** | |
946 | * Get a single link for the item | |
947 | * | |
948 | * @since Beta 3 | |
949 | * @param int $key The link that you want to return. Remember that arrays begin with 0, not 1 | |
950 | * @param string $rel The relationship of the link to return | |
951 | * @return string|null Link URL | |
952 | */ | |
953 | public function get_link($key = 0, $rel = 'alternate') | |
954 | { | |
955 | $links = $this->get_links($rel); | |
956 | if ($links[$key] !== null) | |
957 | { | |
958 | return $links[$key]; | |
959 | } | |
960 | else | |
961 | { | |
962 | return null; | |
963 | } | |
964 | } | |
965 | ||
966 | /** | |
967 | * Get all links for the item | |
968 | * | |
969 | * Uses `<atom:link>`, `<link>` or `<guid>` | |
970 | * | |
971 | * @since Beta 2 | |
972 | * @param string $rel The relationship of links to return | |
973 | * @return array|null Links found for the item (strings) | |
974 | */ | |
975 | public function get_links($rel = 'alternate') | |
976 | { | |
977 | if (!isset($this->data['links'])) | |
978 | { | |
979 | $this->data['links'] = array(); | |
980 | foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'link') as $link) | |
981 | { | |
982 | if (isset($link['attribs']['']['href'])) | |
983 | { | |
984 | $link_rel = (isset($link['attribs']['']['rel'])) ? $link['attribs']['']['rel'] : 'alternate'; | |
985 | $this->data['links'][$link_rel][] = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link)); | |
986 | ||
987 | } | |
988 | } | |
989 | foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'link') as $link) | |
990 | { | |
991 | if (isset($link['attribs']['']['href'])) | |
992 | { | |
993 | $link_rel = (isset($link['attribs']['']['rel'])) ? $link['attribs']['']['rel'] : 'alternate'; | |
994 | $this->data['links'][$link_rel][] = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link)); | |
995 | } | |
996 | } | |
997 | if ($links = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'link')) | |
998 | { | |
999 | $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0])); | |
1000 | } | |
1001 | if ($links = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'link')) | |
1002 | { | |
1003 | $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0])); | |
1004 | } | |
1005 | if ($links = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'link')) | |
1006 | { | |
1007 | $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0])); | |
1008 | } | |
1009 | if ($links = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'guid')) | |
1010 | { | |
1011 | if (!isset($links[0]['attribs']['']['isPermaLink']) || strtolower(trim($links[0]['attribs']['']['isPermaLink'])) === 'true') | |
1012 | { | |
1013 | $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0])); | |
1014 | } | |
1015 | } | |
1016 | ||
1017 | $keys = array_keys($this->data['links']); | |
1018 | foreach ($keys as $key) | |
1019 | { | |
1020 | if ($this->registry->call('Misc', 'is_isegment_nz_nc', array($key))) | |
1021 | { | |
1022 | if (isset($this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key])) | |
1023 | { | |
1024 | $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key] = array_merge($this->data['links'][$key], $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key]); | |
1025 | $this->data['links'][$key] =& $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key]; | |
1026 | } | |
1027 | else | |
1028 | { | |
1029 | $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key] =& $this->data['links'][$key]; | |
1030 | } | |
1031 | } | |
1032 | elseif (substr($key, 0, 41) === SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY) | |
1033 | { | |
1034 | $this->data['links'][substr($key, 41)] =& $this->data['links'][$key]; | |
1035 | } | |
1036 | $this->data['links'][$key] = array_unique($this->data['links'][$key]); | |
1037 | } | |
1038 | } | |
1039 | if (isset($this->data['links'][$rel])) | |
1040 | { | |
1041 | return $this->data['links'][$rel]; | |
1042 | } | |
1043 | else | |
1044 | { | |
1045 | return null; | |
1046 | } | |
1047 | } | |
1048 | ||
1049 | /** | |
1050 | * Get an enclosure from the item | |
1051 | * | |
1052 | * Supports the <enclosure> RSS tag, as well as Media RSS and iTunes RSS. | |
1053 | * | |
1054 | * @since Beta 2 | |
1055 | * @todo Add ability to prefer one type of content over another (in a media group). | |
1056 | * @param int $key The enclosure that you want to return. Remember that arrays begin with 0, not 1 | |
1057 | * @return SimplePie_Enclosure|null | |
1058 | */ | |
1059 | public function get_enclosure($key = 0, $prefer = null) | |
1060 | { | |
1061 | $enclosures = $this->get_enclosures(); | |
1062 | if (isset($enclosures[$key])) | |
1063 | { | |
1064 | return $enclosures[$key]; | |
1065 | } | |
1066 | else | |
1067 | { | |
1068 | return null; | |
1069 | } | |
1070 | } | |
1071 | ||
1072 | /** | |
1073 | * Get all available enclosures (podcasts, etc.) | |
1074 | * | |
1075 | * Supports the <enclosure> RSS tag, as well as Media RSS and iTunes RSS. | |
1076 | * | |
1077 | * At this point, we're pretty much assuming that all enclosures for an item | |
1078 | * are the same content. Anything else is too complicated to | |
1079 | * properly support. | |
1080 | * | |
1081 | * @since Beta 2 | |
1082 | * @todo Add support for end-user defined sorting of enclosures by type/handler (so we can prefer the faster-loading FLV over MP4). | |
1083 | * @todo If an element exists at a level, but it's value is empty, we should fall back to the value from the parent (if it exists). | |
1084 | * @return array|null List of SimplePie_Enclosure items | |
1085 | */ | |
1086 | public function get_enclosures() | |
1087 | { | |
1088 | if (!isset($this->data['enclosures'])) | |
1089 | { | |
1090 | $this->data['enclosures'] = array(); | |
1091 | ||
1092 | // Elements | |
1093 | $captions_parent = null; | |
1094 | $categories_parent = null; | |
1095 | $copyrights_parent = null; | |
1096 | $credits_parent = null; | |
1097 | $description_parent = null; | |
1098 | $duration_parent = null; | |
1099 | $hashes_parent = null; | |
1100 | $keywords_parent = null; | |
1101 | $player_parent = null; | |
1102 | $ratings_parent = null; | |
1103 | $restrictions_parent = null; | |
1104 | $thumbnails_parent = null; | |
1105 | $title_parent = null; | |
1106 | ||
1107 | // Let's do the channel and item-level ones first, and just re-use them if we need to. | |
1108 | $parent = $this->get_feed(); | |
1109 | ||
1110 | // CAPTIONS | |
1111 | if ($captions = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'text')) | |
1112 | { | |
1113 | foreach ($captions as $caption) | |
1114 | { | |
1115 | $caption_type = null; | |
1116 | $caption_lang = null; | |
1117 | $caption_startTime = null; | |
1118 | $caption_endTime = null; | |
1119 | $caption_text = null; | |
1120 | if (isset($caption['attribs']['']['type'])) | |
1121 | { | |
1122 | $caption_type = $this->sanitize($caption['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1123 | } | |
1124 | if (isset($caption['attribs']['']['lang'])) | |
1125 | { | |
1126 | $caption_lang = $this->sanitize($caption['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1127 | } | |
1128 | if (isset($caption['attribs']['']['start'])) | |
1129 | { | |
1130 | $caption_startTime = $this->sanitize($caption['attribs']['']['start'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1131 | } | |
1132 | if (isset($caption['attribs']['']['end'])) | |
1133 | { | |
1134 | $caption_endTime = $this->sanitize($caption['attribs']['']['end'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1135 | } | |
1136 | if (isset($caption['data'])) | |
1137 | { | |
1138 | $caption_text = $this->sanitize($caption['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1139 | } | |
1140 | $captions_parent[] = $this->registry->create('Caption', array($caption_type, $caption_lang, $caption_startTime, $caption_endTime, $caption_text)); | |
1141 | } | |
1142 | } | |
1143 | elseif ($captions = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'text')) | |
1144 | { | |
1145 | foreach ($captions as $caption) | |
1146 | { | |
1147 | $caption_type = null; | |
1148 | $caption_lang = null; | |
1149 | $caption_startTime = null; | |
1150 | $caption_endTime = null; | |
1151 | $caption_text = null; | |
1152 | if (isset($caption['attribs']['']['type'])) | |
1153 | { | |
1154 | $caption_type = $this->sanitize($caption['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1155 | } | |
1156 | if (isset($caption['attribs']['']['lang'])) | |
1157 | { | |
1158 | $caption_lang = $this->sanitize($caption['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1159 | } | |
1160 | if (isset($caption['attribs']['']['start'])) | |
1161 | { | |
1162 | $caption_startTime = $this->sanitize($caption['attribs']['']['start'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1163 | } | |
1164 | if (isset($caption['attribs']['']['end'])) | |
1165 | { | |
1166 | $caption_endTime = $this->sanitize($caption['attribs']['']['end'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1167 | } | |
1168 | if (isset($caption['data'])) | |
1169 | { | |
1170 | $caption_text = $this->sanitize($caption['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1171 | } | |
1172 | $captions_parent[] = $this->registry->create('Caption', array($caption_type, $caption_lang, $caption_startTime, $caption_endTime, $caption_text)); | |
1173 | } | |
1174 | } | |
1175 | if (is_array($captions_parent)) | |
1176 | { | |
1177 | $captions_parent = array_values(array_unique($captions_parent)); | |
1178 | } | |
1179 | ||
1180 | // CATEGORIES | |
1181 | foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'category') as $category) | |
1182 | { | |
1183 | $term = null; | |
1184 | $scheme = null; | |
1185 | $label = null; | |
1186 | if (isset($category['data'])) | |
1187 | { | |
1188 | $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1189 | } | |
1190 | if (isset($category['attribs']['']['scheme'])) | |
1191 | { | |
1192 | $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1193 | } | |
1194 | else | |
1195 | { | |
1196 | $scheme = 'http://search.yahoo.com/mrss/category_schema'; | |
1197 | } | |
1198 | if (isset($category['attribs']['']['label'])) | |
1199 | { | |
1200 | $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1201 | } | |
1202 | $categories_parent[] = $this->registry->create('Category', array($term, $scheme, $label)); | |
1203 | } | |
1204 | foreach ((array) $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'category') as $category) | |
1205 | { | |
1206 | $term = null; | |
1207 | $scheme = null; | |
1208 | $label = null; | |
1209 | if (isset($category['data'])) | |
1210 | { | |
1211 | $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1212 | } | |
1213 | if (isset($category['attribs']['']['scheme'])) | |
1214 | { | |
1215 | $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1216 | } | |
1217 | else | |
1218 | { | |
1219 | $scheme = 'http://search.yahoo.com/mrss/category_schema'; | |
1220 | } | |
1221 | if (isset($category['attribs']['']['label'])) | |
1222 | { | |
1223 | $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1224 | } | |
1225 | $categories_parent[] = $this->registry->create('Category', array($term, $scheme, $label)); | |
1226 | } | |
1227 | foreach ((array) $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'category') as $category) | |
1228 | { | |
1229 | $term = null; | |
1230 | $scheme = 'http://www.itunes.com/dtds/podcast-1.0.dtd'; | |
1231 | $label = null; | |
1232 | if (isset($category['attribs']['']['text'])) | |
1233 | { | |
1234 | $label = $this->sanitize($category['attribs']['']['text'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1235 | } | |
1236 | $categories_parent[] = $this->registry->create('Category', array($term, $scheme, $label)); | |
1237 | ||
1238 | if (isset($category['child'][SIMPLEPIE_NAMESPACE_ITUNES]['category'])) | |
1239 | { | |
1240 | foreach ((array) $category['child'][SIMPLEPIE_NAMESPACE_ITUNES]['category'] as $subcategory) | |
1241 | { | |
1242 | if (isset($subcategory['attribs']['']['text'])) | |
1243 | { | |
1244 | $label = $this->sanitize($subcategory['attribs']['']['text'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1245 | } | |
1246 | $categories_parent[] = $this->registry->create('Category', array($term, $scheme, $label)); | |
1247 | } | |
1248 | } | |
1249 | } | |
1250 | if (is_array($categories_parent)) | |
1251 | { | |
1252 | $categories_parent = array_values(array_unique($categories_parent)); | |
1253 | } | |
1254 | ||
1255 | // COPYRIGHT | |
1256 | if ($copyright = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'copyright')) | |
1257 | { | |
1258 | $copyright_url = null; | |
1259 | $copyright_label = null; | |
1260 | if (isset($copyright[0]['attribs']['']['url'])) | |
1261 | { | |
1262 | $copyright_url = $this->sanitize($copyright[0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1263 | } | |
1264 | if (isset($copyright[0]['data'])) | |
1265 | { | |
1266 | $copyright_label = $this->sanitize($copyright[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1267 | } | |
1268 | $copyrights_parent = $this->registry->create('Copyright', array($copyright_url, $copyright_label)); | |
1269 | } | |
1270 | elseif ($copyright = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'copyright')) | |
1271 | { | |
1272 | $copyright_url = null; | |
1273 | $copyright_label = null; | |
1274 | if (isset($copyright[0]['attribs']['']['url'])) | |
1275 | { | |
1276 | $copyright_url = $this->sanitize($copyright[0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1277 | } | |
1278 | if (isset($copyright[0]['data'])) | |
1279 | { | |
1280 | $copyright_label = $this->sanitize($copyright[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1281 | } | |
1282 | $copyrights_parent = $this->registry->create('Copyright', array($copyright_url, $copyright_label)); | |
1283 | } | |
1284 | ||
1285 | // CREDITS | |
1286 | if ($credits = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'credit')) | |
1287 | { | |
1288 | foreach ($credits as $credit) | |
1289 | { | |
1290 | $credit_role = null; | |
1291 | $credit_scheme = null; | |
1292 | $credit_name = null; | |
1293 | if (isset($credit['attribs']['']['role'])) | |
1294 | { | |
1295 | $credit_role = $this->sanitize($credit['attribs']['']['role'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1296 | } | |
1297 | if (isset($credit['attribs']['']['scheme'])) | |
1298 | { | |
1299 | $credit_scheme = $this->sanitize($credit['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1300 | } | |
1301 | else | |
1302 | { | |
1303 | $credit_scheme = 'urn:ebu'; | |
1304 | } | |
1305 | if (isset($credit['data'])) | |
1306 | { | |
1307 | $credit_name = $this->sanitize($credit['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1308 | } | |
1309 | $credits_parent[] = $this->registry->create('Credit', array($credit_role, $credit_scheme, $credit_name)); | |
1310 | } | |
1311 | } | |
1312 | elseif ($credits = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'credit')) | |
1313 | { | |
1314 | foreach ($credits as $credit) | |
1315 | { | |
1316 | $credit_role = null; | |
1317 | $credit_scheme = null; | |
1318 | $credit_name = null; | |
1319 | if (isset($credit['attribs']['']['role'])) | |
1320 | { | |
1321 | $credit_role = $this->sanitize($credit['attribs']['']['role'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1322 | } | |
1323 | if (isset($credit['attribs']['']['scheme'])) | |
1324 | { | |
1325 | $credit_scheme = $this->sanitize($credit['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1326 | } | |
1327 | else | |
1328 | { | |
1329 | $credit_scheme = 'urn:ebu'; | |
1330 | } | |
1331 | if (isset($credit['data'])) | |
1332 | { | |
1333 | $credit_name = $this->sanitize($credit['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1334 | } | |
1335 | $credits_parent[] = $this->registry->create('Credit', array($credit_role, $credit_scheme, $credit_name)); | |
1336 | } | |
1337 | } | |
1338 | if (is_array($credits_parent)) | |
1339 | { | |
1340 | $credits_parent = array_values(array_unique($credits_parent)); | |
1341 | } | |
1342 | ||
1343 | // DESCRIPTION | |
1344 | if ($description_parent = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'description')) | |
1345 | { | |
1346 | if (isset($description_parent[0]['data'])) | |
1347 | { | |
1348 | $description_parent = $this->sanitize($description_parent[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1349 | } | |
1350 | } | |
1351 | elseif ($description_parent = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'description')) | |
1352 | { | |
1353 | if (isset($description_parent[0]['data'])) | |
1354 | { | |
1355 | $description_parent = $this->sanitize($description_parent[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1356 | } | |
1357 | } | |
1358 | ||
1359 | // DURATION | |
1360 | if ($duration_parent = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'duration')) | |
1361 | { | |
1362 | $seconds = null; | |
1363 | $minutes = null; | |
1364 | $hours = null; | |
1365 | if (isset($duration_parent[0]['data'])) | |
1366 | { | |
1367 | $temp = explode(':', $this->sanitize($duration_parent[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT)); | |
1368 | if (sizeof($temp) > 0) | |
1369 | { | |
1370 | $seconds = (int) array_pop($temp); | |
1371 | } | |
1372 | if (sizeof($temp) > 0) | |
1373 | { | |
1374 | $minutes = (int) array_pop($temp); | |
1375 | $seconds += $minutes * 60; | |
1376 | } | |
1377 | if (sizeof($temp) > 0) | |
1378 | { | |
1379 | $hours = (int) array_pop($temp); | |
1380 | $seconds += $hours * 3600; | |
1381 | } | |
1382 | unset($temp); | |
1383 | $duration_parent = $seconds; | |
1384 | } | |
1385 | } | |
1386 | ||
1387 | // HASHES | |
1388 | if ($hashes_iterator = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'hash')) | |
1389 | { | |
1390 | foreach ($hashes_iterator as $hash) | |
1391 | { | |
1392 | $value = null; | |
1393 | $algo = null; | |
1394 | if (isset($hash['data'])) | |
1395 | { | |
1396 | $value = $this->sanitize($hash['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1397 | } | |
1398 | if (isset($hash['attribs']['']['algo'])) | |
1399 | { | |
1400 | $algo = $this->sanitize($hash['attribs']['']['algo'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1401 | } | |
1402 | else | |
1403 | { | |
1404 | $algo = 'md5'; | |
1405 | } | |
1406 | $hashes_parent[] = $algo.':'.$value; | |
1407 | } | |
1408 | } | |
1409 | elseif ($hashes_iterator = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'hash')) | |
1410 | { | |
1411 | foreach ($hashes_iterator as $hash) | |
1412 | { | |
1413 | $value = null; | |
1414 | $algo = null; | |
1415 | if (isset($hash['data'])) | |
1416 | { | |
1417 | $value = $this->sanitize($hash['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1418 | } | |
1419 | if (isset($hash['attribs']['']['algo'])) | |
1420 | { | |
1421 | $algo = $this->sanitize($hash['attribs']['']['algo'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1422 | } | |
1423 | else | |
1424 | { | |
1425 | $algo = 'md5'; | |
1426 | } | |
1427 | $hashes_parent[] = $algo.':'.$value; | |
1428 | } | |
1429 | } | |
1430 | if (is_array($hashes_parent)) | |
1431 | { | |
1432 | $hashes_parent = array_values(array_unique($hashes_parent)); | |
1433 | } | |
1434 | ||
1435 | // KEYWORDS | |
1436 | if ($keywords = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'keywords')) | |
1437 | { | |
1438 | if (isset($keywords[0]['data'])) | |
1439 | { | |
1440 | $temp = explode(',', $this->sanitize($keywords[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT)); | |
1441 | foreach ($temp as $word) | |
1442 | { | |
1443 | $keywords_parent[] = trim($word); | |
1444 | } | |
1445 | } | |
1446 | unset($temp); | |
1447 | } | |
1448 | elseif ($keywords = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'keywords')) | |
1449 | { | |
1450 | if (isset($keywords[0]['data'])) | |
1451 | { | |
1452 | $temp = explode(',', $this->sanitize($keywords[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT)); | |
1453 | foreach ($temp as $word) | |
1454 | { | |
1455 | $keywords_parent[] = trim($word); | |
1456 | } | |
1457 | } | |
1458 | unset($temp); | |
1459 | } | |
1460 | elseif ($keywords = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'keywords')) | |
1461 | { | |
1462 | if (isset($keywords[0]['data'])) | |
1463 | { | |
1464 | $temp = explode(',', $this->sanitize($keywords[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT)); | |
1465 | foreach ($temp as $word) | |
1466 | { | |
1467 | $keywords_parent[] = trim($word); | |
1468 | } | |
1469 | } | |
1470 | unset($temp); | |
1471 | } | |
1472 | elseif ($keywords = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'keywords')) | |
1473 | { | |
1474 | if (isset($keywords[0]['data'])) | |
1475 | { | |
1476 | $temp = explode(',', $this->sanitize($keywords[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT)); | |
1477 | foreach ($temp as $word) | |
1478 | { | |
1479 | $keywords_parent[] = trim($word); | |
1480 | } | |
1481 | } | |
1482 | unset($temp); | |
1483 | } | |
1484 | if (is_array($keywords_parent)) | |
1485 | { | |
1486 | $keywords_parent = array_values(array_unique($keywords_parent)); | |
1487 | } | |
1488 | ||
1489 | // PLAYER | |
1490 | if ($player_parent = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'player')) | |
1491 | { | |
1492 | if (isset($player_parent[0]['attribs']['']['url'])) | |
1493 | { | |
1494 | $player_parent = $this->sanitize($player_parent[0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI); | |
1495 | } | |
1496 | } | |
1497 | elseif ($player_parent = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'player')) | |
1498 | { | |
1499 | if (isset($player_parent[0]['attribs']['']['url'])) | |
1500 | { | |
1501 | $player_parent = $this->sanitize($player_parent[0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI); | |
1502 | } | |
1503 | } | |
1504 | ||
1505 | // RATINGS | |
1506 | if ($ratings = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'rating')) | |
1507 | { | |
1508 | foreach ($ratings as $rating) | |
1509 | { | |
1510 | $rating_scheme = null; | |
1511 | $rating_value = null; | |
1512 | if (isset($rating['attribs']['']['scheme'])) | |
1513 | { | |
1514 | $rating_scheme = $this->sanitize($rating['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1515 | } | |
1516 | else | |
1517 | { | |
1518 | $rating_scheme = 'urn:simple'; | |
1519 | } | |
1520 | if (isset($rating['data'])) | |
1521 | { | |
1522 | $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1523 | } | |
1524 | $ratings_parent[] = $this->registry->create('Rating', array($rating_scheme, $rating_value)); | |
1525 | } | |
1526 | } | |
1527 | elseif ($ratings = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'explicit')) | |
1528 | { | |
1529 | foreach ($ratings as $rating) | |
1530 | { | |
1531 | $rating_scheme = 'urn:itunes'; | |
1532 | $rating_value = null; | |
1533 | if (isset($rating['data'])) | |
1534 | { | |
1535 | $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1536 | } | |
1537 | $ratings_parent[] = $this->registry->create('Rating', array($rating_scheme, $rating_value)); | |
1538 | } | |
1539 | } | |
1540 | elseif ($ratings = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'rating')) | |
1541 | { | |
1542 | foreach ($ratings as $rating) | |
1543 | { | |
1544 | $rating_scheme = null; | |
1545 | $rating_value = null; | |
1546 | if (isset($rating['attribs']['']['scheme'])) | |
1547 | { | |
1548 | $rating_scheme = $this->sanitize($rating['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1549 | } | |
1550 | else | |
1551 | { | |
1552 | $rating_scheme = 'urn:simple'; | |
1553 | } | |
1554 | if (isset($rating['data'])) | |
1555 | { | |
1556 | $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1557 | } | |
1558 | $ratings_parent[] = $this->registry->create('Rating', array($rating_scheme, $rating_value)); | |
1559 | } | |
1560 | } | |
1561 | elseif ($ratings = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'explicit')) | |
1562 | { | |
1563 | foreach ($ratings as $rating) | |
1564 | { | |
1565 | $rating_scheme = 'urn:itunes'; | |
1566 | $rating_value = null; | |
1567 | if (isset($rating['data'])) | |
1568 | { | |
1569 | $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1570 | } | |
1571 | $ratings_parent[] = $this->registry->create('Rating', array($rating_scheme, $rating_value)); | |
1572 | } | |
1573 | } | |
1574 | if (is_array($ratings_parent)) | |
1575 | { | |
1576 | $ratings_parent = array_values(array_unique($ratings_parent)); | |
1577 | } | |
1578 | ||
1579 | // RESTRICTIONS | |
1580 | if ($restrictions = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'restriction')) | |
1581 | { | |
1582 | foreach ($restrictions as $restriction) | |
1583 | { | |
1584 | $restriction_relationship = null; | |
1585 | $restriction_type = null; | |
1586 | $restriction_value = null; | |
1587 | if (isset($restriction['attribs']['']['relationship'])) | |
1588 | { | |
1589 | $restriction_relationship = $this->sanitize($restriction['attribs']['']['relationship'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1590 | } | |
1591 | if (isset($restriction['attribs']['']['type'])) | |
1592 | { | |
1593 | $restriction_type = $this->sanitize($restriction['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1594 | } | |
1595 | if (isset($restriction['data'])) | |
1596 | { | |
1597 | $restriction_value = $this->sanitize($restriction['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1598 | } | |
1599 | $restrictions_parent[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value)); | |
1600 | } | |
1601 | } | |
1602 | elseif ($restrictions = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'block')) | |
1603 | { | |
1604 | foreach ($restrictions as $restriction) | |
1605 | { | |
1606 | $restriction_relationship = 'allow'; | |
1607 | $restriction_type = null; | |
1608 | $restriction_value = 'itunes'; | |
1609 | if (isset($restriction['data']) && strtolower($restriction['data']) === 'yes') | |
1610 | { | |
1611 | $restriction_relationship = 'deny'; | |
1612 | } | |
1613 | $restrictions_parent[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value)); | |
1614 | } | |
1615 | } | |
1616 | elseif ($restrictions = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'restriction')) | |
1617 | { | |
1618 | foreach ($restrictions as $restriction) | |
1619 | { | |
1620 | $restriction_relationship = null; | |
1621 | $restriction_type = null; | |
1622 | $restriction_value = null; | |
1623 | if (isset($restriction['attribs']['']['relationship'])) | |
1624 | { | |
1625 | $restriction_relationship = $this->sanitize($restriction['attribs']['']['relationship'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1626 | } | |
1627 | if (isset($restriction['attribs']['']['type'])) | |
1628 | { | |
1629 | $restriction_type = $this->sanitize($restriction['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1630 | } | |
1631 | if (isset($restriction['data'])) | |
1632 | { | |
1633 | $restriction_value = $this->sanitize($restriction['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1634 | } | |
1635 | $restrictions_parent[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value)); | |
1636 | } | |
1637 | } | |
1638 | elseif ($restrictions = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'block')) | |
1639 | { | |
1640 | foreach ($restrictions as $restriction) | |
1641 | { | |
1642 | $restriction_relationship = 'allow'; | |
1643 | $restriction_type = null; | |
1644 | $restriction_value = 'itunes'; | |
1645 | if (isset($restriction['data']) && strtolower($restriction['data']) === 'yes') | |
1646 | { | |
1647 | $restriction_relationship = 'deny'; | |
1648 | } | |
1649 | $restrictions_parent[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value)); | |
1650 | } | |
1651 | } | |
1652 | if (is_array($restrictions_parent)) | |
1653 | { | |
1654 | $restrictions_parent = array_values(array_unique($restrictions_parent)); | |
1655 | } | |
1656 | else | |
1657 | { | |
1658 | $restrictions_parent = array(new SimplePie_Restriction('allow', null, 'default')); | |
1659 | } | |
1660 | ||
1661 | // THUMBNAILS | |
1662 | if ($thumbnails = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'thumbnail')) | |
1663 | { | |
1664 | foreach ($thumbnails as $thumbnail) | |
1665 | { | |
1666 | if (isset($thumbnail['attribs']['']['url'])) | |
1667 | { | |
1668 | $thumbnails_parent[] = $this->sanitize($thumbnail['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI); | |
1669 | } | |
1670 | } | |
1671 | } | |
1672 | elseif ($thumbnails = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'thumbnail')) | |
1673 | { | |
1674 | foreach ($thumbnails as $thumbnail) | |
1675 | { | |
1676 | if (isset($thumbnail['attribs']['']['url'])) | |
1677 | { | |
1678 | $thumbnails_parent[] = $this->sanitize($thumbnail['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI); | |
1679 | } | |
1680 | } | |
1681 | } | |
1682 | ||
1683 | // TITLES | |
1684 | if ($title_parent = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'title')) | |
1685 | { | |
1686 | if (isset($title_parent[0]['data'])) | |
1687 | { | |
1688 | $title_parent = $this->sanitize($title_parent[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1689 | } | |
1690 | } | |
1691 | elseif ($title_parent = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'title')) | |
1692 | { | |
1693 | if (isset($title_parent[0]['data'])) | |
1694 | { | |
1695 | $title_parent = $this->sanitize($title_parent[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1696 | } | |
1697 | } | |
1698 | ||
1699 | // Clear the memory | |
1700 | unset($parent); | |
1701 | ||
1702 | // Attributes | |
1703 | $bitrate = null; | |
1704 | $channels = null; | |
1705 | $duration = null; | |
1706 | $expression = null; | |
1707 | $framerate = null; | |
1708 | $height = null; | |
1709 | $javascript = null; | |
1710 | $lang = null; | |
1711 | $length = null; | |
1712 | $medium = null; | |
1713 | $samplingrate = null; | |
1714 | $type = null; | |
1715 | $url = null; | |
1716 | $width = null; | |
1717 | ||
1718 | // Elements | |
1719 | $captions = null; | |
1720 | $categories = null; | |
1721 | $copyrights = null; | |
1722 | $credits = null; | |
1723 | $description = null; | |
1724 | $hashes = null; | |
1725 | $keywords = null; | |
1726 | $player = null; | |
1727 | $ratings = null; | |
1728 | $restrictions = null; | |
1729 | $thumbnails = null; | |
1730 | $title = null; | |
1731 | ||
1732 | // If we have media:group tags, loop through them. | |
1733 | foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'group') as $group) | |
1734 | { | |
1735 | if(isset($group['child']) && isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['content'])) | |
1736 | { | |
1737 | // If we have media:content tags, loop through them. | |
1738 | foreach ((array) $group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['content'] as $content) | |
1739 | { | |
1740 | if (isset($content['attribs']['']['url'])) | |
1741 | { | |
1742 | // Attributes | |
1743 | $bitrate = null; | |
1744 | $channels = null; | |
1745 | $duration = null; | |
1746 | $expression = null; | |
1747 | $framerate = null; | |
1748 | $height = null; | |
1749 | $javascript = null; | |
1750 | $lang = null; | |
1751 | $length = null; | |
1752 | $medium = null; | |
1753 | $samplingrate = null; | |
1754 | $type = null; | |
1755 | $url = null; | |
1756 | $width = null; | |
1757 | ||
1758 | // Elements | |
1759 | $captions = null; | |
1760 | $categories = null; | |
1761 | $copyrights = null; | |
1762 | $credits = null; | |
1763 | $description = null; | |
1764 | $hashes = null; | |
1765 | $keywords = null; | |
1766 | $player = null; | |
1767 | $ratings = null; | |
1768 | $restrictions = null; | |
1769 | $thumbnails = null; | |
1770 | $title = null; | |
1771 | ||
1772 | // Start checking the attributes of media:content | |
1773 | if (isset($content['attribs']['']['bitrate'])) | |
1774 | { | |
1775 | $bitrate = $this->sanitize($content['attribs']['']['bitrate'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1776 | } | |
1777 | if (isset($content['attribs']['']['channels'])) | |
1778 | { | |
1779 | $channels = $this->sanitize($content['attribs']['']['channels'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1780 | } | |
1781 | if (isset($content['attribs']['']['duration'])) | |
1782 | { | |
1783 | $duration = $this->sanitize($content['attribs']['']['duration'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1784 | } | |
1785 | else | |
1786 | { | |
1787 | $duration = $duration_parent; | |
1788 | } | |
1789 | if (isset($content['attribs']['']['expression'])) | |
1790 | { | |
1791 | $expression = $this->sanitize($content['attribs']['']['expression'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1792 | } | |
1793 | if (isset($content['attribs']['']['framerate'])) | |
1794 | { | |
1795 | $framerate = $this->sanitize($content['attribs']['']['framerate'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1796 | } | |
1797 | if (isset($content['attribs']['']['height'])) | |
1798 | { | |
1799 | $height = $this->sanitize($content['attribs']['']['height'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1800 | } | |
1801 | if (isset($content['attribs']['']['lang'])) | |
1802 | { | |
1803 | $lang = $this->sanitize($content['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1804 | } | |
1805 | if (isset($content['attribs']['']['fileSize'])) | |
1806 | { | |
1807 | $length = ceil($content['attribs']['']['fileSize']); | |
1808 | } | |
1809 | if (isset($content['attribs']['']['medium'])) | |
1810 | { | |
1811 | $medium = $this->sanitize($content['attribs']['']['medium'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1812 | } | |
1813 | if (isset($content['attribs']['']['samplingrate'])) | |
1814 | { | |
1815 | $samplingrate = $this->sanitize($content['attribs']['']['samplingrate'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1816 | } | |
1817 | if (isset($content['attribs']['']['type'])) | |
1818 | { | |
1819 | $type = $this->sanitize($content['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1820 | } | |
1821 | if (isset($content['attribs']['']['width'])) | |
1822 | { | |
1823 | $width = $this->sanitize($content['attribs']['']['width'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1824 | } | |
1825 | $url = $this->sanitize($content['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI); | |
1826 | ||
1827 | // Checking the other optional media: elements. Priority: media:content, media:group, item, channel | |
1828 | ||
1829 | // CAPTIONS | |
1830 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text'])) | |
1831 | { | |
1832 | foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text'] as $caption) | |
1833 | { | |
1834 | $caption_type = null; | |
1835 | $caption_lang = null; | |
1836 | $caption_startTime = null; | |
1837 | $caption_endTime = null; | |
1838 | $caption_text = null; | |
1839 | if (isset($caption['attribs']['']['type'])) | |
1840 | { | |
1841 | $caption_type = $this->sanitize($caption['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1842 | } | |
1843 | if (isset($caption['attribs']['']['lang'])) | |
1844 | { | |
1845 | $caption_lang = $this->sanitize($caption['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1846 | } | |
1847 | if (isset($caption['attribs']['']['start'])) | |
1848 | { | |
1849 | $caption_startTime = $this->sanitize($caption['attribs']['']['start'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1850 | } | |
1851 | if (isset($caption['attribs']['']['end'])) | |
1852 | { | |
1853 | $caption_endTime = $this->sanitize($caption['attribs']['']['end'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1854 | } | |
1855 | if (isset($caption['data'])) | |
1856 | { | |
1857 | $caption_text = $this->sanitize($caption['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1858 | } | |
1859 | $captions[] = $this->registry->create('Caption', array($caption_type, $caption_lang, $caption_startTime, $caption_endTime, $caption_text)); | |
1860 | } | |
1861 | if (is_array($captions)) | |
1862 | { | |
1863 | $captions = array_values(array_unique($captions)); | |
1864 | } | |
1865 | } | |
1866 | elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text'])) | |
1867 | { | |
1868 | foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text'] as $caption) | |
1869 | { | |
1870 | $caption_type = null; | |
1871 | $caption_lang = null; | |
1872 | $caption_startTime = null; | |
1873 | $caption_endTime = null; | |
1874 | $caption_text = null; | |
1875 | if (isset($caption['attribs']['']['type'])) | |
1876 | { | |
1877 | $caption_type = $this->sanitize($caption['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1878 | } | |
1879 | if (isset($caption['attribs']['']['lang'])) | |
1880 | { | |
1881 | $caption_lang = $this->sanitize($caption['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1882 | } | |
1883 | if (isset($caption['attribs']['']['start'])) | |
1884 | { | |
1885 | $caption_startTime = $this->sanitize($caption['attribs']['']['start'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1886 | } | |
1887 | if (isset($caption['attribs']['']['end'])) | |
1888 | { | |
1889 | $caption_endTime = $this->sanitize($caption['attribs']['']['end'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1890 | } | |
1891 | if (isset($caption['data'])) | |
1892 | { | |
1893 | $caption_text = $this->sanitize($caption['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1894 | } | |
1895 | $captions[] = $this->registry->create('Caption', array($caption_type, $caption_lang, $caption_startTime, $caption_endTime, $caption_text)); | |
1896 | } | |
1897 | if (is_array($captions)) | |
1898 | { | |
1899 | $captions = array_values(array_unique($captions)); | |
1900 | } | |
1901 | } | |
1902 | else | |
1903 | { | |
1904 | $captions = $captions_parent; | |
1905 | } | |
1906 | ||
1907 | // CATEGORIES | |
1908 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category'])) | |
1909 | { | |
1910 | foreach ((array) $content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category'] as $category) | |
1911 | { | |
1912 | $term = null; | |
1913 | $scheme = null; | |
1914 | $label = null; | |
1915 | if (isset($category['data'])) | |
1916 | { | |
1917 | $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1918 | } | |
1919 | if (isset($category['attribs']['']['scheme'])) | |
1920 | { | |
1921 | $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1922 | } | |
1923 | else | |
1924 | { | |
1925 | $scheme = 'http://search.yahoo.com/mrss/category_schema'; | |
1926 | } | |
1927 | if (isset($category['attribs']['']['label'])) | |
1928 | { | |
1929 | $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1930 | } | |
1931 | $categories[] = $this->registry->create('Category', array($term, $scheme, $label)); | |
1932 | } | |
1933 | } | |
1934 | if (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category'])) | |
1935 | { | |
1936 | foreach ((array) $group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category'] as $category) | |
1937 | { | |
1938 | $term = null; | |
1939 | $scheme = null; | |
1940 | $label = null; | |
1941 | if (isset($category['data'])) | |
1942 | { | |
1943 | $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1944 | } | |
1945 | if (isset($category['attribs']['']['scheme'])) | |
1946 | { | |
1947 | $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1948 | } | |
1949 | else | |
1950 | { | |
1951 | $scheme = 'http://search.yahoo.com/mrss/category_schema'; | |
1952 | } | |
1953 | if (isset($category['attribs']['']['label'])) | |
1954 | { | |
1955 | $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1956 | } | |
1957 | $categories[] = $this->registry->create('Category', array($term, $scheme, $label)); | |
1958 | } | |
1959 | } | |
1960 | if (is_array($categories) && is_array($categories_parent)) | |
1961 | { | |
1962 | $categories = array_values(array_unique(array_merge($categories, $categories_parent))); | |
1963 | } | |
1964 | elseif (is_array($categories)) | |
1965 | { | |
1966 | $categories = array_values(array_unique($categories)); | |
1967 | } | |
1968 | elseif (is_array($categories_parent)) | |
1969 | { | |
1970 | $categories = array_values(array_unique($categories_parent)); | |
1971 | } | |
1972 | ||
1973 | // COPYRIGHTS | |
1974 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'])) | |
1975 | { | |
1976 | $copyright_url = null; | |
1977 | $copyright_label = null; | |
1978 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url'])) | |
1979 | { | |
1980 | $copyright_url = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1981 | } | |
1982 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data'])) | |
1983 | { | |
1984 | $copyright_label = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1985 | } | |
1986 | $copyrights = $this->registry->create('Copyright', array($copyright_url, $copyright_label)); | |
1987 | } | |
1988 | elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'])) | |
1989 | { | |
1990 | $copyright_url = null; | |
1991 | $copyright_label = null; | |
1992 | if (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url'])) | |
1993 | { | |
1994 | $copyright_url = $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1995 | } | |
1996 | if (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data'])) | |
1997 | { | |
1998 | $copyright_label = $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
1999 | } | |
2000 | $copyrights = $this->registry->create('Copyright', array($copyright_url, $copyright_label)); | |
2001 | } | |
2002 | else | |
2003 | { | |
2004 | $copyrights = $copyrights_parent; | |
2005 | } | |
2006 | ||
2007 | // CREDITS | |
2008 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit'])) | |
2009 | { | |
2010 | foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit'] as $credit) | |
2011 | { | |
2012 | $credit_role = null; | |
2013 | $credit_scheme = null; | |
2014 | $credit_name = null; | |
2015 | if (isset($credit['attribs']['']['role'])) | |
2016 | { | |
2017 | $credit_role = $this->sanitize($credit['attribs']['']['role'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2018 | } | |
2019 | if (isset($credit['attribs']['']['scheme'])) | |
2020 | { | |
2021 | $credit_scheme = $this->sanitize($credit['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2022 | } | |
2023 | else | |
2024 | { | |
2025 | $credit_scheme = 'urn:ebu'; | |
2026 | } | |
2027 | if (isset($credit['data'])) | |
2028 | { | |
2029 | $credit_name = $this->sanitize($credit['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2030 | } | |
2031 | $credits[] = $this->registry->create('Credit', array($credit_role, $credit_scheme, $credit_name)); | |
2032 | } | |
2033 | if (is_array($credits)) | |
2034 | { | |
2035 | $credits = array_values(array_unique($credits)); | |
2036 | } | |
2037 | } | |
2038 | elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit'])) | |
2039 | { | |
2040 | foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit'] as $credit) | |
2041 | { | |
2042 | $credit_role = null; | |
2043 | $credit_scheme = null; | |
2044 | $credit_name = null; | |
2045 | if (isset($credit['attribs']['']['role'])) | |
2046 | { | |
2047 | $credit_role = $this->sanitize($credit['attribs']['']['role'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2048 | } | |
2049 | if (isset($credit['attribs']['']['scheme'])) | |
2050 | { | |
2051 | $credit_scheme = $this->sanitize($credit['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2052 | } | |
2053 | else | |
2054 | { | |
2055 | $credit_scheme = 'urn:ebu'; | |
2056 | } | |
2057 | if (isset($credit['data'])) | |
2058 | { | |
2059 | $credit_name = $this->sanitize($credit['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2060 | } | |
2061 | $credits[] = $this->registry->create('Credit', array($credit_role, $credit_scheme, $credit_name)); | |
2062 | } | |
2063 | if (is_array($credits)) | |
2064 | { | |
2065 | $credits = array_values(array_unique($credits)); | |
2066 | } | |
2067 | } | |
2068 | else | |
2069 | { | |
2070 | $credits = $credits_parent; | |
2071 | } | |
2072 | ||
2073 | // DESCRIPTION | |
2074 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description'])) | |
2075 | { | |
2076 | $description = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2077 | } | |
2078 | elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description'])) | |
2079 | { | |
2080 | $description = $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2081 | } | |
2082 | else | |
2083 | { | |
2084 | $description = $description_parent; | |
2085 | } | |
2086 | ||
2087 | // HASHES | |
2088 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash'])) | |
2089 | { | |
2090 | foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash'] as $hash) | |
2091 | { | |
2092 | $value = null; | |
2093 | $algo = null; | |
2094 | if (isset($hash['data'])) | |
2095 | { | |
2096 | $value = $this->sanitize($hash['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2097 | } | |
2098 | if (isset($hash['attribs']['']['algo'])) | |
2099 | { | |
2100 | $algo = $this->sanitize($hash['attribs']['']['algo'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2101 | } | |
2102 | else | |
2103 | { | |
2104 | $algo = 'md5'; | |
2105 | } | |
2106 | $hashes[] = $algo.':'.$value; | |
2107 | } | |
2108 | if (is_array($hashes)) | |
2109 | { | |
2110 | $hashes = array_values(array_unique($hashes)); | |
2111 | } | |
2112 | } | |
2113 | elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash'])) | |
2114 | { | |
2115 | foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash'] as $hash) | |
2116 | { | |
2117 | $value = null; | |
2118 | $algo = null; | |
2119 | if (isset($hash['data'])) | |
2120 | { | |
2121 | $value = $this->sanitize($hash['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2122 | } | |
2123 | if (isset($hash['attribs']['']['algo'])) | |
2124 | { | |
2125 | $algo = $this->sanitize($hash['attribs']['']['algo'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2126 | } | |
2127 | else | |
2128 | { | |
2129 | $algo = 'md5'; | |
2130 | } | |
2131 | $hashes[] = $algo.':'.$value; | |
2132 | } | |
2133 | if (is_array($hashes)) | |
2134 | { | |
2135 | $hashes = array_values(array_unique($hashes)); | |
2136 | } | |
2137 | } | |
2138 | else | |
2139 | { | |
2140 | $hashes = $hashes_parent; | |
2141 | } | |
2142 | ||
2143 | // KEYWORDS | |
2144 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'])) | |
2145 | { | |
2146 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data'])) | |
2147 | { | |
2148 | $temp = explode(',', $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT)); | |
2149 | foreach ($temp as $word) | |
2150 | { | |
2151 | $keywords[] = trim($word); | |
2152 | } | |
2153 | unset($temp); | |
2154 | } | |
2155 | if (is_array($keywords)) | |
2156 | { | |
2157 | $keywords = array_values(array_unique($keywords)); | |
2158 | } | |
2159 | } | |
2160 | elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'])) | |
2161 | { | |
2162 | if (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data'])) | |
2163 | { | |
2164 | $temp = explode(',', $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT)); | |
2165 | foreach ($temp as $word) | |
2166 | { | |
2167 | $keywords[] = trim($word); | |
2168 | } | |
2169 | unset($temp); | |
2170 | } | |
2171 | if (is_array($keywords)) | |
2172 | { | |
2173 | $keywords = array_values(array_unique($keywords)); | |
2174 | } | |
2175 | } | |
2176 | else | |
2177 | { | |
2178 | $keywords = $keywords_parent; | |
2179 | } | |
2180 | ||
2181 | // PLAYER | |
2182 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player'])) | |
2183 | { | |
2184 | $player = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI); | |
2185 | } | |
2186 | elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player'])) | |
2187 | { | |
2188 | $player = $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI); | |
2189 | } | |
2190 | else | |
2191 | { | |
2192 | $player = $player_parent; | |
2193 | } | |
2194 | ||
2195 | // RATINGS | |
2196 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating'])) | |
2197 | { | |
2198 | foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating'] as $rating) | |
2199 | { | |
2200 | $rating_scheme = null; | |
2201 | $rating_value = null; | |
2202 | if (isset($rating['attribs']['']['scheme'])) | |
2203 | { | |
2204 | $rating_scheme = $this->sanitize($rating['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2205 | } | |
2206 | else | |
2207 | { | |
2208 | $rating_scheme = 'urn:simple'; | |
2209 | } | |
2210 | if (isset($rating['data'])) | |
2211 | { | |
2212 | $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2213 | } | |
2214 | $ratings[] = $this->registry->create('Rating', array($rating_scheme, $rating_value)); | |
2215 | } | |
2216 | if (is_array($ratings)) | |
2217 | { | |
2218 | $ratings = array_values(array_unique($ratings)); | |
2219 | } | |
2220 | } | |
2221 | elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating'])) | |
2222 | { | |
2223 | foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating'] as $rating) | |
2224 | { | |
2225 | $rating_scheme = null; | |
2226 | $rating_value = null; | |
2227 | if (isset($rating['attribs']['']['scheme'])) | |
2228 | { | |
2229 | $rating_scheme = $this->sanitize($rating['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2230 | } | |
2231 | else | |
2232 | { | |
2233 | $rating_scheme = 'urn:simple'; | |
2234 | } | |
2235 | if (isset($rating['data'])) | |
2236 | { | |
2237 | $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2238 | } | |
2239 | $ratings[] = $this->registry->create('Rating', array($rating_scheme, $rating_value)); | |
2240 | } | |
2241 | if (is_array($ratings)) | |
2242 | { | |
2243 | $ratings = array_values(array_unique($ratings)); | |
2244 | } | |
2245 | } | |
2246 | else | |
2247 | { | |
2248 | $ratings = $ratings_parent; | |
2249 | } | |
2250 | ||
2251 | // RESTRICTIONS | |
2252 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction'])) | |
2253 | { | |
2254 | foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction'] as $restriction) | |
2255 | { | |
2256 | $restriction_relationship = null; | |
2257 | $restriction_type = null; | |
2258 | $restriction_value = null; | |
2259 | if (isset($restriction['attribs']['']['relationship'])) | |
2260 | { | |
2261 | $restriction_relationship = $this->sanitize($restriction['attribs']['']['relationship'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2262 | } | |
2263 | if (isset($restriction['attribs']['']['type'])) | |
2264 | { | |
2265 | $restriction_type = $this->sanitize($restriction['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2266 | } | |
2267 | if (isset($restriction['data'])) | |
2268 | { | |
2269 | $restriction_value = $this->sanitize($restriction['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2270 | } | |
2271 | $restrictions[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value)); | |
2272 | } | |
2273 | if (is_array($restrictions)) | |
2274 | { | |
2275 | $restrictions = array_values(array_unique($restrictions)); | |
2276 | } | |
2277 | } | |
2278 | elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction'])) | |
2279 | { | |
2280 | foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction'] as $restriction) | |
2281 | { | |
2282 | $restriction_relationship = null; | |
2283 | $restriction_type = null; | |
2284 | $restriction_value = null; | |
2285 | if (isset($restriction['attribs']['']['relationship'])) | |
2286 | { | |
2287 | $restriction_relationship = $this->sanitize($restriction['attribs']['']['relationship'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2288 | } | |
2289 | if (isset($restriction['attribs']['']['type'])) | |
2290 | { | |
2291 | $restriction_type = $this->sanitize($restriction['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2292 | } | |
2293 | if (isset($restriction['data'])) | |
2294 | { | |
2295 | $restriction_value = $this->sanitize($restriction['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2296 | } | |
2297 | $restrictions[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value)); | |
2298 | } | |
2299 | if (is_array($restrictions)) | |
2300 | { | |
2301 | $restrictions = array_values(array_unique($restrictions)); | |
2302 | } | |
2303 | } | |
2304 | else | |
2305 | { | |
2306 | $restrictions = $restrictions_parent; | |
2307 | } | |
2308 | ||
2309 | // THUMBNAILS | |
2310 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail'])) | |
2311 | { | |
2312 | foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail'] as $thumbnail) | |
2313 | { | |
2314 | $thumbnails[] = $this->sanitize($thumbnail['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI); | |
2315 | } | |
2316 | if (is_array($thumbnails)) | |
2317 | { | |
2318 | $thumbnails = array_values(array_unique($thumbnails)); | |
2319 | } | |
2320 | } | |
2321 | elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail'])) | |
2322 | { | |
2323 | foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail'] as $thumbnail) | |
2324 | { | |
2325 | $thumbnails[] = $this->sanitize($thumbnail['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI); | |
2326 | } | |
2327 | if (is_array($thumbnails)) | |
2328 | { | |
2329 | $thumbnails = array_values(array_unique($thumbnails)); | |
2330 | } | |
2331 | } | |
2332 | else | |
2333 | { | |
2334 | $thumbnails = $thumbnails_parent; | |
2335 | } | |
2336 | ||
2337 | // TITLES | |
2338 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title'])) | |
2339 | { | |
2340 | $title = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2341 | } | |
2342 | elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title'])) | |
2343 | { | |
2344 | $title = $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2345 | } | |
2346 | else | |
2347 | { | |
2348 | $title = $title_parent; | |
2349 | } | |
2350 | ||
2351 | $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions, $categories, $channels, $copyrights, $credits, $description, $duration, $expression, $framerate, $hashes, $height, $keywords, $lang, $medium, $player, $ratings, $restrictions, $samplingrate, $thumbnails, $title, $width)); | |
2352 | } | |
2353 | } | |
2354 | } | |
2355 | } | |
2356 | ||
2357 | // If we have standalone media:content tags, loop through them. | |
2358 | if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['content'])) | |
2359 | { | |
2360 | foreach ((array) $this->data['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['content'] as $content) | |
2361 | { | |
2362 | if (isset($content['attribs']['']['url']) || isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player'])) | |
2363 | { | |
2364 | // Attributes | |
2365 | $bitrate = null; | |
2366 | $channels = null; | |
2367 | $duration = null; | |
2368 | $expression = null; | |
2369 | $framerate = null; | |
2370 | $height = null; | |
2371 | $javascript = null; | |
2372 | $lang = null; | |
2373 | $length = null; | |
2374 | $medium = null; | |
2375 | $samplingrate = null; | |
2376 | $type = null; | |
2377 | $url = null; | |
2378 | $width = null; | |
2379 | ||
2380 | // Elements | |
2381 | $captions = null; | |
2382 | $categories = null; | |
2383 | $copyrights = null; | |
2384 | $credits = null; | |
2385 | $description = null; | |
2386 | $hashes = null; | |
2387 | $keywords = null; | |
2388 | $player = null; | |
2389 | $ratings = null; | |
2390 | $restrictions = null; | |
2391 | $thumbnails = null; | |
2392 | $title = null; | |
2393 | ||
2394 | // Start checking the attributes of media:content | |
2395 | if (isset($content['attribs']['']['bitrate'])) | |
2396 | { | |
2397 | $bitrate = $this->sanitize($content['attribs']['']['bitrate'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2398 | } | |
2399 | if (isset($content['attribs']['']['channels'])) | |
2400 | { | |
2401 | $channels = $this->sanitize($content['attribs']['']['channels'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2402 | } | |
2403 | if (isset($content['attribs']['']['duration'])) | |
2404 | { | |
2405 | $duration = $this->sanitize($content['attribs']['']['duration'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2406 | } | |
2407 | else | |
2408 | { | |
2409 | $duration = $duration_parent; | |
2410 | } | |
2411 | if (isset($content['attribs']['']['expression'])) | |
2412 | { | |
2413 | $expression = $this->sanitize($content['attribs']['']['expression'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2414 | } | |
2415 | if (isset($content['attribs']['']['framerate'])) | |
2416 | { | |
2417 | $framerate = $this->sanitize($content['attribs']['']['framerate'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2418 | } | |
2419 | if (isset($content['attribs']['']['height'])) | |
2420 | { | |
2421 | $height = $this->sanitize($content['attribs']['']['height'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2422 | } | |
2423 | if (isset($content['attribs']['']['lang'])) | |
2424 | { | |
2425 | $lang = $this->sanitize($content['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2426 | } | |
2427 | if (isset($content['attribs']['']['fileSize'])) | |
2428 | { | |
2429 | $length = ceil($content['attribs']['']['fileSize']); | |
2430 | } | |
2431 | if (isset($content['attribs']['']['medium'])) | |
2432 | { | |
2433 | $medium = $this->sanitize($content['attribs']['']['medium'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2434 | } | |
2435 | if (isset($content['attribs']['']['samplingrate'])) | |
2436 | { | |
2437 | $samplingrate = $this->sanitize($content['attribs']['']['samplingrate'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2438 | } | |
2439 | if (isset($content['attribs']['']['type'])) | |
2440 | { | |
2441 | $type = $this->sanitize($content['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2442 | } | |
2443 | if (isset($content['attribs']['']['width'])) | |
2444 | { | |
2445 | $width = $this->sanitize($content['attribs']['']['width'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2446 | } | |
2447 | if (isset($content['attribs']['']['url'])) | |
2448 | { | |
2449 | $url = $this->sanitize($content['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI); | |
2450 | } | |
2451 | // Checking the other optional media: elements. Priority: media:content, media:group, item, channel | |
2452 | ||
2453 | // CAPTIONS | |
2454 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text'])) | |
2455 | { | |
2456 | foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text'] as $caption) | |
2457 | { | |
2458 | $caption_type = null; | |
2459 | $caption_lang = null; | |
2460 | $caption_startTime = null; | |
2461 | $caption_endTime = null; | |
2462 | $caption_text = null; | |
2463 | if (isset($caption['attribs']['']['type'])) | |
2464 | { | |
2465 | $caption_type = $this->sanitize($caption['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2466 | } | |
2467 | if (isset($caption['attribs']['']['lang'])) | |
2468 | { | |
2469 | $caption_lang = $this->sanitize($caption['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2470 | } | |
2471 | if (isset($caption['attribs']['']['start'])) | |
2472 | { | |
2473 | $caption_startTime = $this->sanitize($caption['attribs']['']['start'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2474 | } | |
2475 | if (isset($caption['attribs']['']['end'])) | |
2476 | { | |
2477 | $caption_endTime = $this->sanitize($caption['attribs']['']['end'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2478 | } | |
2479 | if (isset($caption['data'])) | |
2480 | { | |
2481 | $caption_text = $this->sanitize($caption['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2482 | } | |
2483 | $captions[] = $this->registry->create('Caption', array($caption_type, $caption_lang, $caption_startTime, $caption_endTime, $caption_text)); | |
2484 | } | |
2485 | if (is_array($captions)) | |
2486 | { | |
2487 | $captions = array_values(array_unique($captions)); | |
2488 | } | |
2489 | } | |
2490 | else | |
2491 | { | |
2492 | $captions = $captions_parent; | |
2493 | } | |
2494 | ||
2495 | // CATEGORIES | |
2496 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category'])) | |
2497 | { | |
2498 | foreach ((array) $content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category'] as $category) | |
2499 | { | |
2500 | $term = null; | |
2501 | $scheme = null; | |
2502 | $label = null; | |
2503 | if (isset($category['data'])) | |
2504 | { | |
2505 | $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2506 | } | |
2507 | if (isset($category['attribs']['']['scheme'])) | |
2508 | { | |
2509 | $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2510 | } | |
2511 | else | |
2512 | { | |
2513 | $scheme = 'http://search.yahoo.com/mrss/category_schema'; | |
2514 | } | |
2515 | if (isset($category['attribs']['']['label'])) | |
2516 | { | |
2517 | $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2518 | } | |
2519 | $categories[] = $this->registry->create('Category', array($term, $scheme, $label)); | |
2520 | } | |
2521 | } | |
2522 | if (is_array($categories) && is_array($categories_parent)) | |
2523 | { | |
2524 | $categories = array_values(array_unique(array_merge($categories, $categories_parent))); | |
2525 | } | |
2526 | elseif (is_array($categories)) | |
2527 | { | |
2528 | $categories = array_values(array_unique($categories)); | |
2529 | } | |
2530 | elseif (is_array($categories_parent)) | |
2531 | { | |
2532 | $categories = array_values(array_unique($categories_parent)); | |
2533 | } | |
2534 | else | |
2535 | { | |
2536 | $categories = null; | |
2537 | } | |
2538 | ||
2539 | // COPYRIGHTS | |
2540 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'])) | |
2541 | { | |
2542 | $copyright_url = null; | |
2543 | $copyright_label = null; | |
2544 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url'])) | |
2545 | { | |
2546 | $copyright_url = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2547 | } | |
2548 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data'])) | |
2549 | { | |
2550 | $copyright_label = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2551 | } | |
2552 | $copyrights = $this->registry->create('Copyright', array($copyright_url, $copyright_label)); | |
2553 | } | |
2554 | else | |
2555 | { | |
2556 | $copyrights = $copyrights_parent; | |
2557 | } | |
2558 | ||
2559 | // CREDITS | |
2560 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit'])) | |
2561 | { | |
2562 | foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit'] as $credit) | |
2563 | { | |
2564 | $credit_role = null; | |
2565 | $credit_scheme = null; | |
2566 | $credit_name = null; | |
2567 | if (isset($credit['attribs']['']['role'])) | |
2568 | { | |
2569 | $credit_role = $this->sanitize($credit['attribs']['']['role'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2570 | } | |
2571 | if (isset($credit['attribs']['']['scheme'])) | |
2572 | { | |
2573 | $credit_scheme = $this->sanitize($credit['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2574 | } | |
2575 | else | |
2576 | { | |
2577 | $credit_scheme = 'urn:ebu'; | |
2578 | } | |
2579 | if (isset($credit['data'])) | |
2580 | { | |
2581 | $credit_name = $this->sanitize($credit['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2582 | } | |
2583 | $credits[] = $this->registry->create('Credit', array($credit_role, $credit_scheme, $credit_name)); | |
2584 | } | |
2585 | if (is_array($credits)) | |
2586 | { | |
2587 | $credits = array_values(array_unique($credits)); | |
2588 | } | |
2589 | } | |
2590 | else | |
2591 | { | |
2592 | $credits = $credits_parent; | |
2593 | } | |
2594 | ||
2595 | // DESCRIPTION | |
2596 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description'])) | |
2597 | { | |
2598 | $description = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2599 | } | |
2600 | else | |
2601 | { | |
2602 | $description = $description_parent; | |
2603 | } | |
2604 | ||
2605 | // HASHES | |
2606 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash'])) | |
2607 | { | |
2608 | foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash'] as $hash) | |
2609 | { | |
2610 | $value = null; | |
2611 | $algo = null; | |
2612 | if (isset($hash['data'])) | |
2613 | { | |
2614 | $value = $this->sanitize($hash['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2615 | } | |
2616 | if (isset($hash['attribs']['']['algo'])) | |
2617 | { | |
2618 | $algo = $this->sanitize($hash['attribs']['']['algo'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2619 | } | |
2620 | else | |
2621 | { | |
2622 | $algo = 'md5'; | |
2623 | } | |
2624 | $hashes[] = $algo.':'.$value; | |
2625 | } | |
2626 | if (is_array($hashes)) | |
2627 | { | |
2628 | $hashes = array_values(array_unique($hashes)); | |
2629 | } | |
2630 | } | |
2631 | else | |
2632 | { | |
2633 | $hashes = $hashes_parent; | |
2634 | } | |
2635 | ||
2636 | // KEYWORDS | |
2637 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'])) | |
2638 | { | |
2639 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data'])) | |
2640 | { | |
2641 | $temp = explode(',', $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT)); | |
2642 | foreach ($temp as $word) | |
2643 | { | |
2644 | $keywords[] = trim($word); | |
2645 | } | |
2646 | unset($temp); | |
2647 | } | |
2648 | if (is_array($keywords)) | |
2649 | { | |
2650 | $keywords = array_values(array_unique($keywords)); | |
2651 | } | |
2652 | } | |
2653 | else | |
2654 | { | |
2655 | $keywords = $keywords_parent; | |
2656 | } | |
2657 | ||
2658 | // PLAYER | |
2659 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player'])) | |
2660 | { | |
2661 | $player = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI); | |
2662 | } | |
2663 | else | |
2664 | { | |
2665 | $player = $player_parent; | |
2666 | } | |
2667 | ||
2668 | // RATINGS | |
2669 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating'])) | |
2670 | { | |
2671 | foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating'] as $rating) | |
2672 | { | |
2673 | $rating_scheme = null; | |
2674 | $rating_value = null; | |
2675 | if (isset($rating['attribs']['']['scheme'])) | |
2676 | { | |
2677 | $rating_scheme = $this->sanitize($rating['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2678 | } | |
2679 | else | |
2680 | { | |
2681 | $rating_scheme = 'urn:simple'; | |
2682 | } | |
2683 | if (isset($rating['data'])) | |
2684 | { | |
2685 | $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2686 | } | |
2687 | $ratings[] = $this->registry->create('Rating', array($rating_scheme, $rating_value)); | |
2688 | } | |
2689 | if (is_array($ratings)) | |
2690 | { | |
2691 | $ratings = array_values(array_unique($ratings)); | |
2692 | } | |
2693 | } | |
2694 | else | |
2695 | { | |
2696 | $ratings = $ratings_parent; | |
2697 | } | |
2698 | ||
2699 | // RESTRICTIONS | |
2700 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction'])) | |
2701 | { | |
2702 | foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction'] as $restriction) | |
2703 | { | |
2704 | $restriction_relationship = null; | |
2705 | $restriction_type = null; | |
2706 | $restriction_value = null; | |
2707 | if (isset($restriction['attribs']['']['relationship'])) | |
2708 | { | |
2709 | $restriction_relationship = $this->sanitize($restriction['attribs']['']['relationship'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2710 | } | |
2711 | if (isset($restriction['attribs']['']['type'])) | |
2712 | { | |
2713 | $restriction_type = $this->sanitize($restriction['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2714 | } | |
2715 | if (isset($restriction['data'])) | |
2716 | { | |
2717 | $restriction_value = $this->sanitize($restriction['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2718 | } | |
2719 | $restrictions[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value)); | |
2720 | } | |
2721 | if (is_array($restrictions)) | |
2722 | { | |
2723 | $restrictions = array_values(array_unique($restrictions)); | |
2724 | } | |
2725 | } | |
2726 | else | |
2727 | { | |
2728 | $restrictions = $restrictions_parent; | |
2729 | } | |
2730 | ||
2731 | // THUMBNAILS | |
2732 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail'])) | |
2733 | { | |
2734 | foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail'] as $thumbnail) | |
2735 | { | |
2736 | $thumbnails[] = $this->sanitize($thumbnail['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI); | |
2737 | } | |
2738 | if (is_array($thumbnails)) | |
2739 | { | |
2740 | $thumbnails = array_values(array_unique($thumbnails)); | |
2741 | } | |
2742 | } | |
2743 | else | |
2744 | { | |
2745 | $thumbnails = $thumbnails_parent; | |
2746 | } | |
2747 | ||
2748 | // TITLES | |
2749 | if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title'])) | |
2750 | { | |
2751 | $title = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2752 | } | |
2753 | else | |
2754 | { | |
2755 | $title = $title_parent; | |
2756 | } | |
2757 | ||
2758 | $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions, $categories, $channels, $copyrights, $credits, $description, $duration, $expression, $framerate, $hashes, $height, $keywords, $lang, $medium, $player, $ratings, $restrictions, $samplingrate, $thumbnails, $title, $width)); | |
2759 | } | |
2760 | } | |
2761 | } | |
2762 | ||
2763 | foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'link') as $link) | |
2764 | { | |
2765 | if (isset($link['attribs']['']['href']) && !empty($link['attribs']['']['rel']) && $link['attribs']['']['rel'] === 'enclosure') | |
2766 | { | |
2767 | // Attributes | |
2768 | $bitrate = null; | |
2769 | $channels = null; | |
2770 | $duration = null; | |
2771 | $expression = null; | |
2772 | $framerate = null; | |
2773 | $height = null; | |
2774 | $javascript = null; | |
2775 | $lang = null; | |
2776 | $length = null; | |
2777 | $medium = null; | |
2778 | $samplingrate = null; | |
2779 | $type = null; | |
2780 | $url = null; | |
2781 | $width = null; | |
2782 | ||
2783 | $url = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link)); | |
2784 | if (isset($link['attribs']['']['type'])) | |
2785 | { | |
2786 | $type = $this->sanitize($link['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2787 | } | |
2788 | if (isset($link['attribs']['']['length'])) | |
2789 | { | |
2790 | $length = ceil($link['attribs']['']['length']); | |
2791 | } | |
2792 | ||
2793 | // Since we don't have group or content for these, we'll just pass the '*_parent' variables directly to the constructor | |
2794 | $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions_parent, $categories_parent, $channels, $copyrights_parent, $credits_parent, $description_parent, $duration_parent, $expression, $framerate, $hashes_parent, $height, $keywords_parent, $lang, $medium, $player_parent, $ratings_parent, $restrictions_parent, $samplingrate, $thumbnails_parent, $title_parent, $width)); | |
2795 | } | |
2796 | } | |
2797 | ||
2798 | foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'link') as $link) | |
2799 | { | |
2800 | if (isset($link['attribs']['']['href']) && !empty($link['attribs']['']['rel']) && $link['attribs']['']['rel'] === 'enclosure') | |
2801 | { | |
2802 | // Attributes | |
2803 | $bitrate = null; | |
2804 | $channels = null; | |
2805 | $duration = null; | |
2806 | $expression = null; | |
2807 | $framerate = null; | |
2808 | $height = null; | |
2809 | $javascript = null; | |
2810 | $lang = null; | |
2811 | $length = null; | |
2812 | $medium = null; | |
2813 | $samplingrate = null; | |
2814 | $type = null; | |
2815 | $url = null; | |
2816 | $width = null; | |
2817 | ||
2818 | $url = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link)); | |
2819 | if (isset($link['attribs']['']['type'])) | |
2820 | { | |
2821 | $type = $this->sanitize($link['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2822 | } | |
2823 | if (isset($link['attribs']['']['length'])) | |
2824 | { | |
2825 | $length = ceil($link['attribs']['']['length']); | |
2826 | } | |
2827 | ||
2828 | // Since we don't have group or content for these, we'll just pass the '*_parent' variables directly to the constructor | |
2829 | $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions_parent, $categories_parent, $channels, $copyrights_parent, $credits_parent, $description_parent, $duration_parent, $expression, $framerate, $hashes_parent, $height, $keywords_parent, $lang, $medium, $player_parent, $ratings_parent, $restrictions_parent, $samplingrate, $thumbnails_parent, $title_parent, $width)); | |
2830 | } | |
2831 | } | |
2832 | ||
2833 | if ($enclosure = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'enclosure')) | |
2834 | { | |
2835 | if (isset($enclosure[0]['attribs']['']['url'])) | |
2836 | { | |
2837 | // Attributes | |
2838 | $bitrate = null; | |
2839 | $channels = null; | |
2840 | $duration = null; | |
2841 | $expression = null; | |
2842 | $framerate = null; | |
2843 | $height = null; | |
2844 | $javascript = null; | |
2845 | $lang = null; | |
2846 | $length = null; | |
2847 | $medium = null; | |
2848 | $samplingrate = null; | |
2849 | $type = null; | |
2850 | $url = null; | |
2851 | $width = null; | |
2852 | ||
2853 | $url = $this->sanitize($enclosure[0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($enclosure[0])); | |
2854 | if (isset($enclosure[0]['attribs']['']['type'])) | |
2855 | { | |
2856 | $type = $this->sanitize($enclosure[0]['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2857 | } | |
2858 | if (isset($enclosure[0]['attribs']['']['length'])) | |
2859 | { | |
2860 | $length = ceil($enclosure[0]['attribs']['']['length']); | |
2861 | } | |
2862 | ||
2863 | // Since we don't have group or content for these, we'll just pass the '*_parent' variables directly to the constructor | |
2864 | $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions_parent, $categories_parent, $channels, $copyrights_parent, $credits_parent, $description_parent, $duration_parent, $expression, $framerate, $hashes_parent, $height, $keywords_parent, $lang, $medium, $player_parent, $ratings_parent, $restrictions_parent, $samplingrate, $thumbnails_parent, $title_parent, $width)); | |
2865 | } | |
2866 | } | |
2867 | ||
2868 | if (sizeof($this->data['enclosures']) === 0 && ($url || $type || $length || $bitrate || $captions_parent || $categories_parent || $channels || $copyrights_parent || $credits_parent || $description_parent || $duration_parent || $expression || $framerate || $hashes_parent || $height || $keywords_parent || $lang || $medium || $player_parent || $ratings_parent || $restrictions_parent || $samplingrate || $thumbnails_parent || $title_parent || $width)) | |
2869 | { | |
2870 | // Since we don't have group or content for these, we'll just pass the '*_parent' variables directly to the constructor | |
2871 | $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions_parent, $categories_parent, $channels, $copyrights_parent, $credits_parent, $description_parent, $duration_parent, $expression, $framerate, $hashes_parent, $height, $keywords_parent, $lang, $medium, $player_parent, $ratings_parent, $restrictions_parent, $samplingrate, $thumbnails_parent, $title_parent, $width)); | |
2872 | } | |
2873 | ||
2874 | $this->data['enclosures'] = array_values(array_unique($this->data['enclosures'])); | |
2875 | } | |
2876 | if (!empty($this->data['enclosures'])) | |
2877 | { | |
2878 | return $this->data['enclosures']; | |
2879 | } | |
2880 | else | |
2881 | { | |
2882 | return null; | |
2883 | } | |
2884 | } | |
2885 | ||
2886 | /** | |
2887 | * Get the latitude coordinates for the item | |
2888 | * | |
2889 | * Compatible with the W3C WGS84 Basic Geo and GeoRSS specifications | |
2890 | * | |
2891 | * Uses `<geo:lat>` or `<georss:point>` | |
2892 | * | |
2893 | * @since 1.0 | |
2894 | * @link http://www.w3.org/2003/01/geo/ W3C WGS84 Basic Geo | |
2895 | * @link http://www.georss.org/ GeoRSS | |
2896 | * @return string|null | |
2897 | */ | |
2898 | public function get_latitude() | |
2899 | { | |
2900 | if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'lat')) | |
2901 | { | |
2902 | return (float) $return[0]['data']; | |
2903 | } | |
2904 | elseif (($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_GEORSS, 'point')) && preg_match('/^((?:-)?[0-9]+(?:\.[0-9]+)) ((?:-)?[0-9]+(?:\.[0-9]+))$/', trim($return[0]['data']), $match)) | |
2905 | { | |
2906 | return (float) $match[1]; | |
2907 | } | |
2908 | else | |
2909 | { | |
2910 | return null; | |
2911 | } | |
2912 | } | |
2913 | ||
2914 | /** | |
2915 | * Get the longitude coordinates for the item | |
2916 | * | |
2917 | * Compatible with the W3C WGS84 Basic Geo and GeoRSS specifications | |
2918 | * | |
2919 | * Uses `<geo:long>`, `<geo:lon>` or `<georss:point>` | |
2920 | * | |
2921 | * @since 1.0 | |
2922 | * @link http://www.w3.org/2003/01/geo/ W3C WGS84 Basic Geo | |
2923 | * @link http://www.georss.org/ GeoRSS | |
2924 | * @return string|null | |
2925 | */ | |
2926 | public function get_longitude() | |
2927 | { | |
2928 | if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'long')) | |
2929 | { | |
2930 | return (float) $return[0]['data']; | |
2931 | } | |
2932 | elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'lon')) | |
2933 | { | |
2934 | return (float) $return[0]['data']; | |
2935 | } | |
2936 | elseif (($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_GEORSS, 'point')) && preg_match('/^((?:-)?[0-9]+(?:\.[0-9]+)) ((?:-)?[0-9]+(?:\.[0-9]+))$/', trim($return[0]['data']), $match)) | |
2937 | { | |
2938 | return (float) $match[2]; | |
2939 | } | |
2940 | else | |
2941 | { | |
2942 | return null; | |
2943 | } | |
2944 | } | |
2945 | ||
2946 | /** | |
2947 | * Get the `<atom:source>` for the item | |
2948 | * | |
2949 | * @since 1.1 | |
2950 | * @return SimplePie_Source|null | |
2951 | */ | |
2952 | public function get_source() | |
2953 | { | |
2954 | if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'source')) | |
2955 | { | |
2956 | return $this->registry->create('Source', array($this, $return[0])); | |
2957 | } | |
2958 | else | |
2959 | { | |
2960 | return null; | |
2961 | } | |
2962 | } | |
2963 | } | |
2964 |