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

declare(strict_types=1);

namespace mod_edusharing;

use coding_exception;

use dml_exception;

use EduSharingApiClient\CurlResult;

use EduSharingApiClient\CurlHandler as EdusharingCurlHandler;

use EduSharingApiClient\DisplayMode;

use EduSharingApiClient\EduSharingAuthHelper;

use EduSharingApiClient\EduSharingHelperBase;

use EduSharingApiClient\EduSharingNodeHelper;

use EduSharingApiClient\EduSharingNodeHelperConfig;

use EduSharingApiClient\MissingRightsException;

use EduSharingApiClient\NodeDeletedException;

use EduSharingApiClient\UrlHandling;

use EduSharingApiClient\Usage;

use EduSharingApiClient\UsageDeletedException;

use Exception;

use JsonException;

use moodle_exception;

use require_login_exception;

use stdClass;

/**

 * class EduSharingService

 *

 * Wrapper service class for API utilities bundled in the auth plugin

 *

 * @author Marian Ziegler <ziegler@edu-sharing.net>

 * @package mod_edusharing

 */

class EduSharingService {

    /**

     * @var EduSharingAuthHelper|null

     */

    private ?EduSharingAuthHelper $authhelper;

    /**

     * @var EduSharingNodeHelper|null

     */

    private ?EduSharingNodeHelper $nodehelper;

    /**

     * @var UtilityFunctions|null

     */

    private ?UtilityFunctions     $utils;

    /**

     * EduSharingService constructor

     *

     * constructor params are optional if you want to use DI.

     * This possibility is needed for unit testing

     *

     * @param EduSharingAuthHelper|null $authhelper

     * @param EduSharingNodeHelper|null $nodehelper

     * @param UtilityFunctions|null $utils

     * @throws dml_exception

     */

    public function __construct(

        ?EduSharingAuthHelper $authhelper = null,

        ?EduSharingNodeHelper $nodehelper = null,

        ?UtilityFunctions $utils = null

    ) {

        $this->authhelper = $authhelper;

        $this->nodehelper = $nodehelper;

        $this->utils      = $utils;

        global $CFG;

        require_once($CFG->dirroot . '/mod/edusharing/eduSharingAutoloader.php');

        $this->init();

    }

    /**

     * Function init

     *

     * @throws dml_exception

     * @throws Exception

     */

    private function init(): void {

        global $CFG;

        $this->utils === null && $this->utils = new UtilityFunctions();

        if ($this->authhelper === null || $this->nodehelper === null) {

            $internalurl = $this->utils->get_internal_url();

            $basehelper  = new EduSharingHelperBase(

                $internalurl,

                $this->utils->get_config_entry('application_private_key'),

                $this->utils->get_config_entry('application_appid')

            );

            $basehelper->registerCurlHandler(new MoodleCurlHandler());

            $this->authhelper === null && $this->authhelper = new EduSharingAuthHelper($basehelper);

            if ($this->nodehelper === null) {

                $nodeconfig       = new EduSharingNodeHelperConfig(

                    new UrlHandling(

                        true,

                        $CFG->wwwroot . "/filter/edusharing/inlineHelper.php?sesskey=" . sesskey()

                    )

                );

                $this->nodehelper = new EduSharingNodeHelper($basehelper, $nodeconfig);

            }

        }

    }

    /**

     * Function create_usage

     *

     * @param stdClass $usagedata

     * @return Usage

     * @throws JsonException

     * @throws MissingRightsException

     * @throws Exception

     */

    public function create_usage(stdClass $usagedata): Usage {

        return $this->nodehelper->createUsage(

            !empty($usagedata->ticket) ? $usagedata->ticket : $this->get_ticket(),

            (string)$usagedata->containerId,

            (string)$usagedata->resourceId,

            (string)$usagedata->nodeId,

            (string)$usagedata->nodeVersion

        );

    }

    /**

     * Function get_usage_id

     *

     * @param stdClass $usagedata

     * @return string

     * @throws Exception

     */

