51292947113ba4a5996db8ea969340e509cf462c
[moodle.git] / lib / googleapi.php
1 <?php
2 /**
3  * Moodle - Modular Object-Oriented Dynamic Learning Environment
4  *          http://moodle.org
5  * Copyright (C) 1999 onwards Martin Dougiamas  http://dougiamas.com
6  *
7  * This program is free software: you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation, either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
19  *
20  * @package    core
21  * @subpackage lib
22  * @copyright Dan Poltawski <talktodan@gmail.com>
23  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24  *
25  * Simple implementation of some Google API functions for Moodle.
26  */
28 defined('MOODLE_INTERNAL') || die();
30  /** Include essential file */
31 require_once($CFG->libdir.'/filelib.php');
33 /**
34  * Base class for google authenticated http requests
35  *
36  * Most Google API Calls required that requests are sent with an
37  * Authorization header + token. This class extends the curl class
38  * to aid this
39  *
40  * @package    moodlecore
41  * @subpackage lib
42  * @copyright Dan Poltawski <talktodan@gmail.com>
43  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
44  */
45 abstract class google_auth_request extends curl {
46     protected $token = '';
47     private $persistantheaders = array();
49     // Must be overridden with the authorization header name
50     public static function get_auth_header_name() {
51         throw new coding_exception('get_auth_header_name() method needs to be overridden in each subclass of google_auth_request');
52     }
54     protected function request($url, $options = array()){
55         if($this->token){
56             // Adds authorisation head to a request so that it can be authentcated
57             $this->setHeader('Authorization: '. $this->get_auth_header_name().'"'.$this->token.'"');
58         }
60         foreach($this->persistantheaders as $h){
61             $this->setHeader($h);
62         }
64         $ret = parent::request($url, $options);
65         // reset headers for next request
66         $this->header = array();
67         return $ret;
68     }
70     protected function multi($requests, $options = array()) {
71         if($this->token){
72             // Adds authorisation head to a request so that it can be authentcated
73             $this->setHeader('Authorization: '. $this->get_auth_header_name().'"'.$this->token.'"');
74         }
76         foreach($this->persistantheaders as $h){
77             $this->setHeader($h);
78         }
80         $ret = parent::multi($requests, $options);
81         // reset headers for next request
82         $this->header = array();
83         return $ret;
84     }
86     public function get_sessiontoken(){
87         return $this->token;
88     }
90     public function add_persistant_header($header){
91         $this->persistantheaders[] = $header;
92     }
93 }
95 /*******
96  * The following two classes are usd to implement AuthSub google
97  * authtentication, as documented here:
98  * http://code.google.com/apis/accounts/docs/AuthSub.html
99  *******/
101 /**
102  * Used to uprade a google AuthSubRequest one-time token into
103  * a session token which can be used long term.
104  *
105  * @package    moodlecore
106  * @subpackage lib
107  * @copyright Dan Poltawski <talktodan@gmail.com>
108  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
109  */
110 class google_authsub_request extends google_auth_request {
111     const AUTHSESSION_URL = 'https://www.google.com/accounts/AuthSubSessionToken';
113     /**
114      * Constructor. Calls constructor of its parents
115      *
116      * @param string $authtoken The token to upgrade to a session token
117      */
118     public function __construct($authtoken){
119         parent::__construct();
120         $this->token = $authtoken;
121     }
123     /**
124      * Requests a long-term session token from google based on the
125      *
126      * @return string Sub-Auth token
127      */
128     public function get_session_token(){
129         $content = $this->get(google_authsub_request::AUTHSESSION_URL);
131         if( preg_match('/token=(.*)/i', $content, $matches) ){
132             return $matches[1];
133         }else{
134             throw new moodle_exception('could not upgrade google authtoken to session token');
135         }
136     }
138     public static function get_auth_header_name(){
139         return 'AuthSub token=';
140     }
143 /**
144  * Allows http calls using google subauth authorisation
145  *
146  * @package    moodlecore
147  * @subpackage lib
148  * @copyright Dan Poltawski <talktodan@gmail.com>
149  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
150  */
151 class google_authsub extends google_auth_request {
152     const LOGINAUTH_URL    = 'https://www.google.com/accounts/AuthSubRequest';
153     const VERIFY_TOKEN_URL = 'https://www.google.com/accounts/AuthSubTokenInfo';
154     const REVOKE_TOKEN_URL = 'https://www.google.com/accounts/AuthSubRevokeToken';
156     /**
157      * Constructor, allows subauth requests using the response from an initial
158      * AuthSubRequest or with the subauth long-term token. Note that constructing
159      * this object without a valid token will cause an exception to be thrown.
160      *
161      * @param string $sessiontoken A long-term subauth session token
162      * @param string $authtoken A one-time auth token wich is used to upgrade to session token
163      * @param mixed  @options Options to pass to the base curl object
164      */
165     public function __construct($sessiontoken = '', $authtoken = '', $options = array()){
166         parent::__construct($options);
168         if( $authtoken ){
169             $gauth = new google_authsub_request($authtoken);
170             $sessiontoken = $gauth->get_session_token();
171         }
173         $this->token = $sessiontoken;
174         if(! $this->valid_token() ){
175             throw new moodle_exception('Invalid subauth token');
176         }
177     }
179     /**
180      * Tests if a subauth token used is valid
181      *
182      * @return boolean true if token valid
183      */
184     public function valid_token(){
185         $this->get(google_authsub::VERIFY_TOKEN_URL);
187         if($this->info['http_code'] === 200){
188             return true;
189         }else{
190             return false;
191         }
192     }
194     /**
195      * Calls googles api to revoke the subauth token
196      *
197      * @return boolean Returns true if token succesfully revoked
198      */
199     public function revoke_session_token(){
200         $this->get(google_authsub::REVOKE_TOKEN_URL);
202         if($this->info['http_code'] === 200){
203             $this->token = '';
204             return true;
205         }else{
206             return false;
207         }
208     }
210     /**
211      * Creates a login url for subauth request
212      *
213      * @param string $returnaddr The address which the user should be redirected to recieve the token
214      * @param string $realm The google realm which is access is being requested
215      * @return string URL to bounce the user to
216      */
217     public static function login_url($returnaddr, $realm){
218         $uri = google_authsub::LOGINAUTH_URL.'?next='
219             .urlencode($returnaddr)
220             .'&scope='
221             .urlencode($realm)
222             .'&session=1&secure=0';
224         return $uri;
225     }
227     public static function get_auth_header_name(){
228         return 'AuthSub token=';
229     }
232 /**
233  * Class for manipulating google documents through the google data api
234  * Docs for this can be found here:
235  * {@link http://code.google.com/apis/documents/docs/2.0/developers_guide_protocol.html}
236  *
237  * @package    moodlecore
238  * @subpackage lib
239  * @copyright Dan Poltawski <talktodan@gmail.com>
240  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
241  */
242 class google_docs {
243     // need both docs and the spreadsheets realm
244     const REALM            = 'https://docs.google.com/feeds/ https://spreadsheets.google.com/feeds/ https://docs.googleusercontent.com/';
245     const DOCUMENTFEED_URL = 'https://docs.google.com/feeds/default/private/full';
246     const USER_PREF_NAME   = 'google_authsub_sesskey';
248     private $google_curl = null;
250     /**
251      * Constructor.
252      *
253      * @param object A google_auth_request object which can be used to do http requests
254      */
255     public function __construct($google_curl){
256         if(is_a($google_curl, 'google_auth_request')){
257             $this->google_curl = $google_curl;
258             $this->google_curl->add_persistant_header('GData-Version: 3.0');
259         }else{
260             throw new moodle_exception('Google Curl Request object not given');
261         }
262     }
264     public static function get_sesskey($userid){
265         return get_user_preferences(google_docs::USER_PREF_NAME, false, $userid);
266     }
268     public static function set_sesskey($value, $userid){
269         return set_user_preference(google_docs::USER_PREF_NAME, $value, $userid);
270     }
272     public static function delete_sesskey($userid){
273         return unset_user_preference(google_docs::USER_PREF_NAME, $userid);
274     }
276     /**
277      * Returns a list of files the user has formated for files api
278      *
279      * @param string $search A search string to do full text search on the documents
280      * @return mixed Array of files formated for fileapoi
281      */
282     #FIXME
283     public function get_file_list($search = ''){
284         global $CFG, $OUTPUT;
285         $url = google_docs::DOCUMENTFEED_URL;
287         if($search){
288             $url.='?q='.urlencode($search);
289         }
290         $content = $this->google_curl->get($url);
292         $xml = new SimpleXMLElement($content);
295         $files = array();
296         foreach($xml->entry as $gdoc){
297             $docid  = (string) $gdoc->children('http://schemas.google.com/g/2005')->resourceId;
298             list($type, $docid) = explode(':', $docid);
300             $title  = '';
301             $source = '';
302             // FIXME: We're making hard-coded choices about format here.
303             // If the repo api can support it, we could let the user
304             // chose.
305             switch($type){
306                 case 'document':
307                     $title = $gdoc->title.'.rtf';
308                     $source = 'https://docs.google.com/feeds/download/documents/Export?id='.$docid.'&exportFormat=rtf';
309                     break;
310                 case 'presentation':
311                     $title = $gdoc->title.'.ppt';
312                     $source = 'https://docs.google.com/feeds/download/presentations/Export?id='.$docid.'&exportFormat=ppt';
313                     break;
314                 case 'spreadsheet':
315                     $title = $gdoc->title.'.xls';
316                     $source = 'https://spreadsheets.google.com/feeds/download/spreadsheets/Export?key='.$docid.'&exportFormat=xls';
317                     break;
318                 case 'pdf':
319                     $title  = (string)$gdoc->title;
320                     $source = (string)$gdoc->content[0]->attributes()->src;
321                     break;
322                 case 'file':
323                     $title = (string)$gdoc->title;
324                     $source = (string)$gdoc->content[0]->attributes()->src;
325                     break;
326             }
328             if(!empty($source)){
329                 $files[] =  array( 'title' => $title,
330                     'url' => "{$gdoc->link[0]->attributes()->href}",
331                     'source' => $source,
332                     'date'   => usertime(strtotime($gdoc->updated)),
333                     'thumbnail' => (string) $OUTPUT->pix_url(file_extension_icon($title, 32))
334                 );
335             }
336         }
338         return $files;
339     }
341     /**
342      * Sends a file object to google documents
343      *
344      * @param object $file File object
345      * @return boolean True on success
346      */
347     public function send_file($file){
348         $this->google_curl->setHeader("Content-Length: ". $file->get_filesize());
349         $this->google_curl->setHeader("Content-Type: ". $file->get_mimetype());
350         $this->google_curl->setHeader("Slug: ". $file->get_filename());
352         $this->google_curl->post(google_docs::DOCUMENTFEED_URL, $file->get_content());
354         if($this->google_curl->info['http_code'] === 201){
355             return true;
356         }else{
357             return false;
358         }
359     }
361     public function download_file($url, $fp){
362         return $this->google_curl->download(array( array('url'=>$url, 'file' => $fp) ));
363     }
366 /**
367  * Class for manipulating picasa through the google data api
368  * Docs for this can be found here:
369  * {@link http://code.google.com/apis/picasaweb/developers_guide_protocol.html}
370  *
371  * @package    moodlecore
372  * @subpackage lib
373  * @copyright Dan Poltawski <talktodan@gmail.com>
374  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
375  */
376 class google_picasa {
377     const REALM             = 'http://picasaweb.google.com/data/';
378     const USER_PREF_NAME    = 'google_authsub_sesskey_picasa';
379     const UPLOAD_LOCATION   = 'https://picasaweb.google.com/data/feed/api/user/default/albumid/default';
380     const ALBUM_PHOTO_LIST  = 'https://picasaweb.google.com/data/feed/api/user/default/albumid/';
381     const PHOTO_SEARCH_URL  = 'https://picasaweb.google.com/data/feed/api/user/default?kind=photo&q=';
382     const LIST_ALBUMS_URL   = 'https://picasaweb.google.com/data/feed/api/user/default';
383     const MANAGE_URL        = 'http://picasaweb.google.com/';
385     private $google_curl = null;
386     private $lastalbumname = null;
388     /**
389      * Constructor.
390      *
391      * @param object A google_auth_request object which can be used to do http requests
392      */
393     public function __construct($google_curl){
394         if(is_a($google_curl, 'google_auth_request')){
395             $this->google_curl = $google_curl;
396             $this->google_curl->add_persistant_header('GData-Version: 2');
397         }else{
398             throw new moodle_exception('Google Curl Request object not given');
399         }
400     }
402     public static function get_sesskey($userid){
403         return get_user_preferences(google_picasa::USER_PREF_NAME, false, $userid);
404     }
406     public static function set_sesskey($value, $userid){
407         return set_user_preference(google_picasa::USER_PREF_NAME, $value, $userid);
408     }
410     public static function delete_sesskey($userid){
411         return unset_user_preference(google_picasa::USER_PREF_NAME, $userid);
412     }
414     /**
415      * Sends a file object to picasaweb
416      *
417      * @param object $file File object
418      * @return boolean True on success
419      */
420     public function send_file($file){
421         $this->google_curl->setHeader("Content-Length: ". $file->get_filesize());
422         $this->google_curl->setHeader("Content-Type: ". $file->get_mimetype());
423         $this->google_curl->setHeader("Slug: ". $file->get_filename());
425         $this->google_curl->post(google_picasa::UPLOAD_LOCATION, $file->get_content());
427         if($this->google_curl->info['http_code'] === 201){
428             return true;
429         }else{
430             return false;
431         }
432     }
434     /**
435      * Returns list of photos for file picker.
436      * If top level then returns list of albums, otherwise
437      * photos within an album.
438      *
439      * @param string $path The path to files (assumed to be albumid)
440      * @return mixed $files A list of files for the file picker
441      */
442     public function get_file_list($path = ''){
443         if(!$path){
444             return $this->get_albums();
445         }else{
446             return $this->get_album_photos($path);
447         }
448     }
450     /**
451      * Returns list of photos in album specified
452      *
453      * @param int $albumid Photo album to list photos from
454      * @return mixed $files A list of files for the file picker
455      */
456     public function get_album_photos($albumid){
457         $albumcontent = $this->google_curl->get(google_picasa::ALBUM_PHOTO_LIST.$albumid);
459         return $this->get_photo_details($albumcontent);
460     }
462     /**
463      * Returns the name of the album for which get_photo_details was called last time.
464      *
465      * @return string
466      */
467     public function get_last_album_name() {
468         return $this->lastalbumname;
469     }
471     /**
472      * Does text search on the users photos and returns
473      * matches in format for picasa api
474      *
475      * @param string $query Search terms
476      * @return mixed $files A list of files for the file picker
477      */
478     public function do_photo_search($query){
479         $content = $this->google_curl->get(google_picasa::PHOTO_SEARCH_URL.htmlentities($query));
481         return $this->get_photo_details($content);
482     }
484     /**
485      * Gets all the users albums and returns them as a list of folders
486      * for the file picker
487      *
488      * @return mixes $files Array in the format get_listing uses for folders
489      */
490     public function get_albums(){
491         $content = $this->google_curl->get(google_picasa::LIST_ALBUMS_URL);
492         $xml = new SimpleXMLElement($content);
494         $files = array();
496         foreach($xml->entry as $album){
497             $gphoto = $album->children('http://schemas.google.com/photos/2007');
499             $mediainfo = $album->children('http://search.yahoo.com/mrss/');
500             //hacky...
501             $thumbnailinfo = $mediainfo->group->thumbnail[0]->attributes();
503             $files[] = array( 'title' => (string) $album->title,
504                 'date'  => userdate($gphoto->timestamp),
505                 'size'  => (int) $gphoto->bytesUsed,
506                 'path'  => (string) $gphoto->id,
507                 'thumbnail' => (string) $thumbnailinfo['url'],
508                 'thumbnail_width' => 160,  // 160 is the native maximum dimension
509                 'thumbnail_height' => 160,
510                 'children' => array(),
511             );
513         }
515         return $files;
516     }
518     /**
519      * Recieves XML from a picasa list of photos and returns
520      * array in format for file picker.
521      *
522      * @param string $rawxml XML from picasa api
523      * @return mixed $files A list of files for the file picker
524      */
525     public function get_photo_details($rawxml){
527         $xml = new SimpleXMLElement($rawxml);
528         $this->lastalbumname = (string)$xml->title;
530         $files = array();
532         foreach($xml->entry as $photo){
533             $gphoto = $photo->children('http://schemas.google.com/photos/2007');
535             $mediainfo = $photo->children('http://search.yahoo.com/mrss/');
536             $fullinfo = $mediainfo->group->content->attributes();
537             //hacky...
538             $thumbnailinfo = $mediainfo->group->thumbnail[0]->attributes();
540             // Derive the nicest file name we can
541             if (!empty($mediainfo->group->description)) {
542                 $title = shorten_text((string)$mediainfo->group->description, 20, false, '');
543                 $title = clean_filename($title).'.jpg';
544             } else {
545                 $title = (string)$mediainfo->group->title;
546             }
548             $files[] = array(
549                 'title' => $title,
550                 'date'  => userdate($gphoto->timestamp),
551                 'size' => (int) $gphoto->size,
552                 'path' => $gphoto->albumid.'/'.$gphoto->id,
553                 'thumbnail' => (string) $thumbnailinfo['url'],
554                 'thumbnail_width' => 72,  // 72 is the native maximum dimension
555                 'thumbnail_height' => 72,
556                 'source' => (string) $fullinfo['url'],
557                 'url' => (string) $fullinfo['url']
558             );
559         }
561         return $files;
562     }
566 /**
567  * Beginings of an implementation of Clientogin authenticaton for google
568  * accounts as documented here:
569  * {@link http://code.google.com/apis/accounts/docs/AuthForInstalledApps.html#ClientLogin}
570  *
571  * With this authentication we have to accept a username and password and to post
572  * it to google. Retrieving a token for use afterwards.
573  *
574  * @package    moodlecore
575  * @subpackage lib
576  * @copyright Dan Poltawski <talktodan@gmail.com>
577  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
578  */
579 class google_authclient extends google_auth_request {
580     const LOGIN_URL = 'https://www.google.com/accounts/ClientLogin';
582     public function __construct($sessiontoken = '', $username = '', $password = '', $options = array() ){
583         parent::__construct($options);
585         if($username and $password){
586             $param =  array(
587                 'accountType'=>'GOOGLE',
588                 'Email'=>$username,
589                 'Passwd'=>$password,
590                 'service'=>'writely'
591             );
593             $content = $this->post(google_authclient::LOGIN_URL, $param);
595             if( preg_match('/auth=(.*)/i', $content, $matches) ){
596                 $sessiontoken = $matches[1];
597             }else{
598                 throw new moodle_exception('could not upgrade authtoken');
599             }
601         }
603         if($sessiontoken){
604             $this->token = $sessiontoken;
605         }else{
606             throw new moodle_exception('no session token specified');
607         }
608     }
610     public static function get_auth_header_name(){
611         return 'GoogleLogin auth=';
612     }