09d9518e2236914fbee6b9013220cc1c5c448b28
[moodle.git] / repository / googledocs / lib.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * This plugin is used to access Google Drive.
19  *
20  * @since Moodle 2.0
21  * @package    repository_googledocs
22  * @copyright  2009 Dan Poltawski <talktodan@gmail.com>
23  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24  */
26 defined('MOODLE_INTERNAL') || die();
28 require_once($CFG->dirroot . '/repository/lib.php');
29 require_once($CFG->libdir . '/filebrowser/file_browser.php');
31 /**
32  * Google Docs Plugin
33  *
34  * @since Moodle 2.0
35  * @package    repository_googledocs
36  * @copyright  2009 Dan Poltawski <talktodan@gmail.com>
37  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
38  */
39 class repository_googledocs extends repository {
41     /**
42      * OAuth 2 client
43      * @var \core\oauth2\client
44      */
45     private $client = null;
47     /**
48      * OAuth 2 Issuer
49      * @var \core\oauth2\issuer
50      */
51     private $issuer = null;
53     /**
54      * Additional scopes required for drive.
55      */
56     const SCOPES = 'https://www.googleapis.com/auth/drive';
58     /**
59      * Constructor.
60      *
61      * @param int $repositoryid repository instance id.
62      * @param int|stdClass $context a context id or context object.
63      * @param array $options repository options.
64      * @param int $readonly indicate this repo is readonly or not.
65      * @return void
66      */
67     public function __construct($repositoryid, $context = SYSCONTEXTID, $options = array(), $readonly = 0) {
68         parent::__construct($repositoryid, $context, $options, $readonly = 0);
70         try {
71             $this->issuer = \core\oauth2\api::get_issuer(get_config('googledocs', 'issuerid'));
72         } catch (dml_missing_record_exception $e) {
73             $this->disabled = true;
74         }
76         if ($this->issuer && !$this->issuer->get('enabled')) {
77             $this->disabled = true;
78         }
79     }
81     /**
82      * Get a cached user authenticated oauth client.
83      *
84      * @param moodle_url $overrideurl - Use this url instead of the repo callback.
85      * @return \core\oauth2\client
86      */
87     protected function get_user_oauth_client($overrideurl = false) {
88         if ($this->client) {
89             return $this->client;
90         }
91         if ($overrideurl) {
92             $returnurl = $overrideurl;
93         } else {
94             $returnurl = new moodle_url('/repository/repository_callback.php');
95             $returnurl->param('callback', 'yes');
96             $returnurl->param('repo_id', $this->id);
97             $returnurl->param('sesskey', sesskey());
98         }
100         $this->client = \core\oauth2\api::get_user_oauth_client($this->issuer, $returnurl, self::SCOPES);
102         return $this->client;
103     }
105     /**
106      * Checks whether the user is authenticate or not.
107      *
108      * @return bool true when logged in.
109      */
110     public function check_login() {
111         $client = $this->get_user_oauth_client();
112         return $client->is_logged_in();
113     }
115     /**
116      * Print or return the login form.
117      *
118      * @return void|array for ajax.
119      */
120     public function print_login() {
121         $client = $this->get_user_oauth_client();
122         $url = $client->get_login_url();
124         if ($this->options['ajax']) {
125             $popup = new stdClass();
126             $popup->type = 'popup';
127             $popup->url = $url->out(false);
128             return array('login' => array($popup));
129         } else {
130             echo '<a target="_blank" href="'.$url->out(false).'">'.get_string('login', 'repository').'</a>';
131         }
132     }
134     /**
135      * Build the breadcrumb from a path.
136      *
137      * @param string $path to create a breadcrumb from.
138      * @return array containing name and path of each crumb.
139      */
140     protected function build_breadcrumb($path) {
141         $bread = explode('/', $path);
142         $crumbtrail = '';
143         foreach ($bread as $crumb) {
144             list($id, $name) = $this->explode_node_path($crumb);
145             $name = empty($name) ? $id : $name;
146             $breadcrumb[] = array(
147                 'name' => $name,
148                 'path' => $this->build_node_path($id, $name, $crumbtrail)
149             );
150             $tmp = end($breadcrumb);
151             $crumbtrail = $tmp['path'];
152         }
153         return $breadcrumb;
154     }
156     /**
157      * Generates a safe path to a node.
158      *
159      * Typically, a node will be id|Name of the node.
160      *
161      * @param string $id of the node.
162      * @param string $name of the node, will be URL encoded.
163      * @param string $root to append the node on, must be a result of this function.
164      * @return string path to the node.
165      */
166     protected function build_node_path($id, $name = '', $root = '') {
167         $path = $id;
168         if (!empty($name)) {
169             $path .= '|' . urlencode($name);
170         }
171         if (!empty($root)) {
172             $path = trim($root, '/') . '/' . $path;
173         }
174         return $path;
175     }
177     /**
178      * Returns information about a node in a path.
179      *
180      * @see self::build_node_path()
181      * @param string $node to extrat information from.
182      * @return array about the node.
183      */
184     protected function explode_node_path($node) {
185         if (strpos($node, '|') !== false) {
186             list($id, $name) = explode('|', $node, 2);
187             $name = urldecode($name);
188         } else {
189             $id = $node;
190             $name = '';
191         }
192         $id = urldecode($id);
193         return array(
194             0 => $id,
195             1 => $name,
196             'id' => $id,
197             'name' => $name
198         );
199     }
201     /**
202      * List the files and folders.
203      *
204      * @param  string $path path to browse.
205      * @param  string $page page to browse.
206      * @return array of result.
207      */
208     public function get_listing($path='', $page = '') {
209         if (empty($path)) {
210             $path = $this->build_node_path('root', get_string('pluginname', 'repository_googledocs'));
211         }
212         if (!$this->issuer->get('enabled')) {
213             // Empty list of files for disabled repository.
214             return ['dynload' => false, 'list' => [], 'nologin' => true];
215         }
217         // We analyse the path to extract what to browse.
218         $trail = explode('/', $path);
219         $uri = array_pop($trail);
220         list($id, $name) = $this->explode_node_path($uri);
222         // Handle the special keyword 'search', which we defined in self::search() so that
223         // we could set up a breadcrumb in the search results. In any other case ID would be
224         // 'root' which is a special keyword set up by Google, or a parent (folder) ID.
225         if ($id === 'search') {
226             return $this->search($name);
227         }
229         // Query the Drive.
230         $q = "'" . str_replace("'", "\'", $id) . "' in parents";
231         $q .= ' AND trashed = false';
232         $results = $this->query($q, $path);
234         $ret = array();
235         $ret['dynload'] = true;
236         $ret['defaultreturntype'] = $this->default_returntype();
237         $ret['path'] = $this->build_breadcrumb($path);
238         $ret['list'] = $results;
239         $ret['manage'] = 'https://drive.google.com/';
241         return $ret;
242     }
244     /**
245      * Search throughout the Google Drive.
246      *
247      * @param string $searchtext text to search for.
248      * @param int $page search page.
249      * @return array of results.
250      */
251     public function search($searchtext, $page = 0) {
252         $path = $this->build_node_path('root', get_string('pluginname', 'repository_googledocs'));
253         $str = get_string('searchfor', 'repository_googledocs', $searchtext);
254         $path = $this->build_node_path('search', $str, $path);
256         // Query the Drive.
257         $q = "fullText contains '" . str_replace("'", "\'", $searchtext) . "'";
258         $q .= ' AND trashed = false';
259         $results = $this->query($q, $path);
261         $ret = array();
262         $ret['dynload'] = true;
263         $ret['path'] = $this->build_breadcrumb($path);
264         $ret['list'] = $results;
265         $ret['manage'] = 'https://drive.google.com/';
266         return $ret;
267     }
269     /**
270      * Query Google Drive for files and folders using a search query.
271      *
272      * Documentation about the query format can be found here:
273      *   https://developers.google.com/drive/search-parameters
274      *
275      * This returns a list of files and folders with their details as they should be
276      * formatted and returned by functions such as get_listing() or search().
277      *
278      * @param string $q search query as expected by the Google API.
279      * @param string $path parent path of the current files, will not be used for the query.
280      * @param int $page page.
281      * @return array of files and folders.
282      */
283     protected function query($q, $path = null, $page = 0) {
284         global $OUTPUT;
286         $files = array();
287         $folders = array();
288         $config = get_config('googledocs');
289         $fields = "files(id,name,mimeType,webContentLink,webViewLink,fileExtension,modifiedTime,size,thumbnailLink,iconLink)";
290         $params = array('q' => $q, 'fields' => $fields, 'spaces' => 'drive');
292         try {
293             // Retrieving files and folders.
294             $client = $this->get_user_oauth_client();
295             $service = new repository_googledocs\rest($client);
297             $response = $service->call('list', $params);
298         } catch (Exception $e) {
299             if ($e->getCode() == 403 && strpos($e->getMessage(), 'Access Not Configured') !== false) {
300                 // This is raised when the service Drive API has not been enabled on Google APIs control panel.
301                 throw new repository_exception('servicenotenabled', 'repository_googledocs');
302             } else {
303                 throw $e;
304             }
305         }
307         $gfiles = isset($response->files) ? $response->files : array();
308         foreach ($gfiles as $gfile) {
309             if ($gfile->mimeType == 'application/vnd.google-apps.folder') {
310                 // This is a folder.
311                 $folders[$gfile->name . $gfile->id] = array(
312                     'title' => $gfile->name,
313                     'path' => $this->build_node_path($gfile->id, $gfile->name, $path),
314                     'date' => strtotime($gfile->modifiedTime),
315                     'thumbnail' => $OUTPUT->image_url(file_folder_icon(64))->out(false),
316                     'thumbnail_height' => 64,
317                     'thumbnail_width' => 64,
318                     'children' => array()
319                 );
320             } else {
321                 // This is a file.
322                 $link = isset($gfile->webViewLink) ? $gfile->webViewLink : '';
323                 if (empty($link)) {
324                     $link = isset($gfile->webContentLink) ? $gfile->webContentLink : '';
325                 }
326                 if (isset($gfile->fileExtension)) {
327                     // The file has an extension, therefore we can download it.
328                     $source = json_encode([
329                         'id' => $gfile->id,
330                         'name' => $gfile->name,
331                         'exportformat' => 'download',
332                         'link' => $link
333                     ]);
334                     $title = $gfile->name;
335                 } else {
336                     // The file is probably a Google Doc file, we get the corresponding export link.
337                     // This should be improved by allowing the user to select the type of export they'd like.
338                     $type = str_replace('application/vnd.google-apps.', '', $gfile->mimeType);
339                     $title = '';
340                     $exporttype = '';
341                     $types = get_mimetypes_array();
343                     switch ($type){
344                         case 'document':
345                             $ext = $config->documentformat;
346                             $title = $gfile->name . '.gdoc';
347                             if ($ext === 'rtf') {
348                                 // Moodle user 'text/rtf' as the MIME type for RTF files.
349                                 // Google uses 'application/rtf' for the same type of file.
350                                 // See https://developers.google.com/drive/v3/web/manage-downloads.
351                                 $exporttype = 'application/rtf';
352                             } else {
353                                 $exporttype = $types[$ext]['type'];
354                             }
355                             break;
356                         case 'presentation':
357                             $ext = $config->presentationformat;
358                             $title = $gfile->name . '.gslides';
359                             $exporttype = $types[$ext]['type'];
360                             break;
361                         case 'spreadsheet':
362                             $ext = $config->spreadsheetformat;
363                             $title = $gfile->name . '.gsheet';
364                             $exporttype = $types[$ext]['type'];
365                             break;
366                         case 'drawing':
367                             $ext = $config->drawingformat;
368                             $title = $gfile->name . '.'. $ext;
369                             $exporttype = $types[$ext]['type'];
370                             break;
371                     }
372                     // Skips invalid/unknown types.
373                     if (empty($title)) {
374                         continue;
375                     }
376                     $source = json_encode([
377                         'id' => $gfile->id,
378                         'exportformat' => $exporttype,
379                         'link' => $link,
380                         'name' => $gfile->name
381                     ]);
382                 }
383                 // Adds the file to the file list. Using the itemId along with the name as key
384                 // of the array because Google Drive allows files with identical names.
385                 $thumb = '';
386                 if (isset($gfile->thumbnailLink)) {
387                     $thumb = $gfile->thumbnailLink;
388                 } else if (isset($gfile->iconLink)) {
389                     $thumb = $gfile->iconLink;
390                 }
391                 $files[$title . $gfile->id] = array(
392                     'title' => $title,
393                     'source' => $source,
394                     'date' => strtotime($gfile->modifiedTime),
395                     'size' => isset($gfile->size) ? $gfile->size : null,
396                     'thumbnail' => $thumb,
397                     'thumbnail_height' => 64,
398                     'thumbnail_width' => 64,
399                 );
400             }
401         }
403         // Filter and order the results.
404         $files = array_filter($files, array($this, 'filter'));
405         core_collator::ksort($files, core_collator::SORT_NATURAL);
406         core_collator::ksort($folders, core_collator::SORT_NATURAL);
407         return array_merge(array_values($folders), array_values($files));
408     }
410     /**
411      * Logout.
412      *
413      * @return string
414      */
415     public function logout() {
416         $client = $this->get_user_oauth_client();
417         $client->log_out();
418         return parent::logout();
419     }
421     /**
422      * Get a file.
423      *
424      * @param string $reference reference of the file.
425      * @param string $file name to save the file to.
426      * @return string JSON encoded array of information about the file.
427      */
428     public function get_file($reference, $filename = '') {
429         global $CFG;
431         if (!$this->issuer->get('enabled')) {
432             throw new repository_exception('cannotdownload', 'repository');
433         }
435         $source = json_decode($reference);
437         $client = null;
438         if (!empty($source->usesystem)) {
439             $client = \core\oauth2\api::get_system_oauth_client($this->issuer);
440         } else {
441             $client = $this->get_user_oauth_client();
442         }
444         $base = 'https://www.googleapis.com/drive/v3';
446         $newfilename = false;
447         if ($source->exportformat == 'download') {
448             $params = ['alt' => 'media'];
449             $sourceurl = new moodle_url($base . '/files/' . $source->id, $params);
450             $source = $sourceurl->out(false);
451         } else {
452             $params = ['mimeType' => $source->exportformat];
453             $sourceurl = new moodle_url($base . '/files/' . $source->id . '/export', $params);
454             $types = get_mimetypes_array();
455             $checktype = $source->exportformat;
456             if ($checktype == 'application/rtf') {
457                 $checktype = 'text/rtf';
458             }
459             foreach ($types as $extension => $info) {
460                 if ($info['type'] == $checktype) {
461                     $newfilename = $source->name . '.' . $extension;
462                     break;
463                 }
464             }
465             $source = $sourceurl->out(false);
466         }
468         // We use download_one and not the rest API because it has special timeouts etc.
469         $path = $this->prepare_file($filename);
470         $options = ['filepath' => $path, 'timeout' => 15, 'followlocation' => true, 'maxredirs' => 5];
471         $success = $client->download_one($source, null, $options);
473         if ($success) {
474             @chmod($path, $CFG->filepermissions);
476             $result = [
477                 'path' => $path,
478                 'url' => $reference,
479             ];
480             if (!empty($newfilename)) {
481                 $result['newfilename'] = $newfilename;
482             }
483             return $result;
484         }
485         throw new repository_exception('cannotdownload', 'repository');
486     }
488     /**
489      * Prepare file reference information.
490      *
491      * We are using this method to clean up the source to make sure that it
492      * is a valid source.
493      *
494      * @param string $source of the file.
495      * @return string file reference.
496      */
497     public function get_file_reference($source) {
498         // We could do some magic upgrade code here.
499         return $source;
500     }
502     /**
503      * What kind of files will be in this repository?
504      *
505      * @return array return '*' means this repository support any files, otherwise
506      *               return mimetypes of files, it can be an array
507      */
508     public function supported_filetypes() {
509         return '*';
510     }
512     /**
513      * Tells how the file can be picked from this repository.
514      *
515      * @return int
516      */
517     public function supported_returntypes() {
518         // We can only support references if the system account is connected.
519         if (!empty($this->issuer) && $this->issuer->is_system_account_connected()) {
520             $setting = get_config('googledocs', 'supportedreturntypes');
521             if ($setting == 'internal') {
522                 return FILE_INTERNAL;
523             } else if ($setting == 'external') {
524                 return FILE_CONTROLLED_LINK;
525             } else {
526                 return FILE_CONTROLLED_LINK | FILE_INTERNAL;
527             }
528         } else {
529             return FILE_INTERNAL;
530         }
531     }
533     /**
534      * Which return type should be selected by default.
535      *
536      * @return int
537      */
538     public function default_returntype() {
539         $setting = get_config('googledocs', 'defaultreturntype');
540         $supported = get_config('googledocs', 'supportedreturntypes');
541         if (($setting == FILE_INTERNAL && $supported != 'external') || $supported == 'internal') {
542             return FILE_INTERNAL;
543         } else {
544             return FILE_CONTROLLED_LINK;
545         }
546     }
548     /**
549      * Return names of the general options.
550      * By default: no general option name.
551      *
552      * @return array
553      */
554     public static function get_type_option_names() {
555         return array('issuerid', 'pluginname',
556             'documentformat', 'drawingformat',
557             'presentationformat', 'spreadsheetformat',
558             'defaultreturntype', 'supportedreturntypes');
559     }
561     /**
562      * Store the access token.
563      */
564     public function callback() {
565         $client = $this->get_user_oauth_client();
566         // This will upgrade to an access token if we have an authorization code and save the access token in the session.
567         $client->is_logged_in();
568     }
570     /**
571      * Repository method to serve the referenced file
572      *
573      * @see send_stored_file
574      *
575      * @param stored_file $storedfile the file that contains the reference
576      * @param int $lifetime Number of seconds before the file should expire from caches (null means $CFG->filelifetime)
577      * @param int $filter 0 (default)=no filtering, 1=all files, 2=html files only
578      * @param bool $forcedownload If true (default false), forces download of file rather than view in browser/plugin
579      * @param array $options additional options affecting the file serving
580      */
581     public function send_file($storedfile, $lifetime=null , $filter=0, $forcedownload=false, array $options = null) {
582         if (!$this->issuer->get('enabled')) {
583             throw new repository_exception('cannotdownload', 'repository');
584         }
586         $source = json_decode($storedfile->get_reference());
588         $fb = get_file_browser();
589         $context = context::instance_by_id($storedfile->get_contextid(), MUST_EXIST);
590         $info = $fb->get_file_info($context,
591                                    $storedfile->get_component(),
592                                    $storedfile->get_filearea(),
593                                    $storedfile->get_itemid(),
594                                    $storedfile->get_filepath(),
595                                    $storedfile->get_filename());
597         if (empty($options['offline']) && !empty($info) && $info->is_writable() && !empty($source->usesystem)) {
598             // Add the current user as an OAuth writer.
599             $systemauth = \core\oauth2\api::get_system_oauth_client($this->issuer);
601             if ($systemauth === false) {
602                 $details = 'Cannot connect as system user';
603                 throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
604             }
605             $systemservice = new repository_googledocs\rest($systemauth);
607             // Get the user oauth so we can get the account to add.
608             $url = moodle_url::make_pluginfile_url($storedfile->get_contextid(),
609                                                    $storedfile->get_component(),
610                                                    $storedfile->get_filearea(),
611                                                    $storedfile->get_itemid(),
612                                                    $storedfile->get_filepath(),
613                                                    $storedfile->get_filename(),
614                                                    $forcedownload);
615             $url->param('sesskey', sesskey());
616             $userauth = $this->get_user_oauth_client($url);
617             if (!$userauth->is_logged_in()) {
618                 redirect($userauth->get_login_url());
619             }
620             if ($userauth === false) {
621                 $details = 'Cannot connect as current user';
622                 throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
623             }
624             $userinfo = $userauth->get_userinfo();
625             $useremail = $userinfo['email'];
627             $this->add_temp_writer_to_file($systemservice, $source->id, $useremail);
628         }
630         if (!empty($options['offline'])) {
631             $downloaded = $this->get_file($storedfile->get_reference(), $storedfile->get_filename());
633             $filename = $storedfile->get_filename();
634             if (isset($downloaded['newfilename'])) {
635                 $filename = $downloaded['newfilename'];
636             }
637             send_file($downloaded['path'], $filename, $lifetime, $filter, false, $forcedownload, '', false, $options);
638         } else if ($source->link) {
639             redirect($source->link);
640         } else {
641             $details = 'File is missing source link';
642             throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
643         }
644     }
646     /**
647      * See if a folder exists within a folder
648      *
649      * @param \repository_googledocs\rest $client Authenticated client.
650      * @param string $foldername The folder we are looking for.
651      * @param string $parentid The parent folder we are looking in.
652      * @return string|boolean The file id if it exists or false.
653      */
654     protected function folder_exists_in_folder(\repository_googledocs\rest $client, $foldername, $parentid) {
655         $q = '\'' . addslashes($parentid) . '\' in parents and trashed = false and name = \'' . addslashes($foldername). '\'';
656         $fields = 'files(id, name)';
657         $params = [ 'q' => $q, 'fields' => $fields];
658         $response = $client->call('list', $params);
659         $missing = true;
660         foreach ($response->files as $child) {
661             if ($child->name == $foldername) {
662                 return $child->id;
663             }
664         }
665         return false;
666     }
668     /**
669      * Create a folder within a folder
670      *
671      * @param \repository_googledocs\rest $client Authenticated client.
672      * @param string $foldername The folder we are creating.
673      * @param string $parentid The parent folder we are creating in.
674      *
675      * @return string The file id of the new folder.
676      */
677     protected function create_folder_in_folder(\repository_googledocs\rest $client, $foldername, $parentid) {
678         $fields = 'id';
679         $params = ['fields' => $fields];
680         $folder = ['mimeType' => 'application/vnd.google-apps.folder', 'name' => $foldername, 'parents' => [$parentid]];
681         $created = $client->call('create', $params, json_encode($folder));
682         if (empty($created->id)) {
683             $details = 'Cannot create folder:' . $foldername;
684             throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
685         }
686         return $created->id;
687     }
689     /**
690      * Get simple file info for humans.
691      *
692      * @param \repository_googledocs\rest $client Authenticated client.
693      * @param string $fileid The file we are querying.
694      *
695      * @return stdClass
696      */
697     protected function get_file_summary(\repository_googledocs\rest $client, $fileid) {
698         $fields = "id,name,owners,parents";
699         $params = [
700             'fileid' => $fileid,
701             'fields' => $fields
702         ];
703         return $client->call('get', $params);
704     }
706     /**
707      * Copy a file and return the new file details. A side effect of the copy
708      * is that the owner will be the account authenticated with this oauth client.
709      *
710      * @param \repository_googledocs\rest $client Authenticated client.
711      * @param string $fileid The file we are copying.
712      * @param string $name The original filename (don't change it).
713      *
714      * @return stdClass file details.
715      */
716     protected function copy_file(\repository_googledocs\rest $client, $fileid, $name) {
717         $fields = "id,name,mimeType,webContentLink,webViewLink,size,thumbnailLink,iconLink";
718         $params = [
719             'fileid' => $fileid,
720             'fields' => $fields,
721         ];
722         // Keep the original name (don't put copy at the end of it).
723         $copyinfo = [];
724         if (!empty($name)) {
725             $copyinfo = [ 'name' => $name ];
726         }
727         $fileinfo = $client->call('copy', $params, json_encode($copyinfo));
728         if (empty($fileinfo->id)) {
729             $details = 'Cannot copy file:' . $fileid;
730             throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
731         }
732         return $fileinfo;
733     }
735     /**
736      * Add a writer to the permissions on the file (temporary).
737      *
738      * @param \repository_googledocs\rest $client Authenticated client.
739      * @param string $fileid The file we are updating.
740      * @param string $email The email of the writer account to add.
741      * @return boolean
742      */
743     protected function add_temp_writer_to_file(\repository_googledocs\rest $client, $fileid, $email) {
744         // Expires in 7 days.
745         $expires = new DateTime();
746         $expires->add(new DateInterval("P7D"));
748         $updateeditor = [
749             'emailAddress' => $email,
750             'role' => 'writer',
751             'type' => 'user',
752             'expirationTime' => $expires->format(DateTime::RFC3339)
753         ];
754         $params = ['fileid' => $fileid, 'sendNotificationEmail' => 'false'];
755         $response = $client->call('create_permission', $params, json_encode($updateeditor));
756         if (empty($response->id)) {
757             $details = 'Cannot add user ' . $email . ' as a writer for document: ' . $fileid;
758             throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
759         }
760         return true;
761     }
764     /**
765      * Add a writer to the permissions on the file.
766      *
767      * @param \repository_googledocs\rest $client Authenticated client.
768      * @param string $fileid The file we are updating.
769      * @param string $email The email of the writer account to add.
770      * @return boolean
771      */
772     protected function add_writer_to_file(\repository_googledocs\rest $client, $fileid, $email) {
773         $updateeditor = [
774             'emailAddress' => $email,
775             'role' => 'writer',
776             'type' => 'user'
777         ];
778         $params = ['fileid' => $fileid, 'sendNotificationEmail' => 'false'];
779         $response = $client->call('create_permission', $params, json_encode($updateeditor));
780         if (empty($response->id)) {
781             $details = 'Cannot add user ' . $email . ' as a writer for document: ' . $fileid;
782             throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
783         }
784         return true;
785     }
787     /**
788      * Move from root to folder
789      *
790      * @param \repository_googledocs\rest $client Authenticated client.
791      * @param string $fileid The file we are updating.
792      * @param string $folderid The id of the folder we are moving to
793      * @return boolean
794      */
795     protected function move_file_from_root_to_folder(\repository_googledocs\rest $client, $fileid, $folderid) {
796         // Set the parent.
797         $params = [
798             'fileid' => $fileid, 'addParents' => $folderid, 'removeParents' => 'root'
799         ];
800         $response = $client->call('update', $params, ' ');
801         if (empty($response->id)) {
802             $details = 'Cannot move the file to a folder: ' . $fileid;
803             throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
804         }
805         return true;
806     }
808     /**
809      * Prevent writers from sharing.
810      *
811      * @param \repository_googledocs\rest $client Authenticated client.
812      * @param string $fileid The file we are updating.
813      * @return boolean
814      */
815     protected function prevent_writers_from_sharing_file(\repository_googledocs\rest $client, $fileid) {
816         // We don't want anyone but Moodle to change the sharing settings.
817         $params = [
818             'fileid' => $fileid
819         ];
820         $update = [
821             'writersCanShare' => false
822         ];
823         $response = $client->call('update', $params, json_encode($update));
824         if (empty($response->id)) {
825             $details = 'Cannot prevent writers from sharing document: ' . $fileid;
826             throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
827         }
828         return true;
829     }
831     /**
832      * Allow anyone with the link to read the file.
833      *
834      * @param \repository_googledocs\rest $client Authenticated client.
835      * @param string $fileid The file we are updating.
836      * @return boolean
837      */
838     protected function set_file_sharing_anyone_with_link_can_read(\repository_googledocs\rest $client, $fileid) {
839         $updateread = [
840             'type' => 'anyone',
841             'role' => 'reader',
842             'allowFileDiscovery' => 'false'
843         ];
844         $params = ['fileid' => $fileid];
845         $response = $client->call('create_permission', $params, json_encode($updateread));
846         if (empty($response->id) || $response->id != 'anyoneWithLink') {
847             $details = 'Cannot update link sharing for the document: ' . $fileid;
848             throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
849         }
850         return true;
851     }
853     /**
854      * Called when a file is selected as a "link".
855      * Invoked at MOODLE/repository/repository_ajax.php
856      *
857      * This is called at the point the reference files are being copied from the draft area to the real area
858      * (when the file has really really been selected.
859      *
860      * @param string $reference this reference is generated by
861      *                          repository::get_file_reference()
862      * @param context $context the target context for this new file.
863      * @param string $component the target component for this new file.
864      * @param string $filearea the target filearea for this new file.
865      * @param string $itemid the target itemid for this new file.
866      * @return string updated reference (final one before it's saved to db).
867      */
868     public function reference_file_selected($reference, $context, $component, $filearea, $itemid) {
869         // What we need to do here is transfer ownership to the system user (or copy)
870         // then set the permissions so anyone with the share link can view,
871         // finally update the reference to contain the share link if it was not
872         // already there (and point to new file id if we copied).
875         // Check this issuer is enabled.
876         if ($this->disabled) {
877             throw new repository_exception('cannotdownload', 'repository');
878         }
880         // Get a system oauth client and a user oauth client.
881         $systemauth = \core\oauth2\api::get_system_oauth_client($this->issuer);
883         if ($systemauth === false) {
884             $details = 'Cannot connect as system user';
885             throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
886         }
887         // Get the system user email so we can share the file with this user.
888         $systemuserinfo = $systemauth->get_userinfo();
889         $systemuseremail = $systemuserinfo['email'];
891         $userauth = $this->get_user_oauth_client();
892         if ($userauth === false) {
893             $details = 'Cannot connect as current user';
894             throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
895         }
897         // Get the details from the reference.
898         $source = json_decode($reference);
899         $userservice = new repository_googledocs\rest($userauth);
900         $systemservice = new repository_googledocs\rest($systemauth);
902         // Add Moodle as writer.
903         $this->add_writer_to_file($userservice, $source->id, $systemuseremail);
905         // Now move it to a sensible folder.
906         $contextlist = array_reverse($context->get_parent_contexts(true));
908         $cache = cache::make('repository_googledocs', 'folder');
909         $parentid = 'root';
910         $fullpath = 'root';
911         $allfolders = [];
912         foreach ($contextlist as $context) {
913             // Make sure a folder exists here.
914             $foldername = clean_param($context->get_context_name(), PARAM_PATH);
915             $allfolders[] = $foldername;
916         }
918         $allfolders[] = clean_param($component, PARAM_PATH);
919         $allfolders[] = clean_param($filearea, PARAM_PATH);
920         $allfolders[] = clean_param($itemid, PARAM_PATH);
922         // Variable $allfolders is the full path we want to put the file in - so walk it and create each folder.
924         foreach ($allfolders as $foldername) {
925             // Make sure a folder exists here.
926             $fullpath .= '/' . $foldername;
928             $folderid = $cache->get($fullpath);
929             if (empty($folderid)) {
930                 $folderid = $this->folder_exists_in_folder($systemservice, $foldername, $parentid);
931             }
932             if ($folderid !== false) {
933                 $cache->set($fullpath, $folderid);
934                 $parentid = $folderid;
935             } else {
936                 // Create it.
937                 $parentid = $this->create_folder_in_folder($systemservice, $foldername, $parentid);
938                 $cache->set($fullpath, $parentid);
939             }
940         }
942         // Copy the file so we get a snapshot file owned by Moodle.
943         $newsource = $this->copy_file($systemservice, $source->id, $source->name);
944         // Move the copied file to the correct folder.
945         $this->move_file_from_root_to_folder($systemservice, $newsource->id, $parentid);
947         // Set the sharing options.
948         $this->set_file_sharing_anyone_with_link_can_read($systemservice, $newsource->id);
949         $this->prevent_writers_from_sharing_file($systemservice, $newsource->id);
951         // Update the returned reference so that the stored_file in moodle points to the newly copied file.
952         $source->id = $newsource->id;
953         $source->link = isset($newsource->webViewLink) ? $newsource->webViewLink : '';
954         $source->usesystem = true;
955         if (empty($source->link)) {
956             $source->link = isset($newsource->webContentLink) ? $newsource->webContentLink : '';
957         }
958         $reference = json_encode($source);
960         return $reference;
961     }
963     /**
964      * Get human readable file info from a the reference.
965      *
966      * @param string $reference
967      * @param int $filestatus
968      */
969     public function get_reference_details($reference, $filestatus = 0) {
970         if ($this->disabled) {
971             throw new repository_exception('cannotdownload', 'repository');
972         }
973         if (empty($reference)) {
974             return get_string('unknownsource', 'repository');
975         }
976         $source = json_decode($reference);
977         if (empty($source->usesystem)) {
978             return '';
979         }
980         $systemauth = \core\oauth2\api::get_system_oauth_client($this->issuer);
982         if ($systemauth === false) {
983             return '';
984         }
985         $systemservice = new repository_googledocs\rest($systemauth);
986         $info = $this->get_file_summary($systemservice, $source->id);
988         $owner = '';
989         if (!empty($info->owners[0]->displayName)) {
990             $owner = $info->owners[0]->displayName;
991         }
992         if ($owner) {
993             return get_string('owner', 'repository_googledocs', $owner);
994         } else {
995             return $info->name;
996         }
997     }
999     /**
1000      * Edit/Create Admin Settings Moodle form.
1001      *
1002      * @param moodleform $mform Moodle form (passed by reference).
1003      * @param string $classname repository class name.
1004      */
1005     public static function type_config_form($mform, $classname = 'repository') {
1006         $url = new moodle_url('/admin/tool/oauth2/issuers.php');
1007         $url = $url->out();
1009         $mform->addElement('static', null, '', get_string('oauth2serviceslink', 'repository_googledocs', $url));
1011         parent::type_config_form($mform);
1012         $options = [];
1013         $issuers = \core\oauth2\api::get_all_issuers();
1015         foreach ($issuers as $issuer) {
1016             $options[$issuer->get('id')] = s($issuer->get('name'));
1017         }
1019         $strrequired = get_string('required');
1021         $mform->addElement('select', 'issuerid', get_string('issuer', 'repository_googledocs'), $options);
1022         $mform->addHelpButton('issuerid', 'issuer', 'repository_googledocs');
1023         $mform->addRule('issuerid', $strrequired, 'required', null, 'client');
1025         $mform->addElement('static', null, '', get_string('fileoptions', 'repository_googledocs'));
1026         $choices = [
1027             'internal' => get_string('internal', 'repository_googledocs'),
1028             'external' => get_string('external', 'repository_googledocs'),
1029             'both' => get_string('both', 'repository_googledocs')
1030         ];
1031         $mform->addElement('select', 'supportedreturntypes', get_string('supportedreturntypes', 'repository_googledocs'), $choices);
1033         $choices = [
1034             FILE_INTERNAL => get_string('internal', 'repository_googledocs'),
1035             FILE_CONTROLLED_LINK => get_string('external', 'repository_googledocs'),
1036         ];
1037         $mform->addElement('select', 'defaultreturntype', get_string('defaultreturntype', 'repository_googledocs'), $choices);
1039         $mform->addElement('static', null, '', get_string('importformat', 'repository_googledocs'));
1041         // Documents.
1042         $docsformat = array();
1043         $docsformat['html'] = 'html';
1044         $docsformat['docx'] = 'docx';
1045         $docsformat['odt'] = 'odt';
1046         $docsformat['pdf'] = 'pdf';
1047         $docsformat['rtf'] = 'rtf';
1048         $docsformat['txt'] = 'txt';
1049         core_collator::ksort($docsformat, core_collator::SORT_NATURAL);
1051         $mform->addElement('select', 'documentformat', get_string('docsformat', 'repository_googledocs'), $docsformat);
1052         $mform->setDefault('documentformat', $docsformat['rtf']);
1053         $mform->setType('documentformat', PARAM_ALPHANUM);
1055         // Drawing.
1056         $drawingformat = array();
1057         $drawingformat['jpeg'] = 'jpeg';
1058         $drawingformat['png'] = 'png';
1059         $drawingformat['svg'] = 'svg';
1060         $drawingformat['pdf'] = 'pdf';
1061         core_collator::ksort($drawingformat, core_collator::SORT_NATURAL);
1063         $mform->addElement('select', 'drawingformat', get_string('drawingformat', 'repository_googledocs'), $drawingformat);
1064         $mform->setDefault('drawingformat', $drawingformat['pdf']);
1065         $mform->setType('drawingformat', PARAM_ALPHANUM);
1067         // Presentation.
1068         $presentationformat = array();
1069         $presentationformat['pdf'] = 'pdf';
1070         $presentationformat['pptx'] = 'pptx';
1071         $presentationformat['txt'] = 'txt';
1072         core_collator::ksort($presentationformat, core_collator::SORT_NATURAL);
1074         $str = get_string('presentationformat', 'repository_googledocs');
1075         $mform->addElement('select', 'presentationformat', $str, $presentationformat);
1076         $mform->setDefault('presentationformat', $presentationformat['pptx']);
1077         $mform->setType('presentationformat', PARAM_ALPHANUM);
1079         // Spreadsheet.
1080         $spreadsheetformat = array();
1081         $spreadsheetformat['csv'] = 'csv';
1082         $spreadsheetformat['ods'] = 'ods';
1083         $spreadsheetformat['pdf'] = 'pdf';
1084         $spreadsheetformat['xlsx'] = 'xlsx';
1085         core_collator::ksort($spreadsheetformat, core_collator::SORT_NATURAL);
1087         $str = get_string('spreadsheetformat', 'repository_googledocs');
1088         $mform->addElement('select', 'spreadsheetformat', $str, $spreadsheetformat);
1089         $mform->setDefault('spreadsheetformat', $spreadsheetformat['xlsx']);
1090         $mform->setType('spreadsheetformat', PARAM_ALPHANUM);
1091     }
1094 /**
1095  * Callback to get the required scopes for system account.
1096  *
1097  * @param \core\oauth2\issuer $issuer
1098  * @return string
1099  */
1100 function repository_googledocs_oauth2_system_scopes(\core\oauth2\issuer $issuer) {
1101     if ($issuer->get('id') == get_config('googledocs', 'issuerid')) {
1102         return 'https://www.googleapis.com/auth/drive';
1103     }
1104     return '';