    public function get_usage_id(stdClass $usagedata): string {

        $usageid = $this->nodehelper->getUsageIdByParameters($usagedata->ticket,

            $usagedata->nodeId,

            $usagedata->containerId,

            $usagedata->resourceId

        );

        $usageid === null && throw new Exception('No usage found: ' . json_encode($usagedata));

        return $usageid;

    }

    /**

     * Function delete_usage

     *

     * @param stdClass $usagedata

     * @throws Exception

     */

    public function delete_usage(stdClass $usagedata): void {

        !isset($usagedata->usageId) && throw new Exception('No usage id provided, deletion cannot be performed');

        try {

            $this->nodehelper->deleteUsage($usagedata->nodeId, $usagedata->usageId);

        } catch (UsageDeletedException $usagedeletedexception) {

            debugging('noted, deleting locally: ' . $usagedeletedexception->getMessage());

        }

    }

    /**

     * Function get_node

     *

     * @param Usage $usage

     * @param array|null $renderingparams

     * @param string|null $userid

     * @return array

     * @throws JsonException

     * @throws NodeDeletedException

     * @throws UsageDeletedException

     */

    public function get_node(Usage $usage, ?array $renderingparams = null, ?string $userid = null): array {

        return $this->nodehelper->getNodeByUsage($usage, DisplayMode::INLINE, $renderingparams, $userid);

    }

    /**

     * Function get_redirect_url

     *

     * @param Usage $usage

     * @param string|null $userid

     * @param string $mode

     * @return string

     * @throws JsonException

     * @throws NodeDeletedException

     * @throws UsageDeletedException

     */

    public function get_redirect_url(Usage $usage, ?string $userid = null, string $mode = 'content'): string {

        return $this->nodehelper->getRedirectUrl($mode, $usage, [], $userid);

    }

    /**

     * Function get_ticket

     *

     * @throws Exception

     */

    public function get_ticket(): string {

        global $USER;

        if (isset($USER->edusharing_userticket)) {

            if (isset($USER->edusharing_userticketvalidationts) && time() - $USER->edusharing_userticketvalidationts < 10) {

                return $USER->edusharing_userticket;

            }

            $ticketinfo = $this->authhelper->getTicketAuthenticationInfo($USER->edusharing_userticket);

            if ($ticketinfo['statusCode'] === 'OK') {

                $USER->edusharing_userticketvalidationts = time();

                return $USER->edusharing_userticket;

            }

        }

        $additionalfields = null;

        if ($this->utils->get_config_entry('send_additional_auth') === '1') {

            $additionalfields = [

                'firstName' => $USER->firstname,

                'lastName'  => $USER->lastname,

                'email'     => $USER->email,

            ];

        }

        return $this->authhelper->getTicketForUser($this->utils->get_auth_key(), $additionalfields);

    }

    /**

     * Function delete_instance

     *

     * Given an ID of an instance of this module,

     * this function will permanently delete the instance

     * and any data that depends on it.

     *

     * @param string $id

     * @return void

     * @throws dml_exception

     * @throws Exception

     */

    public function delete_instance(string $id): void {

        global $DB;

        $edusharing             = $DB->get_record('edusharing', ['id' => $id], '*', MUST_EXIST);

        $usagedata              = new stdClass();

        $usagedata->ticket      = $this->get_ticket();

        $usagedata->nodeId      = $this->utils->get_object_id_from_url($edusharing->object_url);

        $usagedata->containerId = $edusharing->course;

        $usagedata->resourceId  = $edusharing->id;

        $usagedata->usageId    = empty($edusharing->usage_id) ? $this->get_usage_id($usagedata) : $edusharing->usage_id;

        $this->delete_usage($usagedata);

        $DB->delete_records('edusharing', ['id' => $edusharing->id]);

    }

    /**

     * Function add_instance

     *

     * @param stdClass $edusharing

     * @param int|null $updatetime

     * @return bool|int

     */

