Ir a la última revisión | Autoría | Comparar con el anterior | Ultima modificación | Ver Log |
<?php// This file is part of Moodle - http://moodle.org///// Moodle is free software: you can redistribute it and/or modify// it under the terms of the GNU General Public License as published by// the Free Software Foundation, either version 3 of the License, or// (at your option) any later version.//// Moodle is distributed in the hope that it will be useful,// but WITHOUT ANY WARRANTY; without even the implied warranty of// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the// GNU General Public License for more details.//// You should have received a copy of the GNU General Public License// along with Moodle. If not, see <http://www.gnu.org/licenses/>./*** Nextcloud repository plugin library.** @package repository_nextcloud* @copyright 2017 Project seminar (Learnweb, University of Münster)* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or*/use repository_nextcloud\issuer_management;use repository_nextcloud\ocs_client;defined('MOODLE_INTERNAL') || die();require_once($CFG->dirroot . '/repository/lib.php');require_once($CFG->libdir . '/webdavlib.php');/*** Nextcloud repository class.** @package repository_nextcloud* @copyright 2017 Project seminar (Learnweb, University of Münster)* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later*/class repository_nextcloud extends repository {/*** OAuth 2 client* @var \core\oauth2\client*/private $client = null;/*** OAuth 2 Issuer* @var \core\oauth2\issuer*/private $issuer = null;/*** Additional scopes needed for the repository. Currently, nextcloud does not actually support/use scopes, so* this is intended as a hint at required functionality and will help declare future scopes.*/const SCOPES = 'files ocs';/*** Webdav client which is used for webdav operations.** @var \webdav_client*/private $dav = null;/*** Basepath for WebDAV operations* @var string*/private $davbasepath;/*** OCS client that uses the Open Collaboration Services REST API.* @var ocs_client*/private $ocsclient;/*** @var oauth2_client System account client.*/private $systemoauthclient = false;/*** OCS systemocsclient that uses the Open Collaboration Services REST API.* @var ocs_client*/private $systemocsclient = null;/*** Name of the folder for controlled links.* @var string*/private $controlledlinkfoldername;/*** Curl instance that can be used to fetch file from nextcloud instance.* @var curl*/private $curl;/*** repository_nextcloud constructor.** @param int $repositoryid* @param bool|int|stdClass $context* @param array $options*/public function __construct($repositoryid, $context = SYSCONTEXTID, $options = array()) {parent::__construct($repositoryid, $context, $options);try {// Issuer from repository instance config.$issuerid = $this->get_option('issuerid');$this->issuer = \core\oauth2\api::get_issuer($issuerid);} catch (dml_missing_record_exception $e) {// A repository is marked as disabled when no issuer is present.$this->disabled = true;return;}try {// Load the webdav endpoint and parse the basepath.$webdavendpoint = issuer_management::parse_endpoint_url('webdav', $this->issuer);// Get basepath without trailing slash, because future uses will come with a leading slash.$basepath = $webdavendpoint['path'];if (strlen($basepath) > 0 && substr($basepath, -1) === '/') {$basepath = substr($basepath, 0, -1);}$this->davbasepath = $basepath;} catch (\repository_nextcloud\configuration_exception $e) {// A repository is marked as disabled when no webdav_endpoint is present// or it fails to parse, because all operations concerning files// rely on the webdav endpoint.$this->disabled = true;return;}$this->controlledlinkfoldername = $this->get_option('controlledlinkfoldername');if (!$this->issuer) {$this->disabled = true;return;} else if (!$this->issuer->get('enabled')) {// In case the Issuer is not enabled, the repository is disabled.$this->disabled = true;return;} else if (!issuer_management::is_valid_issuer($this->issuer)) {// Check if necessary endpoints are present.$this->disabled = true;return;}$this->ocsclient = new ocs_client($this->get_user_oauth_client());$this->curl = new curl();}/*** Get or initialise an oauth client for the system account.** @return false|oauth2_client False if initialisation was unsuccessful, otherwise an initialised client.*/private function get_system_oauth_client() {if ($this->systemoauthclient === false) {try {$this->systemoauthclient = \core\oauth2\api::get_system_oauth_client($this->issuer);} catch (\moodle_exception $e) {$this->systemoauthclient = false;}}return $this->systemoauthclient;}/*** Get or initialise an ocs client for the system account.** @return null|ocs_client Null if initialisation was unsuccessful, otherwise an initialised client.*/private function get_system_ocs_client() {if ($this->systemocsclient === null) {try {$systemoauth = $this->get_system_oauth_client();if (!$systemoauth) {return null;}$this->systemocsclient = new ocs_client($systemoauth);} catch (\moodle_exception $e) {$this->systemocsclient = null;}}return $this->systemocsclient;}/*** Initiates the webdav client.** @throws \repository_nextcloud\configuration_exception If configuration is missing (endpoints).*/private function initiate_webdavclient() {if ($this->dav !== null) {return $this->dav;}$webdavendpoint = issuer_management::parse_endpoint_url('webdav', $this->issuer);// Selects the necessary information (port, type, server) from the path to build the webdavclient.$server = $webdavendpoint['host'];if ($webdavendpoint['scheme'] === 'https') {$webdavtype = 'ssl://';$webdavport = 443;} else if ($webdavendpoint['scheme'] === 'http') {$webdavtype = '';$webdavport = 80;}// Override default port, if a specific one is set.if (isset($webdavendpoint['port'])) {$webdavport = $webdavendpoint['port'];}// Authentication method is `bearer` for OAuth 2. Pass token of authenticated client, too.$this->dav = new \webdav_client($server, '', '', 'bearer', $webdavtype,$this->get_user_oauth_client()->get_accesstoken()->token);$this->dav->port = $webdavport;$this->dav->debug = false;return $this->dav;}/*** This function does exactly the same as in the WebDAV repository. The only difference is, that* the nextcloud OAuth2 client uses OAuth2 instead of Basic Authentication.** @param string $reference relative path to the file.* @param string $title title of the file.* @return array|bool returns either the moodle path to the file or false.*/public function get_file($reference, $title = '') {// Normal file.$reference = urldecode($reference);// Prepare a file with an arbitrary name - cannot be $title because of special chars (cf. MDL-57002).$path = $this->prepare_file(uniqid());$this->initiate_webdavclient();if (!$this->dav->open()) {return false;}$this->dav->get_file($this->davbasepath . $reference, $path);$this->dav->close();return array('path' => $path);}/*** This function does exactly the same as in the WebDAV repository. The only difference is, that* the nextcloud OAuth2 client uses OAuth2 instead of Basic Authentication.** @param string $path relative path to the directory or file.* @param string $page page number (given multiple pages of elements).* @return array directory properties.*/public function get_listing($path='', $page = '') {if (empty($path)) {$path = '/';}$ret = $this->get_listing_prepare_response($path);// Before any WebDAV method can be executed, a WebDAV client socket needs to be opened// which connects to the server.$this->initiate_webdavclient();if (!$this->dav->open()) {return $ret;}// Since the paths which are received from the PROPFIND WebDAV method are url encoded// (because they depict actual web-paths), the received paths need to be decoded back// for the plugin to be able to work with them.$ls = $this->dav->ls($this->davbasepath . urldecode($path));$this->dav->close();// The method get_listing return all information about all child files/folders of the// current directory. If no information was received, the directory must be empty.if (!is_array($ls)) {return $ret;}// Process WebDAV output and convert it into Moodle format.$ret['list'] = $this->get_listing_convert_response($path, $ls);return $ret;}/*** Use OCS to generate a public share to the requested file.* This method derives a download link from the public share URL.** @param string $url relative path to the chosen file* @return string the generated download link.* @throws \repository_nextcloud\request_exception If nextcloud responded badly**/public function get_link($url) {// Create a read only public link, remember no update possible in this file/folder.$ocsparams = ['path' => $url,'shareType' => ocs_client::SHARE_TYPE_PUBLIC,'publicUpload' => false,'permissions' => ocs_client::SHARE_PERMISSION_READ];$response = $this->ocsclient->call('create_share', $ocsparams);$xml = simplexml_load_string($response);if ($xml === false ) {throw new \repository_nextcloud\request_exception(array('instance' => $this->get_name(),'errormessage' => get_string('invalidresponse', 'repository_nextcloud')));}if ((string)$xml->meta->status !== 'ok') {throw new \repository_nextcloud\request_exception(array('instance' => $this->get_name(), 'errormessage' => sprintf('(%s) %s', $xml->meta->statuscode, $xml->meta->message)));}// Take the share link and convert it into a download link.return ((string)$xml->data[0]->url) . '/download';}/*** This method does not do any translation of the file source.** @param string $source source of the file, returned by repository as 'source' and received back from user (not cleaned)* @return string file reference, ready to be stored or json encoded string for public link reference*/public function get_file_reference($source) {$usefilereference = optional_param('usefilereference', false, PARAM_BOOL);if ($usefilereference) {return json_encode(['type' => 'FILE_REFERENCE','link' => $this->get_link($source),]);}// The simple relative path to the file is enough.return $source;}/*** Called when a file is selected as a "access control link".* Invoked at MOODLE/repository/repository_ajax.php** This is called at the point the reference files are being copied from the draft area to the real area.* What is done here is transfer ownership to the system user (by copying) then delete the intermediate share* used for that. Finally update the reference to point to new file name.** @param string $reference this reference is generated by repository::get_file_reference()* @param context $context the target context for this new file.* @param string $component the target component for this new file.* @param string $filearea the target filearea for this new file.* @param string $itemid the target itemid for this new file.* @return string updated reference (final one before it's saved to db).* @throws \repository_nextcloud\configuration_exception* @throws \repository_nextcloud\request_exception* @throws coding_exception* @throws moodle_exception* @throws repository_exception*/public function reference_file_selected($reference, $context, $component, $filearea, $itemid) {$source = json_decode($reference);if (is_object($source)) {if ($source->type != 'FILE_CONTROLLED_LINK') {// Only access controlled links need special handling; we are done.return $reference;}if (!empty($source->usesystem)) {// If we already copied this file to the system account - we are done.return $reference;}}// Check this issuer is enabled.if ($this->disabled || $this->get_system_oauth_client() === false || $this->get_system_ocs_client() === null) {throw new repository_exception('cannotdownload', 'repository');}$linkmanager = new \repository_nextcloud\access_controlled_link_manager($this->ocsclient, $this->get_system_oauth_client(),$this->get_system_ocs_client(), $this->issuer, $this->get_name());// Get the current user.$userauth = $this->get_user_oauth_client();if ($userauth === false) {$details = get_string('cannotconnect', 'repository_nextcloud');throw new \repository_nextcloud\request_exception(array('instance' => $this->get_name(), 'errormessage' => $details));}// 1. Share the File with the system account.$responsecreateshare = $linkmanager->create_share_user_sysaccount($reference);if ($responsecreateshare['statuscode'] == 403) {// File has already been shared previously => find file in system account and use that.$responsecreateshare = $linkmanager->find_share_in_sysaccount($reference);}// 2. Create a unique path in the system account.$createdfolder = $linkmanager->create_folder_path_access_controlled_links($context, $component, $filearea,$itemid);// 3. Copy File to the new folder path.$linkmanager->transfer_file_to_path($responsecreateshare['filetarget'], $createdfolder, 'copy');// 4. Delete the share.$linkmanager->delete_share_dataowner_sysaccount($responsecreateshare['shareid']);// Update the returned reference so that the stored_file in moodle points to the newly copied file.$filereturn = new stdClass();$filereturn->type = 'FILE_CONTROLLED_LINK';$filereturn->link = $createdfolder . $responsecreateshare['filetarget'];$filereturn->name = $reference;$filereturn->usesystem = true;$filereturn = json_encode($filereturn);return $filereturn;}/*** Repository method that serves the referenced file (created e.g. via get_link).* All parameters are there for compatibility with superclass, but they are ignored.** @param stored_file $storedfile* @param int $lifetime (ignored)* @param int $filter (ignored)* @param bool $forcedownload (ignored)* @param array $options additional options affecting the file serving* @throws \repository_nextcloud\configuration_exception* @throws \repository_nextcloud\request_exception* @throws coding_exception* @throws moodle_exception*/public function send_file($storedfile, $lifetime=null , $filter=0, $forcedownload=false, array $options = null) {$repositoryname = $this->get_name();$reference = json_decode($storedfile->get_reference());// If the file is a reference which means its a public link in nextcloud.if ($reference->type === 'FILE_REFERENCE') {// This file points to the public link just fetch the latest one from nextcloud repo.redirect($reference->link);}// 1. assure the client and user is logged in.if (empty($this->client) || $this->get_system_oauth_client() === false || $this->get_system_ocs_client() === null) {$details = get_string('contactadminwith', 'repository_nextcloud',get_string('noclientconnection', 'repository_nextcloud'));throw new \repository_nextcloud\request_exception(array('instance' => $repositoryname, 'errormessage' => $details));}// Download for offline usage. This is strictly read-only, so the file need not be shared.if (!empty($options['offline'])) {// Download from system account and provide the file to the user.$linkmanager = new \repository_nextcloud\access_controlled_link_manager($this->ocsclient,$this->get_system_oauth_client(), $this->get_system_ocs_client(), $this->issuer, $repositoryname);// Create temp path, then download into it.$filename = basename($reference->link);$tmppath = make_request_directory() . '/' . $filename;$linkmanager->download_for_offline_usage($reference->link, $tmppath);// Output the obtained file to the user and remove it from disk.send_temp_file($tmppath, $filename);// That's all.return;}if (!$this->client->is_logged_in()) {$this->print_login_popup(['style' => 'margin-top: 250px'], $options['embed']);return;}// Determining writeability of file from the using context.// Variable $info is null|\file_info. file_info::is_writable is only true if user may write for any reason.$fb = get_file_browser();$context = context::instance_by_id($storedfile->get_contextid(), MUST_EXIST);$info = $fb->get_file_info($context,$storedfile->get_component(),$storedfile->get_filearea(),$storedfile->get_itemid(),$storedfile->get_filepath(),$storedfile->get_filename());$maywrite = !empty($info) && $info->is_writable();$this->initiate_webdavclient();// Create the a manager to handle steps.$linkmanager = new \repository_nextcloud\access_controlled_link_manager($this->ocsclient, $this->get_system_oauth_client(),$this->get_system_ocs_client(), $this->issuer, $repositoryname);// 2. Check whether user has folder for files otherwise create it.$linkmanager->create_storage_folder($this->controlledlinkfoldername, $this->dav);$userinfo = $this->client->get_userinfo();$username = $userinfo['username'];// Creates a share between the systemaccount and the user.$responsecreateshare = $linkmanager->create_share_user_sysaccount($reference->link, $username, $maywrite);$statuscode = $responsecreateshare['statuscode'];if ($statuscode == 403) {$shareid = $linkmanager->get_shares_from_path($reference->link, $username);} else if ($statuscode == 100) {$filetarget = $linkmanager->get_share_information_from_shareid($responsecreateshare['shareid'], $username);$copyresult = $linkmanager->transfer_file_to_path($filetarget, $this->controlledlinkfoldername,'move', $this->dav);if (!($copyresult == 201 || $copyresult == 412)) {throw new \repository_nextcloud\request_exception(array('instance' => $repositoryname,'errormessage' => get_string('couldnotmove', 'repository_nextcloud', $this->controlledlinkfoldername)));}$shareid = $responsecreateshare['shareid'];} else if ($statuscode == 997) {throw new \repository_nextcloud\request_exception(array('instance' => $repositoryname,'errormessage' => get_string('notauthorized', 'repository_nextcloud')));} else {$details = get_string('filenotaccessed', 'repository_nextcloud');throw new \repository_nextcloud\request_exception(array('instance' => $repositoryname, 'errormessage' => $details));}$filetarget = $linkmanager->get_share_information_from_shareid((int)$shareid, $username);// Obtain the file from Nextcloud using a Bearer token authenticated connection because we cannot perform a redirect here.// The reason is that Nextcloud uses samesite cookie validation, i.e. a redirected request would not be authenticated.// (Also the browser might use the session of a Nextcloud user that is different from the one that is known to Moodle.)$filename = basename($filetarget);$tmppath = make_request_directory() . '/' . $filename;$this->dav->open();// Concat webdav path with file path.$webdavendpoint = issuer_management::parse_endpoint_url('webdav', $this->issuer);$filetarget = ltrim($filetarget, '/');$filetarget = $webdavendpoint['path'] . $filetarget;// Write file into temp location.if (!$this->dav->get_file($filetarget, $tmppath)) {$this->dav->close();throw new repository_exception('cannotdownload', 'repository');}$this->dav->close();// Output the obtained file to the user and remove it from disk.send_temp_file($tmppath, $filename);}/*** Which return type should be selected by default.** @return int*/public function default_returntype() {$setting = $this->get_option('defaultreturntype');$supported = $this->get_option('supportedreturntypes');if (($setting == FILE_INTERNAL && $supported !== 'external') || $supported === 'internal') {return FILE_INTERNAL;}return FILE_CONTROLLED_LINK;}/*** Return names of the general options.* By default: no general option name.** @return array*/public static function get_type_option_names() {return array();}/*** Function which checks whether the user is logged in on the Nextcloud instance.** @return bool false, if no Access Token is set or can be requested.*/public function check_login() {$client = $this->get_user_oauth_client();return $client->is_logged_in();}/*** Get a cached user authenticated oauth client.** @param bool|moodle_url $overrideurl Use this url instead of the repo callback.* @return \core\oauth2\client*/protected function get_user_oauth_client($overrideurl = false) {if ($this->client) {return $this->client;}if ($overrideurl) {$returnurl = $overrideurl;} else {$returnurl = new moodle_url('/repository/repository_callback.php');$returnurl->param('callback', 'yes');$returnurl->param('repo_id', $this->id);$returnurl->param('sesskey', sesskey());}$this->client = \core\oauth2\api::get_user_oauth_client($this->issuer, $returnurl, self::SCOPES, true);return $this->client;}/*** Prints a simple Login Button which redirects to an authorization window from Nextcloud.** @return mixed login window properties.* @throws coding_exception*/public function print_login() {$client = $this->get_user_oauth_client();$loginurl = $client->get_login_url();if ($this->options['ajax']) {$ret = array();$btn = new \stdClass();$btn->type = 'popup';$btn->url = $loginurl->out(false);$ret['login'] = array($btn);return $ret;} else {echo html_writer::link($loginurl, get_string('login', 'repository'),array('target' => '_blank', 'rel' => 'noopener noreferrer'));}}/*** Deletes the held Access Token and prints the Login window.** @return array login window properties.*/public function logout() {$client = $this->get_user_oauth_client();$client->log_out();return parent::logout();}/*** Sets up access token after the redirection from Nextcloud.*/public function callback() {$client = $this->get_user_oauth_client();// If an Access Token is stored within the client, it has to be deleted to prevent the addition// of an Bearer authorization header in the request method.$client->log_out();// This will upgrade to an access token if we have an authorization code and save the access token in the session.$client->is_logged_in();}/*** Create an instance for this plug-in** @param string $type the type of the repository* @param int $userid the user id* @param stdClass $context the context* @param array $params the options for this instance* @param int $readonly whether to create it readonly or not (defaults to not)* @return mixed* @throws dml_exception* @throws required_capability_exception*/public static function create($type, $userid, $context, $params, $readonly=0) {require_capability('moodle/site:config', context_system::instance());return parent::create($type, $userid, $context, $params, $readonly);}/*** This method adds a select form and additional information to the settings form..** @param \moodleform $mform Moodle form (passed by reference)* @return bool|void* @throws coding_exception* @throws dml_exception*/public static function instance_config_form($mform) {if (!has_capability('moodle/site:config', context_system::instance())) {$mform->addElement('static', null, '', get_string('nopermissions', 'error', get_string('configplugin','repository_nextcloud')));return false;}// Load configured issuers.$issuers = core\oauth2\api::get_all_issuers();$types = array();// Validates which issuers implement the right endpoints. WebDav is necessary for Nextcloud.$validissuers = [];foreach ($issuers as $issuer) {$types[$issuer->get('id')] = $issuer->get('name');if (\repository_nextcloud\issuer_management::is_valid_issuer($issuer)) {$validissuers[] = $issuer->get('name');}}// Render the form.$url = new \moodle_url('/admin/tool/oauth2/issuers.php');$mform->addElement('static', null, '', get_string('oauth2serviceslink', 'repository_nextcloud', $url->out()));$mform->addElement('select', 'issuerid', get_string('chooseissuer', 'repository_nextcloud'), $types);$mform->addRule('issuerid', get_string('required'), 'required', null, 'issuer');$mform->addHelpButton('issuerid', 'chooseissuer', 'repository_nextcloud');$mform->setType('issuerid', PARAM_INT);// All issuers that are valid are displayed seperately (if any).if (count($validissuers) === 0) {$mform->addElement('static', null, '', get_string('no_right_issuers', 'repository_nextcloud'));} else {$mform->addElement('static', null, '', get_string('right_issuers', 'repository_nextcloud',implode(', ', $validissuers)));}$mform->addElement('text', 'controlledlinkfoldername', get_string('foldername', 'repository_nextcloud'));$mform->addHelpButton('controlledlinkfoldername', 'foldername', 'repository_nextcloud');$mform->setType('controlledlinkfoldername', PARAM_TEXT);$mform->setDefault('controlledlinkfoldername', 'Moodlefiles');$mform->addElement('static', null, '', get_string('fileoptions', 'repository_nextcloud'));$choices = ['both' => get_string('both', 'repository_nextcloud'),'internal' => get_string('internal', 'repository_nextcloud'),'external' => get_string('external', 'repository_nextcloud'),];$mform->addElement('select', 'supportedreturntypes', get_string('supportedreturntypes', 'repository_nextcloud'), $choices);$choices = [FILE_INTERNAL => get_string('internal', 'repository_nextcloud'),FILE_CONTROLLED_LINK => get_string('external', 'repository_nextcloud'),];$mform->addElement('select', 'defaultreturntype', get_string('defaultreturntype', 'repository_nextcloud'), $choices);}/*** Save settings for repository instance** @param array $options settings* @return bool*/public function set_option($options = array()) {$options['issuerid'] = clean_param($options['issuerid'], PARAM_INT);$options['controlledlinkfoldername'] = clean_param($options['controlledlinkfoldername'], PARAM_TEXT);$ret = parent::set_option($options);return $ret;}/*** Names of the plugin settings** @return array*/public static function get_instance_option_names() {return ['issuerid', 'controlledlinkfoldername','defaultreturntype', 'supportedreturntypes'];}/*** Method to define which file-types are supported (hardcoded can not be changed in Admin Menu)** By default FILE_INTERNAL is supported. In case a system account is connected and an issuer exist,* FILE_CONTROLLED_LINK is supported.** FILE_INTERNAL - the file is uploaded/downloaded and stored directly within the Moodle file system.* FILE_CONTROLLED_LINK - creates a copy of the file in Nextcloud from which private shares to permitted users will be* created. The file itself can not be changed any longer by the owner.** @return int return type bitmask supported*/public function supported_returntypes() {// We can only support references if the system account is connected.if (!empty($this->issuer) && $this->issuer->is_system_account_connected()) {$setting = $this->get_option('supportedreturntypes');if ($setting === 'internal') {return FILE_INTERNAL;} else if ($setting === 'external') {return FILE_CONTROLLED_LINK;} else {return FILE_CONTROLLED_LINK | FILE_INTERNAL | FILE_REFERENCE;}} else {return FILE_INTERNAL | FILE_REFERENCE;}}/*** Take the WebDAV `ls()' output and convert it into a format that Moodle's filepicker understands.** @param string $dirpath Relative (urlencoded) path of the folder of interest.* @param array $ls Output by WebDAV* @return array Moodle-formatted list of directory contents; ready for use as $ret['list'] in get_listings*/private function get_listing_convert_response($dirpath, $ls) {global $OUTPUT;$folders = array();$files = array();$parsedurl = issuer_management::parse_endpoint_url('webdav', $this->issuer);$basepath = rtrim('/' . ltrim($parsedurl['path'], '/ '), '/ ');foreach ($ls as $item) {if (!empty($item['lastmodified'])) {$item['lastmodified'] = strtotime($item['lastmodified']);} else {$item['lastmodified'] = null;}// Extracting object title from absolute path: First remove Nextcloud basepath.$item['href'] = substr(urldecode($item['href']), strlen($basepath));// Then remove relative path to current folder.$title = substr($item['href'], strlen($dirpath));if (!empty($item['resourcetype']) && $item['resourcetype'] == 'collection') {// A folder.if ($dirpath == $item['href']) {// Skip "." listing.continue;}$folders[strtoupper($title)] = array('title' => rtrim($title, '/'),'thumbnail' => $OUTPUT->image_url(file_folder_icon())->out(false),'children' => array(),'datemodified' => $item['lastmodified'],'path' => $item['href']);} else {// A file.$size = !empty($item['getcontentlength']) ? $item['getcontentlength'] : '';$files[strtoupper($title)] = array('title' => $title,'thumbnail' => $OUTPUT->image_url(file_extension_icon($title))->out(false),'size' => $size,'datemodified' => $item['lastmodified'],'source' => $item['href']);}}ksort($files);ksort($folders);return array_merge($folders, $files);}/*** Print the login in a popup.** @param array|null $attr Custom attributes to be applied to popup div.*/private function print_login_popup($attr = null, $embed = false) {global $OUTPUT, $PAGE;if ($embed) {$PAGE->set_pagelayout('embedded');}$this->client = $this->get_user_oauth_client();$url = new moodle_url($this->client->get_login_url());$state = $url->get_param('state') . '&reloadparent=true';$url->param('state', $state);echo $OUTPUT->header();$button = new single_button($url, get_string('logintoaccount', 'repository', $this->get_name()),'post', single_button::BUTTON_PRIMARY);$button->add_action(new popup_action('click', $url, 'Login'));$button->class = 'mdl-align';$button = $OUTPUT->render($button);echo html_writer::div($button, '', $attr);echo $OUTPUT->footer();}/*** Prepare response of get_listing; namely* - defining setting elements,* - filling in the parent path of the currently-viewed directory.** @param string $path Relative path* @return array ret array for use as get_listing's $ret*/private function get_listing_prepare_response($path) {$ret = [// Fetch the list dynamically. An AJAX request is sent to the server as soon as the user opens a folder.'dynload' => true,'nosearch' => true, // Disable search.'nologin' => false, // Provide a login link because a user logs into his/her private Nextcloud storage.'path' => array([ // Contains all parent paths to the current path.'name' => $this->get_meta()->name,'path' => '',]),'defaultreturntype' => $this->default_returntype(),'manage' => $this->issuer->get('baseurl'), // Provide button to go into file management interface quickly.'list' => array(), // Contains all file/folder information and is required to build the file/folder tree.'filereferencewarning' => get_string('externalpubliclinkwarning', 'repository_nextcloud'),];// If relative path is a non-top-level path, calculate all its parents' paths.// This is used for navigation in the file picker.if ($path != '/') {$chunks = explode('/', trim($path, '/'));$parent = '/';// Every sub-path to the last part of the current path is a parent path.foreach ($chunks as $chunk) {$subpath = $parent . $chunk . '/';$ret['path'][] = ['name' => urldecode($chunk),'path' => $subpath];// Prepare next iteration.$parent = $subpath;}}return $ret;}/*** When a controlled link is clicked in the file picker get the human readable info about this file.** @param string $reference* @param int $filestatus* @return string*/public function get_reference_details($reference, $filestatus = 0) {if ($this->disabled) {throw new repository_exception('cannotdownload', 'repository');}if (empty($reference)) {return get_string('unknownsource', 'repository');}$source = json_decode($reference);$path = '';if (!empty($source->usesystem) && !empty($source->name)) {$path = $source->name;}return $path;}/*** Synchronize the external file if there is an update happened to it.** If the file has been updated in the nextcloud instance, this method* would take care of the file we copy into the moodle file pool.** The call to this method reaches from stored_file::sync_external_file()** @param stored_file $file* @return bool true if synced successfully else false if not ready to sync or reference link not set*/public function sync_reference(stored_file $file): bool {global $CFG;if ($file->get_referencelastsync() + DAYSECS > time()) {// Synchronize once per day.return false;}$reference = json_decode($file->get_reference());if (!isset($reference->link)) {return false;}$url = $reference->link;if (file_extension_in_typegroup($file->get_filepath() . $file->get_filename(), 'web_image')) {$saveas = $this->prepare_file(uniqid());try {$result = $this->curl->download_one($url, [], ['filepath' => $saveas,'timeout' => $CFG->repositorysyncimagetimeout,'followlocation' => true,]);$info = $this->curl->get_info();if ($result === true && isset($info['http_code']) && $info['http_code'] === 200) {$file->set_synchronised_content_from_file($saveas);return true;}} catch (Exception $e) {// If the download fails lets download with get().$this->curl->get($url, null, ['timeout' => $CFG->repositorysyncimagetimeout, 'followlocation' => true, 'nobody' => true]);$info = $this->curl->get_info();if (isset($info['http_code']) && $info['http_code'] === 200 &&array_key_exists('download_content_length', $info) &&$info['download_content_length'] >= 0) {$filesize = (int)$info['download_content_length'];$file->set_synchronized(null, $filesize);return true;}$file->set_missingsource();return true;}}return false;}}