PageRenderTime 147ms CodeModel.GetById 81ms app.highlight 12ms RepoModel.GetById 48ms app.codeStats 0ms

/Service/SlideShare.php

https://bitbucket.org/bigstylee/zend-framework
PHP | 619 lines | 308 code | 98 blank | 213 comment | 32 complexity | 9ccb133c65d3bdb81524d73706c29303 MD5 | raw file
  1<?php
  2/**
  3 * Zend Framework
  4 *
  5 * LICENSE
  6 *
  7 * This source file is subject to the new BSD license that is bundled
  8 * with this package in the file LICENSE.txt.
  9 * It is also available through the world-wide-web at this URL:
 10 * http://framework.zend.com/license/new-bsd
 11 * If you did not receive a copy of the license and are unable to
 12 * obtain it through the world-wide-web, please send an email
 13 * to license@zend.com so we can send you a copy immediately.
 14 *
 15 * @category   Zend
 16 * @package    Zend_Service
 17 * @subpackage SlideShare
 18 * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
 19 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 20 * @version    $Id: SlideShare.php 24593 2012-01-05 20:35:02Z matthew $
 21 */
 22
 23/**
 24 * Zend_Http_Client
 25 */
 26require_once 'Zend/Http/Client.php';
 27
 28/**
 29 * Zend_Cache
 30 */
 31require_once 'Zend/Cache.php';
 32
 33/**
 34 * Zend_Service_SlideShare_SlideShow
 35 */
 36require_once 'Zend/Service/SlideShare/SlideShow.php';
 37
 38/**
 39 * The Zend_Service_SlideShare component is used to interface with the
 40 * slideshare.net web server to retrieve slide shows hosted on the web site for
 41 * display or other processing.
 42 *
 43 * @category   Zend
 44 * @package    Zend_Service
 45 * @subpackage SlideShare
 46 * @throws     Zend_Service_SlideShare_Exception
 47 * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
 48 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 49 */
 50class Zend_Service_SlideShare
 51{
 52
 53    /**
 54     * Web service result code mapping
 55     */
 56    const SERVICE_ERROR_BAD_APIKEY       = 1;
 57    const SERVICE_ERROR_BAD_AUTH         = 2;
 58    const SERVICE_ERROR_MISSING_TITLE    = 3;
 59    const SERVICE_ERROR_MISSING_FILE     = 4;
 60    const SERVICE_ERROR_EMPTY_TITLE      = 5;
 61    const SERVICE_ERROR_NOT_SOURCEOBJ    = 6;
 62    const SERVICE_ERROR_INVALID_EXT      = 7;
 63    const SERVICE_ERROR_FILE_TOO_BIG     = 8;
 64    const SERVICE_ERROR_SHOW_NOT_FOUND   = 9;
 65    const SERVICE_ERROR_USER_NOT_FOUND   = 10;
 66    const SERVICE_ERROR_GROUP_NOT_FOUND  = 11;
 67    const SERVICE_ERROR_MISSING_TAG      = 12;
 68    const SERVICE_ERROR_DAILY_LIMIT      = 99;
 69    const SERVICE_ERROR_ACCOUNT_BLOCKED  = 100;
 70
 71    /**
 72     * Slide share Web service communication URIs
 73     */
 74    const SERVICE_UPLOAD_URI                  = 'http://www.slideshare.net/api/1/upload_slideshow';
 75    const SERVICE_GET_SHOW_URI                = 'http://www.slideshare.net/api/1/get_slideshow';
 76    const SERVICE_GET_SHOW_BY_USER_URI        = 'http://www.slideshare.net/api/1/get_slideshow_by_user';
 77    const SERVICE_GET_SHOW_BY_TAG_URI         = 'http://www.slideshare.net/api/1/get_slideshow_by_tag';
 78    const SERVICE_GET_SHOW_BY_GROUP_URI       = 'http://www.slideshare.net/api/1/get_slideshows_from_group';
 79
 80    /**
 81     * The MIME type of Slideshow files
 82     *
 83     */
 84    const POWERPOINT_MIME_TYPE    = "application/vnd.ms-powerpoint";
 85
 86    /**
 87     * The API key to use in requests
 88     *
 89     * @var string The API key
 90     */
 91    protected $_apiKey;
 92
 93    /**
 94     * The shared secret to use in requests
 95     *
 96     * @var string the Shared secret
 97     */
 98    protected $_sharedSecret;
 99
100    /**
101     * The username to use in requests
102     *
103     * @var string the username
104     */
105    protected $_username;
106
107    /**
108     * The password to use in requests
109     *
110     * @var string the password
111     */
112    protected $_password;
113
114    /**
115     * The HTTP Client object to use to perform requests
116     *
117     * @var Zend_Http_Client
118     */
119    protected $_httpclient;
120
121    /**
122     * The Cache object to use to perform caching
123     *
124     * @var Zend_Cache_Core
125     */
126    protected $_cacheobject;
127
128    /**
129     * Sets the Zend_Http_Client object to use in requests. If not provided a default will
130     * be used.
131     *
132     * @param Zend_Http_Client $client The HTTP client instance to use
133     * @return Zend_Service_SlideShare
134     */
135    public function setHttpClient(Zend_Http_Client $client)
136    {
137        $this->_httpclient = $client;
138        return $this;
139    }
140
141    /**
142     * Returns the instance of the Zend_Http_Client which will be used. Creates an instance
143     * of Zend_Http_Client if no previous client was set.
144     *
145     * @return Zend_Http_Client The HTTP client which will be used
146     */
147    public function getHttpClient()
148    {
149
150        if(!($this->_httpclient instanceof Zend_Http_Client)) {
151            $client = new Zend_Http_Client();
152            $client->setConfig(array('maxredirects' => 2,
153                                     'timeout' => 5));
154
155            $this->setHttpClient($client);
156        }
157
158        $this->_httpclient->resetParameters();
159        return $this->_httpclient;
160    }
161
162    /**
163     * Sets the Zend_Cache object to use to cache the results of API queries
164     *
165     * @param Zend_Cache_Core $cacheobject The Zend_Cache object used
166     * @return Zend_Service_SlideShare
167     */
168    public function setCacheObject(Zend_Cache_Core $cacheobject)
169    {
170        $this->_cacheobject = $cacheobject;
171        return $this;
172    }
173
174    /**
175     * Gets the Zend_Cache object which will be used to cache API queries. If no cache object
176     * was previously set the the default will be used (Filesystem caching in /tmp with a life
177     * time of 43200 seconds)
178     *
179     * @return Zend_Cache_Core The object used in caching
180     */
181    public function getCacheObject()
182    {
183
184        if(!($this->_cacheobject instanceof Zend_Cache_Core)) {
185            $cache = Zend_Cache::factory('Core', 'File', array('lifetime' => 43200,
186                                                               'automatic_serialization' => true),
187                                                         array('cache_dir' => '/tmp'));
188
189            $this->setCacheObject($cache);
190        }
191
192        return $this->_cacheobject;
193    }
194
195    /**
196     * Returns the user name used for API calls
197     *
198     * @return string The username
199     */
200    public function getUserName()
201    {
202        return $this->_username;
203    }
204
205    /**
206     * Sets the user name to use for API calls
207     *
208     * @param string $un The username to use
209     * @return Zend_Service_SlideShare
210     */
211    public function setUserName($un)
212    {
213        $this->_username = $un;
214        return $this;
215    }
216
217    /**
218     * Gets the password to use in API calls
219     *
220     * @return string the password to use in API calls
221     */
222    public function getPassword()
223    {
224        return $this->_password;
225    }
226
227    /**
228     * Sets the password to use in API calls
229     *
230     * @param string $pw The password to use
231     * @return Zend_Service_SlideShare
232     */
233    public function setPassword($pw)
234    {
235        $this->_password = (string)$pw;
236        return $this;
237    }
238
239    /**
240     * Gets the API key to be used in making API calls
241     *
242     * @return string the API Key
243     */
244    public function getApiKey()
245    {
246        return $this->_apiKey;
247    }
248
249    /**
250     * Sets the API key to be used in making API calls
251     *
252     * @param string $key The API key to use
253     * @return Zend_Service_SlideShare
254     */
255    public function setApiKey($key)
256    {
257        $this->_apiKey = (string)$key;
258        return $this;
259    }
260
261    /**
262     * Gets the shared secret used in making API calls
263     *
264     * @return string the Shared secret
265     */
266    public function getSharedSecret()
267    {
268        return $this->_sharedSecret;
269    }
270
271    /**
272     * Sets the shared secret used in making API calls
273     *
274     * @param string $secret the shared secret
275     * @return Zend_Service_SlideShare
276     */
277    public function setSharedSecret($secret)
278    {
279        $this->_sharedSecret = (string)$secret;
280        return $this;
281    }
282
283    /**
284     * The Constructor
285     *
286     * @param string $apikey The API key
287     * @param string $sharedSecret The shared secret
288     * @param string $username The username
289     * @param string $password The password
290     */
291    public function __construct($apikey, $sharedSecret, $username = null, $password = null)
292    {
293        $this->setApiKey($apikey)
294             ->setSharedSecret($sharedSecret)
295             ->setUserName($username)
296             ->setPassword($password);
297
298        $this->_httpclient = new Zend_Http_Client();
299    }
300
301    /**
302     * Uploads the specified Slide show the the server
303     *
304     * @param Zend_Service_SlideShare_SlideShow $ss The slide show object representing the slide show to upload
305     * @param boolean $make_src_public Determines if the the slide show's source file is public or not upon upload
306     * @return Zend_Service_SlideShare_SlideShow The passed Slide show object, with the new assigned ID provided
307     */
308    public function uploadSlideShow(Zend_Service_SlideShare_SlideShow $ss, $make_src_public = true)
309    {
310
311        $timestamp = time();
312
313        $params = array('api_key' => $this->getApiKey(),
314                        'ts' => $timestamp,
315                        'hash' => sha1($this->getSharedSecret().$timestamp),
316                        'username' => $this->getUserName(),
317                        'password' => $this->getPassword(),
318                        'slideshow_title' => $ss->getTitle());
319
320        $description = $ss->getDescription();
321        $tags = $ss->getTags();
322
323        $filename = $ss->getFilename();
324
325        if(!file_exists($filename) || !is_readable($filename)) {
326            require_once 'Zend/Service/SlideShare/Exception.php';
327            throw new Zend_Service_SlideShare_Exception("Specified Slideshow for upload not found or unreadable");
328        }
329
330        if(!empty($description)) {
331            $params['slideshow_description'] = $description;
332        } else {
333            $params['slideshow_description'] = "";
334        }
335
336        if(!empty($tags)) {
337            $tmp = array();
338            foreach($tags as $tag) {
339                $tmp[] = "\"$tag\"";
340            }
341            $params['slideshow_tags'] = implode(' ', $tmp);
342        } else {
343            $params['slideshow_tags'] = "";
344        }
345
346
347        $client = $this->getHttpClient();
348        $client->setUri(self::SERVICE_UPLOAD_URI);
349        $client->setParameterPost($params);
350        $client->setFileUpload($filename, "slideshow_srcfile");
351
352        require_once 'Zend/Http/Client/Exception.php';
353        try {
354            $response = $client->request('POST');
355        } catch(Zend_Http_Client_Exception $e) {
356            require_once 'Zend/Service/SlideShare/Exception.php';
357            throw new Zend_Service_SlideShare_Exception("Service Request Failed: {$e->getMessage()}", 0, $e);
358        }
359
360        $sxe = simplexml_load_string($response->getBody());
361
362        if($sxe->getName() == "SlideShareServiceError") {
363            $message = (string)$sxe->Message[0];
364            list($code, $error_str) = explode(':', $message);
365            require_once 'Zend/Service/SlideShare/Exception.php';
366            throw new Zend_Service_SlideShare_Exception(trim($error_str), $code);
367        }
368
369        if(!$sxe->getName() == "SlideShowUploaded") {
370            require_once 'Zend/Service/SlideShare/Exception.php';
371            throw new Zend_Service_SlideShare_Exception("Unknown XML Respons Received");
372        }
373
374        $ss->setId((int)(string)$sxe->SlideShowID);
375
376        return $ss;
377    }
378
379    /**
380     * Retrieves a slide show's information based on slide show ID
381     *
382     * @param int $ss_id The slide show ID
383     * @return Zend_Service_SlideShare_SlideShow the Slideshow object
384     */
385    public function getSlideShow($ss_id)
386    {
387        $timestamp = time();
388
389        $params = array('api_key' => $this->getApiKey(),
390                        'ts' => $timestamp,
391                        'hash' => sha1($this->getSharedSecret().$timestamp),
392                        'slideshow_id' => $ss_id);
393
394        $cache = $this->getCacheObject();
395
396        $cache_key = md5("__zendslideshare_cache_$ss_id");
397
398        if(!$retval = $cache->load($cache_key)) {
399            $client = $this->getHttpClient();
400
401            $client->setUri(self::SERVICE_GET_SHOW_URI);
402            $client->setParameterPost($params);
403
404            require_once 'Zend/Http/Client/Exception.php';
405            try {
406                $response = $client->request('POST');
407            } catch(Zend_Http_Client_Exception $e) {
408                require_once 'Zend/Service/SlideShare/Exception.php';
409                throw new Zend_Service_SlideShare_Exception("Service Request Failed: {$e->getMessage()}", 0, $e);
410            }
411
412            $sxe = simplexml_load_string($response->getBody());
413
414            if($sxe->getName() == "SlideShareServiceError") {
415                $message = (string)$sxe->Message[0];
416                list($code, $error_str) = explode(':', $message);
417                require_once 'Zend/Service/SlideShare/Exception.php';
418                throw new Zend_Service_SlideShare_Exception(trim($error_str), $code);
419            }
420
421            if(!$sxe->getName() == 'Slideshows') {
422                require_once 'Zend/Service/SlideShare/Exception.php';
423                throw new Zend_Service_SlideShare_Exception('Unknown XML Repsonse Received');
424            }
425
426            $retval = $this->_slideShowNodeToObject(clone $sxe->Slideshow[0]);
427
428            $cache->save($retval, $cache_key);
429        }
430
431        return $retval;
432    }
433
434    /**
435     * Retrieves an array of slide shows for a given username
436     *
437     * @param string $username The username to retrieve slide shows from
438     * @param int $offset The offset of the list to start retrieving from
439     * @param int $limit The maximum number of slide shows to retrieve
440     * @return array An array of Zend_Service_SlideShare_SlideShow objects
441     */
442    public function getSlideShowsByUsername($username, $offset = null, $limit = null)
443    {
444        return $this->_getSlideShowsByType('username_for', $username, $offset, $limit);
445    }
446
447    /**
448     * Retrieves an array of slide shows based on tag
449     *
450     * @param string $tag The tag to retrieve slide shows with
451     * @param int $offset The offset of the list to start retrieving from
452     * @param int $limit The maximum number of slide shows to retrieve
453     * @return array An array of Zend_Service_SlideShare_SlideShow objects
454     */
455    public function getSlideShowsByTag($tag, $offset = null, $limit = null)
456    {
457
458        if(is_array($tag)) {
459            $tmp = array();
460            foreach($tag as $t) {
461                $tmp[] = "\"$t\"";
462            }
463
464            $tag = implode(" ", $tmp);
465        }
466
467        return $this->_getSlideShowsByType('tag', $tag, $offset, $limit);
468    }
469
470    /**
471     * Retrieves an array of slide shows based on group name
472     *
473     * @param string $group The group name to retrieve slide shows for
474     * @param int $offset The offset of the list to start retrieving from
475     * @param int $limit The maximum number of slide shows to retrieve
476     * @return array An array of Zend_Service_SlideShare_SlideShow objects
477     */
478    public function getSlideShowsByGroup($group, $offset = null, $limit = null)
479    {
480        return $this->_getSlideShowsByType('group_name', $group, $offset, $limit);
481    }
482
483    /**
484     * Retrieves Zend_Service_SlideShare_SlideShow object arrays based on the type of
485     * list desired
486     *
487     * @param string $key The type of slide show object to retrieve
488     * @param string $value The specific search query for the slide show type to look up
489     * @param int $offset The offset of the list to start retrieving from
490     * @param int $limit The maximum number of slide shows to retrieve
491     * @return array An array of Zend_Service_SlideShare_SlideShow objects
492     */
493    protected function _getSlideShowsByType($key, $value, $offset = null, $limit = null)
494    {
495
496        $key = strtolower($key);
497
498        switch($key) {
499            case 'username_for':
500                $responseTag = 'User';
501                $queryUri = self::SERVICE_GET_SHOW_BY_USER_URI;
502                break;
503            case 'group_name':
504                $responseTag = 'Group';
505                $queryUri = self::SERVICE_GET_SHOW_BY_GROUP_URI;
506                break;
507            case 'tag':
508                $responseTag = 'Tag';
509                $queryUri = self::SERVICE_GET_SHOW_BY_TAG_URI;
510                break;
511            default:
512                require_once 'Zend/Service/SlideShare/Exception.php';
513                throw new Zend_Service_SlideShare_Exception("Invalid SlideShare Query");
514        }
515
516        $timestamp = time();
517
518        $params = array('api_key' => $this->getApiKey(),
519                        'ts' => $timestamp,
520                        'hash' => sha1($this->getSharedSecret().$timestamp),
521                        $key => $value);
522
523        if($offset !== null) {
524            $params['offset'] = (int)$offset;
525        }
526
527        if($limit !== null) {
528            $params['limit'] = (int)$limit;
529        }
530
531        $cache = $this->getCacheObject();
532
533        $cache_key = md5($key.$value.$offset.$limit);
534
535        if(!$retval = $cache->load($cache_key)) {
536
537            $client = $this->getHttpClient();
538
539            $client->setUri($queryUri);
540            $client->setParameterPost($params);
541
542            require_once 'Zend/Http/Client/Exception.php';
543            try {
544                $response = $client->request('POST');
545            } catch(Zend_Http_Client_Exception $e) {
546                require_once 'Zend/Service/SlideShare/Exception.php';
547                throw new Zend_Service_SlideShare_Exception("Service Request Failed: {$e->getMessage()}", 0, $e);
548            }
549
550            $sxe = simplexml_load_string($response->getBody());
551
552            if($sxe->getName() == "SlideShareServiceError") {
553                $message = (string)$sxe->Message[0];
554                list($code, $error_str) = explode(':', $message);
555                require_once 'Zend/Service/SlideShare/Exception.php';
556                throw new Zend_Service_SlideShare_Exception(trim($error_str), $code);
557            }
558
559            if(!$sxe->getName() == $responseTag) {
560                require_once 'Zend/Service/SlideShare/Exception.php';
561                throw new Zend_Service_SlideShare_Exception('Unknown or Invalid XML Repsonse Received');
562            }
563
564            $retval = array();
565
566            foreach($sxe->children() as $node) {
567                if($node->getName() == 'Slideshow') {
568                    $retval[] = $this->_slideShowNodeToObject($node);
569                }
570            }
571
572            $cache->save($retval, $cache_key);
573        }
574
575        return $retval;
576    }
577
578    /**
579     * Converts a SimpleXMLElement object representing a response from the service
580     * into a Zend_Service_SlideShare_SlideShow object
581     *
582     * @param SimpleXMLElement $node The input XML from the slideshare.net service
583     * @return Zend_Service_SlideShare_SlideShow The resulting object
584     */
585    protected function _slideShowNodeToObject(SimpleXMLElement $node)
586    {
587
588        if($node->getName() == 'Slideshow') {
589
590            $ss = new Zend_Service_SlideShare_SlideShow();
591
592            $ss->setId((string)$node->ID);
593            $ss->setDescription((string)$node->Description);
594            $ss->setEmbedCode((string)$node->EmbedCode);
595            $ss->setNumViews((string)$node->Views);
596            $ss->setPermaLink((string)$node->Permalink);
597            $ss->setStatus((string)$node->Status);
598            $ss->setStatusDescription((string)$node->StatusDescription);
599
600            foreach(explode(",", (string)$node->Tags) as $tag) {
601
602                if(!in_array($tag, $ss->getTags())) {
603                    $ss->addTag($tag);
604                }
605            }
606
607            $ss->setThumbnailUrl((string)$node->Thumbnail);
608            $ss->setTitle((string)$node->Title);
609            $ss->setLocation((string)$node->Location);
610            $ss->setTranscript((string)$node->Transcript);
611
612            return $ss;
613
614        }
615
616        require_once 'Zend/Service/SlideShare/Exception.php';
617        throw new Zend_Service_SlideShare_Exception("Was not provided the expected XML Node for processing");
618    }
619}