    public function add_instance(stdClass $edusharing, ?int $updatetime = null): bool|int {

        global $DB;

        $edusharing->timecreated  = $updatetime ?? time();

        $edusharing->timemodified = $updatetime ?? time();

        // You may have to add extra stuff in here.

        $this->post_process_edusharing_object($edusharing, $updatetime);

        if (isset($_POST['object_version']) && $_POST['object_version'] != '0') {

            $edusharing->object_version = $_POST['object_version'];

        }

        // Use simple version handling for atto plugin or legacy code.

        if (isset($edusharing->editor_atto)) {

            // Avoid database error.

            $edusharing->introformat = 0;

        } else if (isset($edusharing->window_versionshow) && $edusharing->window_versionshow == 'current') {

            $edusharing->object_version = $edusharing->window_version;

        }

        try {

            $id = $DB->insert_record('edusharing', $edusharing);

        } catch (Exception $exception) {

            debugging($exception->getMessage());

            return false;

        }

        $usagedata              = new stdClass();

        $usagedata->containerId = $edusharing->course;

        $usagedata->resourceId  = $id;

        $usagedata->nodeId      = $this->utils->get_object_id_from_url($edusharing->object_url);

        $usagedata->nodeVersion = $edusharing->object_version;

        try {

            $usage                = $this->create_usage($usagedata);

            $edusharing->id       = $id;

            $edusharing->usage_id = $usage->usageId;

            $DB->update_record('edusharing', $edusharing);

            return $id;

        } catch (Exception $exception) {

            !empty($exception->getMessage()) && debugging($exception->getMessage());

            try {

                $DB->delete_records('edusharing', ['id' => $id]);

            } catch (Exception $deleteexception) {

                debugging($deleteexception->getMessage());

            }

            return false;

        }

    }

    /**

     * Function update_instance

     *

     * @param stdClass $edusharing

     * @param int|null $updatetime

     * @return bool

     */

    public function update_instance(stdClass $edusharing, ?int $updatetime = null): bool {

        global $DB;

        // FIX: when editing a moodle-course-module the $edusharing->id will be named $edusharing->instance.

        if (!empty($edusharing->instance)) {

            $edusharing->id = $edusharing->instance;

        }

        $this->post_process_edusharing_object($edusharing, $updatetime);

        $usagedata              = new stdClass();

        $usagedata->containerId = $edusharing->course;

        $usagedata->resourceId  = $edusharing->id;

        $usagedata->nodeId      = $this->utils->get_object_id_from_url($edusharing->object_url);

        $usagedata->nodeVersion = $edusharing->object_version;

        try {

            $memento           = $DB->get_record('edusharing', ['id' => $edusharing->id], '*', MUST_EXIST);

            $usagedata->ticket = $this->get_ticket();

        } catch (Exception $exception) {

            unset($exception);

            return false;

        }

        try {

            $usage                = $this->create_usage($usagedata);

            $edusharing->usage_id = $usage->usageId;

            $DB->update_record('edusharing', $edusharing);

        } catch (Exception $exception) {

            !empty($exception->getMessage()) && debugging($exception->getMessage());

            try {

                $DB->update_record('edusharing', $memento);

            } catch (Exception $updateexception) {

                !empty($exception->getMessage()) && debugging($updateexception->getMessage());

            }

            return false;

        }

        return true;

    }

    /**

     * Function post_process_edusharing_object

     *

     * @param stdClass $edusharing

     * @param int|null $updatetime

     * @return void

     */

    private function post_process_edusharing_object(stdClass $edusharing, ?int $updatetime = null): void {

        if ($updatetime === null) {

            $updatetime = time();

        }

        global $COURSE;

        if (empty($edusharing->timecreated)) {

            $edusharing->timecreated = $updatetime;

        }

        $edusharing->timeupdated = $updatetime;

        if (!empty($edusharing->force_download)) {

            $edusharing->force_download = 1;

            $edusharing->popup_window   = 0;

        } else if (!empty($edusharing->popup_window)) {

            $edusharing->force_download = 0;

            $edusharing->options        = '';

        } else {

            if (empty($edusharing->blockdisplay)) {

                $edusharing->options = '';

            }

            $edusharing->popup_window = '';

        }

        $edusharing->tracking = empty($edusharing->tracking) ? 0 : $edusharing->tracking;

        if (!$edusharing->course) {

            $edusharing->course = $COURSE->id;

        }

    }

