Proyectos de Subversion Moodle

<?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/>.

/**

 * Implementation of the Amanote filter plugin.

 *

 * @package     filter_amanote

 * @copyright   2020 Amaplex Software

 * @license     http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

defined('MOODLE_INTERNAL') || die;

require_once($CFG->libdir . '/externallib.php');

require_once(__DIR__ . '/helpers/filehelper.php');

require_once(__DIR__ . '/models/annotatable.php');

/**

 * Filter for processing file links for Amanote enhancements.

 *

 * @copyright  2020 Amaplex Software

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

class filter_amanote extends moodle_text_filter {

    /**

     * Set up the filter and insert JS scripts to page using amd.

     *

     * @param moodle_page $page The current page.

     * @param context $context The current context.

     */

    public function setup($page, $context) {

        try {

            global $PAGE, $COURSE;

            // Check if the filter is enabled for the current course.

            $enabledfilters = filter_get_active_in_context(context_course::instance($COURSE->id));

            if (!isset($enabledfilters['amanote'])) {

                return;

            }

            static $scriptinserted = false;

            // Insert script if needed.

            if ($scriptinserted ||

                (stripos($PAGE->pagetype, 'course-view') !== 0 && $PAGE->pagetype !== 'mod-folder-view') ||

                (strpos($PAGE->url, 'user/') !== false)) {

                return;

            }

            $this->insert_script($page);

            $scriptinserted = true;

        } catch (Exception $e) {

            debugging('An error occurred: ' . $e->getMessage(), DEBUG_DEVELOPER);

        }

    }

    /**

     * Insert the js script.

     *

     * @param moodle_page $page The page in which the script should be inserted.

     */

    private function insert_script($page) {

        global $CFG;

        $params = $this->generate_json_params();

        $userparams = $this->generate_json_user_params();

        // Insert user params using AMD.

        $page->requires->js_call_amd('filter_amanote/main', 'init', [$userparams]);

        // Insert params in footer (AMD can't handle long params).

        $script = <<<EOF

            <script>

                var amanote_params = $params;

            </script>

EOF;

        if (!isset($CFG->additionalhtmlfooter)) {

            $CFG->additionalhtmlfooter = '';

        }

        $CFG->additionalhtmlfooter .= $script;

    }

    /**

     * Return the Moodle params needed by the js script in JSON format.

     *

     * @return string The params in JSON string format.

     */

    private function generate_json_params() {

        global $USER, $COURSE, $CFG, $OUTPUT;

        try {

            $config = get_config('filter_amanote');

            $siteurl = $this->get_site_url();

            $language = substr($USER->lang, 0, 2);

            $usercontext = context_user::instance($USER->id);

            $privatefilepath = '/' . $usercontext->id . '/user/private/Amanote/';

            $contentkind = $config->anonymous ? 'document' : null;

            $annotatables = $this->get_annotatables($COURSE, $contentkind);

            $moodleversion = preg_replace('/(\d+\.\d+(\.\d+)?) .*$/', '$1', $CFG->release);

            $notelogo = $this->get_note_taking_logo_name($config->openingmode);

            $logourl = $OUTPUT->image_url($notelogo , 'filter_amanote')->__toString();

            $annotatedlogourl = $OUTPUT->image_url($notelogo . '-annotated', 'filter_amanote')->__toString();

            $savednotes = null;

            if ($config->saveinprivate) {

                $savednotes = get_user_notes_for_course($USER->id, $COURSE->id);

            }

            return json_encode([

                'siteURL' => $siteurl,

                'privateFilePath' => $privatefilepath,

                'savedNotes' => $savednotes,

                'annotatables' => $annotatables,

                'moodle' => [

                    'version' => $moodleversion,

                ],

                'plugin' => [

                    'version' => $config->version,

                    'saveInProvider' => ($config->saveinprivate == '1'),

                    'preventDownload' => ($config->preventdownload == '1'),

                    'openingMode' => $config->openingmode,

                    'target' => $config->target,

                    'key' => $config->key,

                    'anonymous' => ($config->anonymous == '1'),

                    'worksheet' => ($config->worksheet == '1'),

                    'logo' => $logourl,

                    'annotatedLogo' => $annotatedlogourl,

                ],

                'language' => $language,

                'strings' => [

                    'modalDescription' => get_string('modaldescription', 'filter_amanote'),

                    'annotateResource' => get_string('annotateresource', 'filter_amanote'),

                    'viewResource' => get_string('viewresource', 'filter_amanote'),

                    'downloadNotes' => get_string('downloadnotes', 'filter_amanote'),

                    'openAnalytics' => get_string('openanalytics', 'filter_amanote'),

                    'openPodcastCreator' => get_string('openpodcast', 'filter_amanote'),

                    'openStudentsWorks' => get_string('openstudentsworks', 'filter_amanote'),

                    'teacher' => get_string('teacher', 'filter_amanote'),

                    'deletefilewarning' => get_string('deletefilewarning', 'filter_amanote'),

                    'seeguide' => get_string('seeguide', 'filter_amanote'),

                    'stopmodal' => get_string('stopmodal', 'filter_amanote'),

                ],

            ]);

        } catch (Exception $e) {

            debugging('An error occurred: ' . $e->getMessage() . $e->getTraceAsString(), DEBUG_DEVELOPER);

        }

    }

    /**

     * Return the note-taking logo name for the given opening mode.

     *

     * @param integer $openingmode The opening mode.

     *

     * @return string The note-taking logo name.

     */

    private function get_note_taking_logo_name($openingmode) {

        $openingmodeicons = [

            '0' => 'amanote-logo',

            '1' => 'amanote-logo',

            '2' => 'note-icon',

            '3' => get_string('takenotesicon', 'filter_amanote'),

        ];

        return $openingmodeicons[$openingmode];

    }

    /**

     * Return the user params needed by the js script in JSON format.

     *

     * @return string The user params in JSON string format.

     */

    private function generate_json_user_params() {

        global $USER, $COURSE;

        $coursecontext = context_course::instance($COURSE->id, MUST_EXIST);

        $isteacher = has_capability('moodle/course:update', $coursecontext, $USER->id, false);

        $token = $this->get_current_user_token();

        return json_encode([

            'id' => $USER->id,

            'token' => [

                'value' => $token->token,

                'expiration' => $token->validuntil,

            ],

            'isTeacher' => $isteacher,

        ]);

    }

    /**

     * Return the token of the current user.

     *

     * @return token The user token.

     */

    private function get_current_user_token() {

        global $DB;

        $params = ['shortname' => MOODLE_OFFICIAL_MOBILE_SERVICE, 'enabled' => 1];

        $service = $DB->get_record('external_services', $params);

        if (empty($service)) {

            return null;

        }

        return external_generate_token_for_current_user($service);

    }

    /**

     * Return the site url.

     *

     * @return string The site url (example: https://demo.moodle.com).

     */

    private function get_site_url() {

        global $CFG;

        // Check if protocol is HTTP.

        if (preg_match('/^http:\/\//', $CFG->wwwroot)) {

            $securewwwroot = preg_replace('/^http:\/\//', 'https://', $CFG->wwwroot, 1);

            // Check if Moodle site exists in HTTPS.

            $curl = curl_init($securewwwroot);

            if (curl_exec($curl)) {

                return $securewwwroot;

            }

            curl_close($curl);

        }

        return $CFG->wwwroot;

    }

    /**

     * Return all annotatables for the given course.

     *

     * @param course $course The course.

     * @param string $contentkind Get only a specific content type.

     *

     * @return array List of all annotatable for the given course.

     */

    private function get_annotatables($course, $contentkind = null) {

        global $DB;

        $annotatables = [];

        $supportedtypes = get_supported_mimetypes($contentkind);

        // Get all the annotable files for the given course.

        $sql = "SELECT

                    {files}.id as id,

                    {course_modules}.id as cmid,

                    {course_modules}.instance as modinstance,

                    {context}.id as contextid,

                    {files}.mimetype,

                    {files}.component,

                    {files}.filearea,

                    {files}.filepath,

                    {files}.filename

                FROM {course_modules}

                    LEFT JOIN {context} ON {context}.instanceid = {course_modules}.id

                    LEFT JOIN {files} ON {files}.contextid = {context}.id

                    AND {course_modules}.course = :courseid

                    WHERE {files}.component in ('mod_resource', 'mod_label', 'mod_folder')

                    AND {files}.source IS NOT NULL AND {files}.filename != '.'

                    ";

        $files = $DB->get_records_sql($sql, ['courseid' => $course->id]);

        if (!$files || count($files) <= 0) {

            return [];

        }

        foreach ($files as $file) {

            try {

                // Add only supported files.

                if (!in_array($file->mimetype, $supportedtypes)) {

                    continue;

                }

                $annotatable = get_annotatable_for_file($file, $course->id, $file->cmid, $file->modinstance);

                // Add the annotatable to the array of annotatables.

                array_push($annotatables, $annotatable);

            } catch (Exception $e) {

                debugging('An error occurred: ' . $e->getMessage(), DEBUG_DEVELOPER);

                continue;

            }

        }

        // Add the annotables for urls.

        $annotatables = array_merge($annotatables, $this->get_annotatable_urls($course, $contentkind));

        return $annotatables;

    }

    /**

     * Return all annotable urls for a given course.

     *

     * @param course $course The course.

     * @param string $contentkind Get only a specific content type.

     *

     * @return array List of annotable urls for the given course.

     */

    private function get_annotatable_urls($course, $contentkind = null) {

        global $DB;

        $annotatables = [];

        $supportedtypes = get_supported_mimetypes($contentkind);

        // Get the urls for the given course.

        $sql = "SELECT {course_modules}.id as cmid, {url}.externalurl FROM {url}

            LEFT JOIN {course_modules} ON {course_modules}.instance = {url}.id

            LEFT JOIN {modules} ON {modules}.id = {course_modules}.module

            WHERE {course_modules}.course = :courseid

            AND {modules}.name = 'url'";

        $urls = $DB->get_records_sql($sql, ['courseid' => $course->id]);

        if (!$urls || count($urls) <= 0) {

            return $annotatables;

        }

        foreach ($urls as $url) {

            try {

                // Add only supported files.

                $annotatable = get_annotatable_for_url($url, $course->id, $url->cmid);

                if (!$annotatable->mimetype || !in_array($annotatable->mimetype, $supportedtypes)) {

                    continue;

                }

                // Add the annotatable to the array of annotatables.

                array_push($annotatables, $annotatable);

            } catch (Exception $e) {

                debugging('An error occurred: ' . $e->getMessage(), DEBUG_DEVELOPER);

                continue;

            }

        }

        return $annotatables;

    }

    /**

     * Filters the given HTML text.

     *

     * @param string $text HTML to be processed.

     * @param array $options The options.

     *

     * @return string String containing processed HTML.

     */

    public function filter($text, array $options = []) {

        return $text;

    }

}