Merge branch 'MDL-58823-master' of git://github.com/jleyva/moodle
[moodle.git] / repository / onedrive / 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  * Microsoft Live Skydrive Repository Plugin
19  *
20  * @package    repository_onedrive
21  * @copyright  2012 Lancaster University Network Services Ltd
22  * @author     Dan Poltawski <dan.poltawski@luns.net.uk>
23  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24  */
26 defined('MOODLE_INTERNAL') || die();
28 /**
29  * Microsoft onedrive repository plugin.
30  *
31  * @package    repository_onedrive
32  * @copyright  2012 Lancaster University Network Services Ltd
33  * @author     Dan Poltawski <dan.poltawski@luns.net.uk>
34  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
35  */
36 class repository_onedrive extends repository {
37     /**
38      * OAuth 2 client
39      * @var \core\oauth2\client
40      */
41     private $client = null;
43     /**
44      * OAuth 2 Issuer
45      * @var \core\oauth2\issuer
46      */
47     private $issuer = null;
49     /**
50      * Additional scopes required for drive.
51      */
52     const SCOPES = 'files.readwrite.all';
54     /**
55      * Constructor.
56      *
57      * @param int $repositoryid repository instance id.
58      * @param int|stdClass $context a context id or context object.
59      * @param array $options repository options.
60      * @param int $readonly indicate this repo is readonly or not.
61      * @return void
62      */
63     public function __construct($repositoryid, $context = SYSCONTEXTID, $options = array(), $readonly = 0) {
64         parent::__construct($repositoryid, $context, $options, $readonly = 0);
66         try {
67             $this->issuer = \core\oauth2\api::get_issuer(get_config('onedrive', 'issuerid'));
68         } catch (dml_missing_record_exception $e) {
69             $this->disabled = true;
70         }
72         if ($this->issuer && !$this->issuer->get('enabled')) {
73             $this->disabled = true;
74         }
75     }
77     /**
78      * Get a cached user authenticated oauth client.
79      *
80      * @param moodle_url $overrideurl - Use this url instead of the repo callback.
81      * @return \core\oauth2\client
82      */
83     protected function get_user_oauth_client($overrideurl = false) {
84         if ($this->client) {
85             return $this->client;
86         }
87         if ($overrideurl) {
88             $returnurl = $overrideurl;
89         } else {
90             $returnurl = new moodle_url('/repository/repository_callback.php');
91             $returnurl->param('callback', 'yes');
92             $returnurl->param('repo_id', $this->id);
93             $returnurl->param('sesskey', sesskey());
94         }
96         $this->client = \core\oauth2\api::get_user_oauth_client($this->issuer, $returnurl, self::SCOPES);
98         return $this->client;
99     }
101     /**
102      * Checks whether the user is authenticate or not.
103      *
104      * @return bool true when logged in.
105      */
106     public function check_login() {
107         $client = $this->get_user_oauth_client();
108         return $client->is_logged_in();
109     }
111     /**
112      * Print or return the login form.
113      *
114      * @return void|array for ajax.
115      */
116     public function print_login() {
117         $client = $this->get_user_oauth_client();
118         $url = $client->get_login_url();
120         if ($this->options['ajax']) {
121             $popup = new stdClass();
122             $popup->type = 'popup';
123             $popup->url = $url->out(false);
124             return array('login' => array($popup));
125         } else {
126             echo '<a target="_blank" href="'.$url->out(false).'">'.get_string('login', 'repository').'</a>';
127         }
128     }
130     /**
131      * Build the breadcrumb from a path.
132      *
133      * @param string $path to create a breadcrumb from.
134      * @return array containing name and path of each crumb.
135      */
136     protected function build_breadcrumb($path) {
137         $bread = explode('/', $path);
138         $crumbtrail = '';
139         foreach ($bread as $crumb) {
140             list($id, $name) = $this->explode_node_path($crumb);
141             $name = empty($name) ? $id : $name;
142             $breadcrumb[] = array(
143                 'name' => $name,
144                 'path' => $this->build_node_path($id, $name, $crumbtrail)
145             );
146             $tmp = end($breadcrumb);
147             $crumbtrail = $tmp['path'];
148         }
149         return $breadcrumb;
150     }
152     /**
153      * Generates a safe path to a node.
154      *
155      * Typically, a node will be id|Name of the node.
156      *
157      * @param string $id of the node.
158      * @param string $name of the node, will be URL encoded.
159      * @param string $root to append the node on, must be a result of this function.
160      * @return string path to the node.
161      */
162     protected function build_node_path($id, $name = '', $root = '') {
163         $path = $id;
164         if (!empty($name)) {
165             $path .= '|' . urlencode($name);
166         }
167         if (!empty($root)) {
168             $path = trim($root, '/') . '/' . $path;
169         }
170         return $path;
171     }
173     /**
174      * Returns information about a node in a path.
175      *
176      * @see self::build_node_path()
177      * @param string $node to extrat information from.
178      * @return array about the node.
179      */
180     protected function explode_node_path($node) {
181         if (strpos($node, '|') !== false) {
182             list($id, $name) = explode('|', $node, 2);
183             $name = urldecode($name);
184         } else {
185             $id = $node;
186             $name = '';
187         }
188         $id = urldecode($id);
189         return array(
190             0 => $id,
191             1 => $name,
192             'id' => $id,
193             'name' => $name
194         );
195     }
197     /**
198      * List the files and folders.
199      *
200      * @param  string $path path to browse.
201      * @param  string $page page to browse.
202      * @return array of result.
203      */
204     public function get_listing($path='', $page = '') {
205         if (empty($path)) {
206             $path = $this->build_node_path('root', get_string('pluginname', 'repository_onedrive'));
207         }
209         if ($this->disabled) {
210             // Empty list of files for disabled repository.
211             return ['dynload' => false, 'list' => [], 'nologin' => true];
212         }
214         // We analyse the path to extract what to browse.
215         $trail = explode('/', $path);
216         $uri = array_pop($trail);
217         list($id, $name) = $this->explode_node_path($uri);
219         // Handle the special keyword 'search', which we defined in self::search() so that
220         // we could set up a breadcrumb in the search results. In any other case ID would be
221         // 'root' which is a special keyword, or a parent (folder) ID.
222         if ($id === 'search') {
223             $q = $name;
224             $id = 'root';
226             // Append the active path for search.
227             $str = get_string('searchfor', 'repository_onedrive', $searchtext);
228             $path = $this->build_node_path('search', $str, $path);
229         }
231         // Query the Drive.
232         $parent = $id;
233         if ($parent != 'root') {
234             $parent = 'items/' . $parent;
235         }
236         $q = '';
237         $results = $this->query($q, $path, $parent);
239         $ret = [];
240         $ret['dynload'] = true;
241         $ret['path'] = $this->build_breadcrumb($path);
242         $ret['list'] = $results;
243         $ret['manage'] = 'https://www.office.com/';
244         return $ret;
245     }
247     /**
248      * Search throughout the OneDrive
249      *
250      * @param string $searchtext text to search for.
251      * @param int $page search page.
252      * @return array of results.
253      */
254     public function search($searchtext, $page = 0) {
255         $path = $this->build_node_path('root', get_string('pluginname', 'repository_onedrive'));
256         $str = get_string('searchfor', 'repository_onedrive', $searchtext);
257         $path = $this->build_node_path('search', $str, $path);
259         // Query the Drive.
260         $parent = 'root';
261         $results = $this->query($searchtext, $path, 'root');
263         $ret = [];
264         $ret['dynload'] = true;
265         $ret['path'] = $this->build_breadcrumb($path);
266         $ret['list'] = $results;
267         $ret['manage'] = 'https://www.office.com/';
268         return $ret;
269     }
271     /**
272      * Query OneDrive for files and folders using a search query.
273      *
274      * Documentation about the query format can be found here:
275      *   https://developer.microsoft.com/en-us/graph/docs/api-reference/v1.0/resources/driveitem
276      *   https://developer.microsoft.com/en-us/graph/docs/overview/query_parameters
277      *
278      * This returns a list of files and folders with their details as they should be
279      * formatted and returned by functions such as get_listing() or search().
280      *
281      * @param string $q search query as expected by the Graph API.
282      * @param string $path parent path of the current files, will not be used for the query.
283      * @param string $parent Parent id.
284      * @param int $page page.
285      * @return array of files and folders.
286      * @throws Exception
287      * @throws repository_exception
288      */
289     protected function query($q, $path = null, $parent = null, $page = 0) {
290         global $OUTPUT;
292         $files = [];
293         $folders = [];
294         $fields = "folder,id,lastModifiedDateTime,name,size,webUrl,thumbnails";
295         $params = ['$select' => $fields, '$expand' => 'thumbnails', 'parent' => $parent];
297         try {
298             // Retrieving files and folders.
299             $client = $this->get_user_oauth_client();
300             $service = new repository_onedrive\rest($client);
302             if (!empty($q)) {
303                 $params['search'] = urlencode($q);
305                 // MS does not return thumbnails on a search.
306                 unset($params['$expand']);
307                 $response = $service->call('search', $params);
308             } else {
309                 $response = $service->call('list', $params);
310             }
311         } catch (Exception $e) {
312             if ($e->getCode() == 403 && strpos($e->getMessage(), 'Access Not Configured') !== false) {
313                 throw new repository_exception('servicenotenabled', 'repository_onedrive');
314             } else if (strpos($e->getMessage(), 'mysite not found') !== false) {
315                 throw new repository_exception('mysitenotfound', 'repository_onedrive');
316             }
317         }
319         $remotefiles = isset($response->value) ? $response->value : [];
320         foreach ($remotefiles as $remotefile) {
321             if (!empty($remotefile->folder)) {
322                 // This is a folder.
323                 $folders[$remotefile->id] = [
324                     'title' => $remotefile->name,
325                     'path' => $this->build_node_path($remotefile->id, $remotefile->name, $path),
326                     'date' => strtotime($remotefile->lastModifiedDateTime),
327                     'thumbnail' => $OUTPUT->image_url(file_folder_icon(64))->out(false),
328                     'thumbnail_height' => 64,
329                     'thumbnail_width' => 64,
330                     'children' => []
331                 ];
332             } else {
333                 // We can download all other file types.
334                 $title = $remotefile->name;
335                 $source = json_encode([
336                         'id' => $remotefile->id,
337                         'name' => $remotefile->name,
338                         'link' => $remotefile->webUrl
339                     ]);
341                 $thumb = '';
342                 $thumbwidth = 0;
343                 $thumbheight = 0;
344                 $extendedinfoerr = false;
346                 if (empty($remotefile->thumbnails)) {
347                     // Try and get it directly from the item.
348                     $params = ['fileid' => $remotefile->id, '$select' => $fields, '$expand' => 'thumbnails'];
349                     try {
350                         $response = $service->call('get', $params);
351                         $remotefile = $response;
352                     } catch (Exception $e) {
353                         // This is not a failure condition - we just could not get extended info about the file.
354                         $extendedinfoerr = true;
355                     }
356                 }
358                 if (!empty($remotefile->thumbnails)) {
359                     $thumbs = $remotefile->thumbnails;
360                     if (count($thumbs)) {
361                         $first = reset($thumbs);
362                         if (!empty($first->medium) && !empty($first->medium->url)) {
363                             $thumb = $first->medium->url;
364                             $thumbwidth = min($first->medium->width, 64);
365                             $thumbheight = min($first->medium->height, 64);
366                         }
367                     }
368                 }
370                 $files[$remotefile->id] = [
371                     'title' => $title,
372                     'source' => $source,
373                     'date' => strtotime($remotefile->lastModifiedDateTime),
374                     'size' => isset($remotefile->size) ? $remotefile->size : null,
375                     'thumbnail' => $thumb,
376                     'thumbnail_height' => $thumbwidth,
377                     'thumbnail_width' => $thumbheight,
378                 ];
379             }
380         }
382         // Filter and order the results.
383         $files = array_filter($files, [$this, 'filter']);
384         core_collator::ksort($files, core_collator::SORT_NATURAL);
385         core_collator::ksort($folders, core_collator::SORT_NATURAL);
386         return array_merge(array_values($folders), array_values($files));
387     }
389     /**
390      * Logout.
391      *
392      * @return string
393      */
394     public function logout() {
395         $client = $this->get_user_oauth_client();
396         $client->log_out();
397         return parent::logout();
398     }
400     /**
401      * Get a file.
402      *
403      * @param string $reference reference of the file.
404      * @param string $filename filename to save the file to.
405      * @return string JSON encoded array of information about the file.
406      */
407     public function get_file($reference, $filename = '') {
408         global $CFG;
410         if ($this->disabled) {
411             throw new repository_exception('cannotdownload', 'repository');
412         }
413         $sourceinfo = json_decode($reference);
415         $client = null;
416         if (!empty($sourceinfo->usesystem)) {
417             $client = \core\oauth2\api::get_system_oauth_client($this->issuer);
418         } else {
419             $client = $this->get_user_oauth_client();
420         }
422         $base = 'https://graph.microsoft.com/v1.0/';
424         $sourceurl = new moodle_url($base . 'me/drive/items/' . $sourceinfo->id . '/content');
425         $source = $sourceurl->out(false);
427         // We use download_one and not the rest API because it has special timeouts etc.
428         $path = $this->prepare_file($filename);
429         $options = ['filepath' => $path, 'timeout' => 15, 'followlocation' => true, 'maxredirs' => 5];
430         $result = $client->download_one($source, null, $options);
432         if ($result) {
433             @chmod($path, $CFG->filepermissions);
434             return array(
435                 'path' => $path,
436                 'url' => $reference
437             );
438         }
439         throw new repository_exception('cannotdownload', 'repository');
440     }
442     /**
443      * Prepare file reference information.
444      *
445      * We are using this method to clean up the source to make sure that it
446      * is a valid source.
447      *
448      * @param string $source of the file.
449      * @return string file reference.
450      */
451     public function get_file_reference($source) {
452         // We could do some magic upgrade code here.
453         return $source;
454     }
456     /**
457      * What kind of files will be in this repository?
458      *
459      * @return array return '*' means this repository support any files, otherwise
460      *               return mimetypes of files, it can be an array
461      */
462     public function supported_filetypes() {
463         return '*';
464     }
466     /**
467      * Tells how the file can be picked from this repository.
468      *
469      * @return int
470      */
471     public function supported_returntypes() {
472         // We can only support references if the system account is connected.
473         if (!empty($this->issuer) && $this->issuer->is_system_account_connected()) {
474             $setting = get_config('onedrive', 'supportedreturntypes');
475             if ($setting == 'internal') {
476                 return FILE_INTERNAL;
477             } else if ($setting == 'external') {
478                 return FILE_CONTROLLED_LINK;
479             } else {
480                 return FILE_CONTROLLED_LINK | FILE_INTERNAL;
481             }
482         } else {
483             return FILE_INTERNAL;
484         }
485     }
487     /**
488      * Which return type should be selected by default.
489      *
490      * @return int
491      */
492     public function default_returntype() {
493         $setting = get_config('onedrive', 'defaultreturntype');
494         $supported = get_config('onedrive', 'supportedreturntypes');
495         if (($setting == FILE_INTERNAL && $supported != 'external') || $supported == 'internal') {
496             return FILE_INTERNAL;
497         } else {
498             return FILE_CONTROLLED_LINK;
499         }
500     }
502     /**
503      * Return names of the general options.
504      * By default: no general option name.
505      *
506      * @return array
507      */
508     public static function get_type_option_names() {
509         return array('issuerid', 'pluginname', 'defaultreturntype', 'supportedreturntypes');
510     }
512     /**
513      * Store the access token.
514      */
515     public function callback() {
516         $client = $this->get_user_oauth_client();
517         // This will upgrade to an access token if we have an authorization code and save the access token in the session.
518         $client->is_logged_in();
519     }
521     /**
522      * Repository method to serve the referenced file
523      *
524      * @see send_stored_file
525      *
526      * @param stored_file $storedfile the file that contains the reference
527      * @param int $lifetime Number of seconds before the file should expire from caches (null means $CFG->filelifetime)
528      * @param int $filter 0 (default)=no filtering, 1=all files, 2=html files only
529      * @param bool $forcedownload If true (default false), forces download of file rather than view in browser/plugin
530      * @param array $options additional options affecting the file serving
531      */
532     public function send_file($storedfile, $lifetime=null , $filter=0, $forcedownload=false, array $options = null) {
533         if ($this->disabled) {
534             throw new repository_exception('cannotdownload', 'repository');
535         }
537         $source = json_decode($storedfile->get_reference());
539         $fb = get_file_browser();
540         $context = context::instance_by_id($storedfile->get_contextid(), MUST_EXIST);
541         $info = $fb->get_file_info($context,
542                                    $storedfile->get_component(),
543                                    $storedfile->get_filearea(),
544                                    $storedfile->get_itemid(),
545                                    $storedfile->get_filepath(),
546                                    $storedfile->get_filename());
548         if (empty($options['offline']) && !empty($info) && $info->is_writable() && !empty($source->usesystem)) {
549             // Add the current user as an OAuth writer.
550             $systemauth = \core\oauth2\api::get_system_oauth_client($this->issuer);
552             if ($systemauth === false) {
553                 $details = 'Cannot connect as system user';
554                 throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
555             }
556             $systemservice = new repository_onedrive\rest($systemauth);
558             // Get the user oauth so we can get the account to add.
559             $url = moodle_url::make_pluginfile_url($storedfile->get_contextid(),
560                                                    $storedfile->get_component(),
561                                                    $storedfile->get_filearea(),
562                                                    $storedfile->get_itemid(),
563                                                    $storedfile->get_filepath(),
564                                                    $storedfile->get_filename(),
565                                                    $forcedownload);
566             $url->param('sesskey', sesskey());
567             $userauth = $this->get_user_oauth_client($url);
568             if (!$userauth->is_logged_in()) {
569                 redirect($userauth->get_login_url());
570             }
571             if ($userauth === false) {
572                 $details = 'Cannot connect as current user';
573                 throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
574             }
575             $userinfo = $userauth->get_userinfo();
576             $useremail = $userinfo['email'];
578             $this->add_temp_writer_to_file($systemservice, $source->id, $useremail);
579         }
581         if (!empty($options['offline'])) {
582             $downloaded = $this->get_file($storedfile->get_reference(), $storedfile->get_filename());
583             $filename = $storedfile->get_filename();
584             send_file($downloaded['path'], $filename, $lifetime, $filter, false, $forcedownload, '', false, $options);
585         } else if ($source->link) {
586             // Do not use redirect() here because is not compatible with webservice/pluginfile.php.
587             header('Location: ' . $source->link);
588         } else {
589             $details = 'File is missing source link';
590             throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
591         }
592     }
594     /**
595      * See if a folder exists within a folder
596      *
597      * @param \repository_onedrive\rest $client Authenticated client.
598      * @param string $fullpath
599      * @return string|boolean The file id if it exists or false.
600      */
601     protected function get_file_id_by_path(\repository_onedrive\rest $client, $fullpath) {
602         $fields = "id";
603         try {
604             $response = $client->call('get_file_by_path', ['fullpath' => $fullpath, '$select' => $fields]);
605         } catch (\core\oauth2\rest_exception $re) {
606             return false;
607         }
608         return $response->id;
609     }
611     /**
612      * Delete a file by full path.
613      *
614      * @param \repository_onedrive\rest $client Authenticated client.
615      * @param string $fullpath
616      * @return boolean
617      */
618     protected function delete_file_by_path(\repository_onedrive\rest $client, $fullpath) {
619         try {
620             $response = $client->call('delete_file_by_path', ['fullpath' => $fullpath]);
621         } catch (\core\oauth2\rest_exception $re) {
622             return false;
623         }
624         return true;
625     }
627     /**
628      * Create a folder within a folder
629      *
630      * @param \repository_onedrive\rest $client Authenticated client.
631      * @param string $foldername The folder we are creating.
632      * @param string $parentid The parent folder we are creating in.
633      *
634      * @return string The file id of the new folder.
635      */
636     protected function create_folder_in_folder(\repository_onedrive\rest $client, $foldername, $parentid) {
637         $params = ['parentid' => $parentid];
638         $folder = [ 'name' => $foldername, 'folder' => [ 'childCount' => 0 ]];
639         $created = $client->call('create_folder', $params, json_encode($folder));
640         if (empty($created->id)) {
641             $details = 'Cannot create folder:' . $foldername;
642             throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
643         }
644         return $created->id;
645     }
647     /**
648      * Get simple file info for humans.
649      *
650      * @param \repository_onedrive\rest $client Authenticated client.
651      * @param string $fileid The file we are querying.
652      *
653      * @return stdClass
654      */
655     protected function get_file_summary(\repository_onedrive\rest $client, $fileid) {
656         $fields = "folder,id,lastModifiedDateTime,name,size,webUrl,createdByUser";
657         $response = $client->call('get', ['fileid' => $fileid, '$select' => $fields]);
658         return $response;
659     }
661     /**
662      * Add a writer to the permissions on the file (temporary).
663      *
664      * @param \repository_onedrive\rest $client Authenticated client.
665      * @param string $fileid The file we are updating.
666      * @param string $email The email of the writer account to add.
667      * @return boolean
668      */
669     protected function add_temp_writer_to_file(\repository_onedrive\rest $client, $fileid, $email) {
670         // Expires in 7 days.
671         $expires = new DateTime();
672         $expires->add(new DateInterval("P7D"));
674         $updateeditor = [
675             'recipients' => [[ 'email' => $email ]],
676             'roles' => ['write'],
677             'requireSignIn' => true,
678             'sendInvitation' => false
679         ];
680         $params = ['fileid' => $fileid];
681         $response = $client->call('create_permission', $params, json_encode($updateeditor));
682         if (empty($response->value[0]->id)) {
683             $details = 'Cannot add user ' . $email . ' as a writer for document: ' . $fileid;
684             throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
685         }
686         // Store the permission id in the DB. Scheduled task will remove this permission after 7 days.
687         if ($access = repository_onedrive\access::get_record(['permissionid' => $response->value[0]->id, 'itemid' => $fileid ])) {
688             // Update the timemodified.
689             $access->update();
690         } else {
691             $record = (object) [ 'permissionid' => $response->value[0]->id, 'itemid' => $fileid ];
692             $access = new repository_onedrive\access(0, $record);
693             $access->create();
694         }
695         return true;
696     }
698     /**
699      * Allow anyone with the link to read the file.
700      *
701      * @param \repository_onedrive\rest $client Authenticated client.
702      * @param string $fileid The file we are updating.
703      * @return boolean
704      */
705     protected function set_file_sharing_anyone_with_link_can_read(\repository_onedrive\rest $client, $fileid) {
706         $updateread = [
707             'type' => 'view',
708             'scope' => 'anonymous'
709         ];
710         $params = ['fileid' => $fileid];
711         $response = $client->call('create_link', $params, json_encode($updateread));
712         if (empty($response->link)) {
713             $details = 'Cannot update link sharing for the document: ' . $fileid;
714             throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
715         }
716         return $response->link->webUrl;
717     }
719     /**
720      * Given a filename, use the core_filetypes registered types to guess a mimetype.
721      *
722      * If no mimetype is known, return 'application/unknown';
723      *
724      * @param string $filename
725      * @return string $mimetype
726      */
727     protected function get_mimetype_from_filename($filename) {
728         $mimetype = 'application/unknown';
729         $types = core_filetypes::get_types();
730         $fileextension = '.bin';
731         if (strpos($filename, '.') !== false) {
732             $fileextension = substr($filename, strrpos($filename, '.') + 1);
733         }
735         if (isset($types[$fileextension])) {
736             $mimetype = $types[$fileextension]['type'];
737         }
738         return $mimetype;
739     }
741     /**
742      * Upload a file to onedrive.
743      *
744      * @param \repository_onedrive\rest $service Authenticated client.
745      * @param \curl $curl Curl client to perform the put operation (with no auth headers).
746      * @param \curl $authcurl Curl client that will send authentication headers
747      * @param string $filepath The local path to the file to upload
748      * @param string $mimetype The new mimetype
749      * @param string $parentid The folder to put it.
750      * @param string $filename The name of the new file
751      * @return string $fileid
752      */
753     protected function upload_file(\repository_onedrive\rest $service, \curl $curl, \curl $authcurl,
754                                    $filepath, $mimetype, $parentid, $filename) {
755         // Start an upload session.
756         // Docs https://developer.microsoft.com/en-us/graph/docs/api-reference/v1.0/api/item_createuploadsession link.
758         $params = ['parentid' => $parentid, 'filename' => urlencode($filename)];
759         $behaviour = [ 'item' => [ "@microsoft.graph.conflictBehavior" => "rename" ] ];
760         $created = $service->call('create_upload', $params, json_encode($behaviour));
761         if (empty($created->uploadUrl)) {
762             $details = 'Cannot begin upload session:' . $parentid;
763             throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
764         }
766         $options = ['file' => $filepath];
768         // Try each curl class in turn until we succeed.
769         // First attempt an upload with no auth headers (will work for personal onedrive accounts).
770         // If that fails, try an upload with the auth headers (will work for work onedrive accounts).
771         $curls = [$curl, $authcurl];
772         $response = null;
773         foreach ($curls as $curlinstance) {
774             $curlinstance->setHeader('Content-type: ' . $mimetype);
775             $size = filesize($filepath);
776             $curlinstance->setHeader('Content-Range: bytes 0-' . ($size - 1) . '/' . $size);
777             $response = $curlinstance->put($created->uploadUrl, $options);
778             if ($curlinstance->errno == 0) {
779                 $response = json_decode($response);
780             }
781             if (!empty($response->id)) {
782                 // We can stop now - there is a valid file returned.
783                 break;
784             }
785         }
787         if (empty($response->id)) {
788             $details = 'File not created';
789             throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
790         }
792         return $response->id;
793     }
796     /**
797      * Called when a file is selected as a "link".
798      * Invoked at MOODLE/repository/repository_ajax.php
799      *
800      * What should happen here is that the file should be copied to a new file owned by the moodle system user.
801      * It should be organised in a folder based on the file context.
802      * It's sharing permissions should allow read access with the link.
803      * The returned reference should point to the newly copied file - not the original.
804      *
805      * @param string $reference this reference is generated by
806      *                          repository::get_file_reference()
807      * @param context $context the target context for this new file.
808      * @param string $component the target component for this new file.
809      * @param string $filearea the target filearea for this new file.
810      * @param string $itemid the target itemid for this new file.
811      * @return string $modifiedreference (final one before saving to DB)
812      */
813     public function reference_file_selected($reference, $context, $component, $filearea, $itemid) {
814         // What we need to do here is transfer ownership to the system user (or copy)
815         // then set the permissions so anyone with the share link can view,
816         // finally update the reference to contain the share link if it was not
817         // already there (and point to new file id if we copied).
819         // Get a system and a user oauth client.
820         $systemauth = \core\oauth2\api::get_system_oauth_client($this->issuer);
822         if ($systemauth === false) {
823             $details = 'Cannot connect as system user';
824             throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
825         }
827         $source = json_decode($reference);
829         $userauth = $this->get_user_oauth_client();
830         if ($userauth === false) {
831             $details = 'Cannot connect as current user';
832             throw new repository_exception('errorwhilecommunicatingwith', 'repository', '', $details);
833         }
835         $systemservice = new repository_onedrive\rest($systemauth);
837         // Download the file.
838         $tmpfilename = clean_param($source->id, PARAM_PATH);
839         $temppath = make_request_directory() . $tmpfilename;
841         $options = ['filepath' => $temppath, 'timeout' => 60, 'followlocation' => true, 'maxredirs' => 5];
842         $base = 'https://graph.microsoft.com/v1.0/';
843         $sourceurl = new moodle_url($base . 'me/drive/items/' . $source->id . '/content');
844         $sourceurl = $sourceurl->out(false);
846         $result = $userauth->download_one($sourceurl, null, $options);
848         if (!$result) {
849             throw new repository_exception('cannotdownload', 'repository');
850         }
852         // Now copy it to a sensible folder.
853         $contextlist = array_reverse($context->get_parent_contexts(true));
855         $cache = cache::make('repository_onedrive', 'folder');
856         $parentid = 'root';
857         $fullpath = '';
858         $allfolders = [];
859         foreach ($contextlist as $context) {
860             // Make sure a folder exists here.
861             $foldername = urlencode(clean_param($context->get_context_name(), PARAM_PATH));
862             $allfolders[] = $foldername;
863         }
865         $allfolders[] = urlencode(clean_param($component, PARAM_PATH));
866         $allfolders[] = urlencode(clean_param($filearea, PARAM_PATH));
867         $allfolders[] = urlencode(clean_param($itemid, PARAM_PATH));
869         // Variable $allfolders now has the complete path we want to store the file in.
870         // Create each folder in $allfolders under the system account.
871         foreach ($allfolders as $foldername) {
872             if ($fullpath) {
873                 $fullpath .= '/';
874             }
875             $fullpath .= $foldername;
877             $folderid = $cache->get($fullpath);
878             if (empty($folderid)) {
879                 $folderid = $this->get_file_id_by_path($systemservice, $fullpath);
880             }
881             if ($folderid !== false) {
882                 $cache->set($fullpath, $folderid);
883                 $parentid = $folderid;
884             } else {
885                 // Create it.
886                 $parentid = $this->create_folder_in_folder($systemservice, $foldername, $parentid);
887                 $cache->set($fullpath, $parentid);
888             }
889         }
891         // Delete any existing file at this path.
892         $path = $fullpath . '/' . urlencode(clean_param($source->name, PARAM_PATH));
893         $this->delete_file_by_path($systemservice, $path);
895         // Upload the file.
896         $safefilename = clean_param($source->name, PARAM_PATH);
897         $mimetype = $this->get_mimetype_from_filename($safefilename);
898         // We cannot send authorization headers in the upload or personal microsoft accounts will fail (what a joke!).
899         $curl = new \curl();
900         $fileid = $this->upload_file($systemservice, $curl, $systemauth, $temppath, $mimetype, $parentid, $safefilename);
902         // Read with link.
903         $link = $this->set_file_sharing_anyone_with_link_can_read($systemservice, $fileid);
905         $summary = $this->get_file_summary($systemservice, $fileid);
907         // Update the details in the file reference before it is saved.
908         $source->id = $summary->id;
909         $source->link = $link;
910         $source->usesystem = true;
912         $reference = json_encode($source);
914         return $reference;
915     }
917     /**
918      * Get human readable file info from the reference.
919      *
920      * @param string $reference
921      * @param int $filestatus
922      */
923     public function get_reference_details($reference, $filestatus = 0) {
924         if (empty($reference)) {
925             return get_string('unknownsource', 'repository');
926         }
927         $source = json_decode($reference);
928         if (empty($source->usesystem)) {
929             return '';
930         }
931         $systemauth = \core\oauth2\api::get_system_oauth_client($this->issuer);
933         if ($systemauth === false) {
934             return '';
935         }
936         $systemservice = new repository_onedrive\rest($systemauth);
937         $info = $this->get_file_summary($systemservice, $source->id);
939         $owner = '';
940         if (!empty($info->createdByUser->displayName)) {
941             $owner = $info->createdByUser->displayName;
942         }
943         if ($owner) {
944             return get_string('owner', 'repository_onedrive', $owner);
945         } else {
946             return $info->name;
947         }
948     }
950     /**
951      * Return true if any instances of the skydrive repo exist - and we can import them.
952      *
953      * @return bool
954      */
955     public static function can_import_skydrive_files() {
956         global $DB;
958         $skydrive = $DB->get_record('repository', ['type' => 'skydrive'], 'id', IGNORE_MISSING);
959         $onedrive = $DB->get_record('repository', ['type' => 'onedrive'], 'id', IGNORE_MISSING);
961         if (empty($skydrive) || empty($onedrive)) {
962             return false;
963         }
965         $ready = true;
966         try {
967             $issuer = \core\oauth2\api::get_issuer(get_config('onedrive', 'issuerid'));
968             if (!$issuer->get('enabled')) {
969                 $ready = false;
970             }
971             if (!$issuer->is_configured()) {
972                 $ready = false;
973             }
974         } catch (dml_missing_record_exception $e) {
975             $ready = false;
976         }
977         if (!$ready) {
978             return false;
979         }
981         $sql = "SELECT count('x')
982                   FROM {repository_instances} i, {repository} r
983                  WHERE r.type=:plugin AND r.id=i.typeid";
984         $params = array('plugin' => 'skydrive');
985         return $DB->count_records_sql($sql, $params) > 0;
986     }
988     /**
989      * Import all the files that were created with the skydrive repo to this repo.
990      *
991      * @return bool
992      */
993     public static function import_skydrive_files() {
994         global $DB;
996         if (!self::can_import_skydrive_files()) {
997             return false;
998         }
999         // Should only be one of each.
1000         $skydrivetype = repository::get_type_by_typename('skydrive');
1002         $skydriveinstances = repository::get_instances(['type' => 'skydrive']);
1003         $skydriveinstance = reset($skydriveinstances);
1004         $onedriveinstances = repository::get_instances(['type' => 'onedrive']);
1005         $onedriveinstance = reset($onedriveinstances);
1007         // Update all file references.
1008         $DB->set_field('files_reference', 'repositoryid', $onedriveinstance->id, ['repositoryid' => $skydriveinstance->id]);
1010         // Delete and disable the skydrive repo.
1011         $skydrivetype->delete();
1012         core_plugin_manager::reset_caches();
1014         $sql = "SELECT count('x')
1015                   FROM {repository_instances} i, {repository} r
1016                  WHERE r.type=:plugin AND r.id=i.typeid";
1017         $params = array('plugin' => 'skydrive');
1018         return $DB->count_records_sql($sql, $params) == 0;
1019     }
1021     /**
1022      * Edit/Create Admin Settings Moodle form.
1023      *
1024      * @param moodleform $mform Moodle form (passed by reference).
1025      * @param string $classname repository class name.
1026      */
1027     public static function type_config_form($mform, $classname = 'repository') {
1028         global $OUTPUT;
1030         $url = new moodle_url('/admin/tool/oauth2/issuers.php');
1031         $url = $url->out();
1033         $mform->addElement('static', null, '', get_string('oauth2serviceslink', 'repository_onedrive', $url));
1035         if (self::can_import_skydrive_files()) {
1036             $notice = get_string('skydrivefilesexist', 'repository_onedrive');
1037             $url = new moodle_url('/repository/onedrive/importskydrive.php');
1038             $attrs = ['class' => 'btn btn-primary'];
1039             $button = $OUTPUT->action_link($url, get_string('importskydrivefiles', 'repository_onedrive'), null, $attrs);
1040             $mform->addElement('static', null, '', $OUTPUT->notification($notice) . $button);
1041         }
1043         parent::type_config_form($mform);
1044         $options = [];
1045         $issuers = \core\oauth2\api::get_all_issuers();
1047         foreach ($issuers as $issuer) {
1048             $options[$issuer->get('id')] = s($issuer->get('name'));
1049         }
1051         $strrequired = get_string('required');
1053         $mform->addElement('select', 'issuerid', get_string('issuer', 'repository_onedrive'), $options);
1054         $mform->addHelpButton('issuerid', 'issuer', 'repository_onedrive');
1055         $mform->addRule('issuerid', $strrequired, 'required', null, 'client');
1057         $mform->addElement('static', null, '', get_string('fileoptions', 'repository_onedrive'));
1058         $choices = [
1059             'internal' => get_string('internal', 'repository_onedrive'),
1060             'external' => get_string('external', 'repository_onedrive'),
1061             'both' => get_string('both', 'repository_onedrive')
1062         ];
1063         $mform->addElement('select', 'supportedreturntypes', get_string('supportedreturntypes', 'repository_onedrive'), $choices);
1065         $choices = [
1066             FILE_INTERNAL => get_string('internal', 'repository_onedrive'),
1067             FILE_CONTROLLED_LINK => get_string('external', 'repository_onedrive'),
1068         ];
1069         $mform->addElement('select', 'defaultreturntype', get_string('defaultreturntype', 'repository_onedrive'), $choices);
1071     }
1074 /**
1075  * Callback to get the required scopes for system account.
1076  *
1077  * @param \core\oauth2\issuer $issuer
1078  * @return string
1079  */
1080 function repository_onedrive_oauth2_system_scopes(\core\oauth2\issuer $issuer) {
1081     if ($issuer->get('id') == get_config('onedrive', 'issuerid')) {
1082         return repository_onedrive::SCOPES;
1083     }
1084     return '';