    /**

     * Function import_metadata

     *

     * @param string $url

     * @return CurlResult

     */

    public function import_metadata(string $url): CurlResult {

        $curloptions = [

            CURLOPT_SSL_VERIFYPEER => false,

            CURLOPT_SSL_VERIFYHOST => false,

            CURLOPT_FOLLOWLOCATION => 1,

            CURLOPT_HEADER         => 0,

            CURLOPT_RETURNTRANSFER => 1,

            CURLOPT_USERAGENT      => $_SERVER['HTTP_USER_AGENT'],

        ];

        return $this->authhelper->base->handleCurlRequest($url, $curloptions);

    }

    /**

     * Function validate_session

     *

     * @param string $url

     * @param string $auth

     * @return CurlResult

     */

    public function validate_session(string $url, string $auth): CurlResult {

        $headers = [

            'Content-Type: application/json',

            'Accept: application/json',

            'Authorization: Basic ' . base64_encode($auth),

        ];

        $url     = rtrim($url, '/') . '/rest/authentication/v1/validateSession';

        return $this->authhelper->base->handleCurlRequest($url, [

            CURLOPT_RETURNTRANSFER => 1,

            CURLOPT_HTTPHEADER     => $headers,

        ]);

    }

    /**

     * Function register_plugin

     *

     * @param string $url

     * @param string $delimiter

     * @param string $body

     * @param string $auth

     * @return CurlResult

     */

    public function register_plugin(string $url, string $delimiter, string $body, string $auth): CurlResult {

        $registrationurl = rtrim($url, '/') . '/rest/admin/v1/applications/xml';

        $headers         = [

            'Content-Type: multipart/form-data; boundary=' . $delimiter,

            'Content-Length: ' . strlen($body),

            'Accept: application/json',

            'Authorization: Basic ' . base64_encode($auth),

        ];

        $this->authhelper->base->curlHandler->setMethod(EdusharingCurlHandler::METHOD_PUT);

        return $this->authhelper->base->handleCurlRequest($registrationurl, [

            CURLOPT_RETURNTRANSFER => 1,

            CURLOPT_HTTPHEADER     => $headers,

            CURLOPT_POSTFIELDS     => $body,

        ]);

    }

    /**

     * Function sign

     *

     * @param string $input

     * @return string

     */

    public function sign(string $input): string {

        return $this->nodehelper->base->sign($input);

    }

    /**

     * Function get_render_html

     *

     * @param string $url

     * @return string

     */

    public function get_render_html(string $url): string {

        $curloptions = [

            CURLOPT_SSL_VERIFYPEER => false,

            CURLOPT_SSL_VERIFYHOST => false,

            CURLOPT_FOLLOWLOCATION => 1,

            CURLOPT_HEADER         => 0,

            CURLOPT_RETURNTRANSFER => 1,

            CURLOPT_USERAGENT      => $_SERVER['HTTP_USER_AGENT'],

        ];

        $result      = $this->authhelper->base->handleCurlRequest($url, $curloptions);

        if ($result->error !== 0) {

            try {

                return 'Unexpected Error';

            } catch (Exception $exception) {

                return $exception->getMessage();

            }

        }

        return $result->content;

    }

    /**

     * Function require_edu_login

     *

     * @param int|null $courseid

     * @param bool $checkticket

     * @param bool $checksessionkey

     * @throws coding_exception

     * @throws moodle_exception

     * @throws require_login_exception

     * @throws Exception

     */

    public function require_edu_login(?int $courseid = null, bool $checkticket = true, bool $checksessionkey = true): void {

        require_login($courseid);

        $checksessionkey && require_sesskey();

        $checkticket && $this->get_ticket();

    }

    /**

     * Function get_preview_image

     *

     * @param Usage $usage

     * @return CurlResult

     */

    public function get_preview_image(Usage $usage): CurlResult {

        return $this->nodehelper->getPreview($usage);

    }

}