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

/**

 * mod_bigbluebuttonbn data generator

 *

 * @package    mod_bigbluebuttonbn

 * @category   test

 * @copyright  2018 - present, Blindside Networks Inc

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

 * @author     Jesus Federico  (jesus [at] blindsidenetworks [dt] com)

 */

use core\plugininfo\mod;

use mod_bigbluebuttonbn\instance;

use mod_bigbluebuttonbn\local\config;

use mod_bigbluebuttonbn\logger;

use mod_bigbluebuttonbn\recording;

/**

 * bigbluebuttonbn module data generator

 *

 * @package    mod_bigbluebuttonbn

 * @category   test

 * @copyright  2018 - present, Blindside Networks Inc

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

 * @author     Jesus Federico  (jesus [at] blindsidenetworks [dt] com)

 */

class mod_bigbluebuttonbn_generator extends \testing_module_generator {

    /**

     * Creates an instance of bigbluebuttonbn for testing purposes.

     *

     * @param array|stdClass $record data for module being generated.

     * @param null|array $options general options for course module.

     * @return stdClass record from module-defined table with additional field cmid

     */

    public function create_instance($record = null, array $options = null) {

        // Prior to creating the instance, make sure that the BigBlueButton module is enabled.

        $modules = \core_plugin_manager::instance()->get_plugins_of_type('mod');

        if (!$modules['bigbluebuttonbn']->is_enabled()) {

            mod::enable_plugin('bigbluebuttonbn', true);

        }

        $now = time();

        $defaults = [

            "type" => 0,

            "meetingid" => sha1(rand()),

            "record" => true,

            "moderatorpass" => "mp",

            "viewerpass" => "ap",

            "participants" => "{}",

            "timecreated" => $now,

            "timemodified" => $now,

            "presentation" => null,

            "recordings_preview" => 0

        ];

        $record = (array) $record;

        $record['participants'] = json_encode($this->get_participants_from_record($record));

        foreach ($defaults as $key => $value) {

            if (!isset($record[$key])) {

                $record[$key] = $value;

            }

        }

        if ($record['presentation']) {

            global $USER;

            // Here we replace the original presentation file with a draft area in which we store this file.

            $draftareaid = file_get_unused_draft_itemid();

            $bbbfilerecord['contextid'] = context_user::instance($USER->id)->id;

            $bbbfilerecord['component'] = 'user';

            $bbbfilerecord['filearea'] = 'draft';

            $bbbfilerecord['itemid'] = $draftareaid;

            $bbbfilerecord['filepath'] = '/';

            $bbbfilerecord['filename'] = basename($record['presentation']);

            $fs = get_file_storage();

            $fs->create_file_from_pathname($bbbfilerecord, $record['presentation']);

            // Now the $record['presentation'] must contain the draftareaid.

            $record['presentation'] = $draftareaid;

        }

        return parent::create_instance((object) $record, (array) $options);

    }

    /**

     * Create the participants field data from create_instance data.

     *

     * @param array $record

     * @return array

     */

    protected function get_participants_from_record(array $record): array {

        $roles = [];

        if (array_key_exists('moderators', $record) && !empty($record['moderators'])) {

            $roles = array_merge(

                $roles,

                $this->get_participant_configuration($record['moderators'], 'moderator')

            );

            unset($record['moderators']);

        }

        if (array_key_exists('viewers', $record) && !empty($record['viewers'])) {

            $roles = array_merge(

                $roles,

                $this->get_participant_configuration($record['viewers'], 'viewer')

            );

            unset($record['viewers']);

        }

        if (!empty($roles)) {

            array_unshift($roles, (object) [

                'selectiontype' => 'all',

                'selectionid' => 'all',

                'role' => 'viewer',

            ]);

        }

        return $roles;

    }

    /**

     * Get the participant configuration for a field and role for use in get_participants_from_record.

     *

     * @param string $field

     * @param string $role

     * @return array

     */

    protected function get_participant_configuration(string $field, string $role): array {

        global $DB;

        $values = explode(',', $field);

        $roles = $DB->get_records_menu('role', [], '', 'shortname, id');

        $configuration = [];

        foreach ($values as $value) {

            if (empty($value)) {

                // Empty value.

                continue;

            }

            [$type, $name] = explode(':', $value);

            $participant = (object) [

                'selectiontype' => $type,

                'role' => $role,

            ];

            switch ($type) {

                case 'role':

                    if (!array_key_exists($name, $roles)) {

                        throw new \coding_exception("Unknown role '{$name}'");

                    }

                    $participant->selectionid = $roles[$name];

                    break;

                case 'user':

                    $participant->selectionid = $DB->get_field('user', 'id', ['username' => $name], MUST_EXIST);

                    break;

                default:

                    throw new \coding_exception("Unknown participant type: '{$type}'");

            }

            $configuration[] = $participant;

        }

        return $configuration;

    }

    /**

     * Create a recording for the given bbb activity.

     *

     * The recording is created both locally, and a recording record is created on the mocked BBB server.

     *

     * @param array $data

     * @param bool $serveronly create it only on the server, not in the database.

     * @return stdClass the recording object

     */

    public function create_recording(array $data, $serveronly = false): stdClass {

        $instance = instance::get_from_instanceid($data['bigbluebuttonbnid']);

        if (isset($data['imported']) && filter_var($data['imported'], FILTER_VALIDATE_BOOLEAN)) {

            if (empty($data['importedid'])) {

                throw new moodle_exception('error');

            }

            $recording = recording::get_record(['recordingid' => $data['importedid']]);

            $recording->imported = true;

        } else {

            $recording = (object) [

                'headless' => false,

                'imported' => false,

                'status' => $data['status'] ?? recording::RECORDING_STATUS_NOTIFIED,

            ];

        }

        if (!empty($data['groupid'])) {

            $instance->set_group_id($data['groupid']);

            $recording->groupid = $data['groupid'];

        }

        $recording->bigbluebuttonbnid = $instance->get_instance_id();

        $recording->courseid = $instance->get_course_id();

        if (isset($options['imported']) && $options['imported']) {

            $precording = $recording->create_imported_recording($instance);

        } else {

            if ($recording->status == recording::RECORDING_STATUS_DISMISSED) {

                $recording->recordingid = sprintf(

                    "%s-%s",

                    md5($instance->get_meeting_id()),

                    time() + rand(1, 100000)

                );

            } else {

                $recording->recordingid = $this->create_mockserver_recording($instance, $recording, $data);

            }

            $precording = new recording(0, $recording);

            if (!$serveronly) {

                $precording->create();

            }

        }

        return $precording->to_record();

    }

    /**

     * Add a recording in the mock server

     *

     * @param instance $instance

     * @param stdClass $recordingdata

     * @param array $data

     * @return string

     */

    protected function create_mockserver_recording(instance $instance, stdClass $recordingdata, array $data): string {

        $now = time();

        $mockdata = array_merge((array) $recordingdata, [

            'sequence' => 1,

            'meta' => [

                'bn-presenter-name' => $data['presentername'] ?? 'Fake presenter',

                'bn-recording-ready-url' => new moodle_url('/mod/bigbluebuttonbn/bbb_broker.php', [

                    'action' => 'recording_ready',

                    'bigbluebuttonbn' => $instance->get_instance_id()

                ]),

                'bbb-recording-description' => $data['description'] ?? '',

                'bbb-recording-name' => $data['name'] ?? '',

                'bbb-recording-tags' => $data['tags'] ?? '',

            ],

        ]);

        $mockdata['startTime'] = $data['starttime'] ?? $now;

        $mockdata['endTime'] = $data['endtime'] ?? $mockdata['startTime'] + HOURSECS;

        if (!empty($data['playback'])) {

            $mockdata['playback'] = json_encode($data['playback']);

        }

        if (!empty($data['isBreakout'])) {

            // If it is a breakout meeting, we do not have any way to know the real Id of the meeting

            // unless we query the list of submeetings.

            // For now we will just send the parent ID and let the mock server deal with the sequence + parentID

            // to find the meetingID.

            $mockdata['parentMeetingID'] = $instance->get_meeting_id();

        } else {

            $mockdata['meetingID'] = $instance->get_meeting_id();

        }

        $result = $this->send_mock_request('backoffice/createRecording', [], $mockdata);

        return (string) $result->recordID;

    }

    /**

     * Utility to send a request to the mock server

     *

     * @param string $endpoint

     * @param array $params

     * @param array $mockdata

     * @return SimpleXMLElement|bool

     * @throws moodle_exception

     */

    protected function send_mock_request(string $endpoint, array $params = [], array $mockdata = []): SimpleXMLElement {

        $url = $this->get_mocked_server_url($endpoint, $params);

        foreach ($mockdata as $key => $value) {

            if (is_array($value)) {

                foreach ($value as $subkey => $subvalue) {

                    $paramname = "{$key}_{$subkey}";

                    $url->param($paramname, $subvalue);

                }

            } else {

                $url->param($key, $value);

            }

        }

        $curl = new \curl();

        $result = $curl->get($url->out_omit_querystring(), $url->params());

        $retvalue = @simplexml_load_string($result, 'SimpleXMLElement', LIBXML_NOCDATA | LIBXML_NOBLANKS);

        if ($retvalue === false) {

            throw new moodle_exception('mockserverconnfailed', 'mod_bigbluebutton');

        }

        return $retvalue;

    }

    /**

     * Get a URL for a mocked BBB server endpoint.

     *

     * @param string $endpoint

     * @param array $params

     * @return moodle_url

     */

    protected function get_mocked_server_url(string $endpoint = '', array $params = []): moodle_url {

        return new moodle_url(TEST_MOD_BIGBLUEBUTTONBN_MOCK_SERVER . '/' . $endpoint, $params);

    }

    /**

     * Mock an in-progress meeting on the remote server.

     *

     * @param array $data

     * @return stdClass

     */

    public function create_meeting(array $data): stdClass {

        $instance = instance::get_from_instanceid($data['instanceid']);

        if (array_key_exists('groupid', $data)) {

            $instance = instance::get_group_instance_from_instance($instance, $data['groupid']);

        }

        $meetingid = $instance->get_meeting_id();

        // Default room configuration.

        $roomconfig = array_merge($data, [

            'meetingName' => $instance->get_meeting_name(),

            'attendeePW' => $instance->get_viewer_password(),

            'moderatorPW' => $instance->get_moderator_password(),

            'voiceBridge' => $instance->get_voice_bridge(),

            'meta' => [

                'bbb-context' => $instance->get_course()->fullname,

                'bbb-context-id' => $instance->get_course()->id,

                'bbb-context-label' => $instance->get_course()->shortname,

                'bbb-context-name' => $instance->get_course()->fullname,

                'bbb-origin' => 'Moodle',

                'bbb-origin-tag' => 'moodle-mod_bigbluebuttonbn (TODO version)',

                'bbb-recording-description' => $instance->get_meeting_description(),

                'bbb-recording-name' => $instance->get_meeting_name(),

            ],

        ]);

        if ((boolean) config::get('recordingready_enabled')) {

            $roomconfig['meta']['bn-recording-ready-url'] = $instance->get_record_ready_url()->out(false);

        }

        if ((boolean) config::get('meetingevents_enabled')) {

            $roomconfig['meta']['analytics-callback-url'] = $instance->get_meeting_event_notification_url()->out(false);

        }

        if (!empty($roomconfig['isBreakout'])) {

            // If it is a breakout meeting, we do not have any way to know the real Id of the meeting

            // For now we will just send the parent ID and let the mock server deal with the sequence + parentID

            // to find the meetingID.

            $roomconfig['parentMeetingID'] = $instance->get_meeting_id();

        } else {

            $roomconfig['meetingID'] = $meetingid;

        }

        $this->send_mock_request('backoffice/createMeeting', [], $roomconfig);

        return (object) $roomconfig;

    }

    /**

     * Create a log record

     *

     * @param mixed $record

     * @param array|null $options

     */

    public function create_log($record, array $options = null) {

        $instance = instance::get_from_instanceid($record['bigbluebuttonbnid']);

        $record = array_merge([

            'meetingid' => $instance->get_meeting_id(),

        ], (array) $record);

        $testlogclass = new class extends logger {

            /**

             * Log test event

             *

             * @param instance $instance

             * @param array $record

             */

            public static function log_test_event(instance $instance, array $record): void {

                self::log(

                    $instance,

                    logger::EVENT_CREATE,

                    $record

                );

            }

        };

        $testlogclass::log_test_event($instance, $record);

    }

    /**

     * Set a value in the Mock server

     *

     * @param string $name

     * @param mixed $value

     * @return void

     * @throws moodle_exception

     */

    public function set_value(string $name, $value): void {

        if (defined('TEST_MOD_BIGBLUEBUTTONBN_MOCK_SERVER')) {

            $this->send_mock_request('backoffice/set', [], ['name' => $name, 'value' => json_encode($value)]);

        }

    }

    /**

     * Trigger a meeting event on BBB side

     *

     * @param object $user

     * @param instance $instance

     * @param string $eventtype

     * @param string|null $eventdata

     * @return void

     */

    public function add_meeting_event(object $user, instance $instance, string $eventtype, string $eventdata = ''): void {

        $this->send_mock_request('backoffice/addMeetingEvent', [

                'secret' => \mod_bigbluebuttonbn\local\config::DEFAULT_SHARED_SECRET,

                'meetingID' => $instance->get_meeting_id(),

                'attendeeID' => $user->id,

                'attendeeName' => fullname($user),

                'eventType' => $eventtype,

                'eventData' => $eventdata

            ]

        );

    }

    /**

     * Send all previously store events

     *

     * @param instance $instance

     * @return object|null

     */

    public function send_all_events(instance $instance): ?object {

        if (defined('TEST_MOD_BIGBLUEBUTTONBN_MOCK_SERVER')) {

            return $this->send_mock_request('backoffice/sendAllEvents', [

                'meetingID' => $instance->get_meeting_id(),

                'sendQuery' => false, // We get the result directly here.

                'secret' => \mod_bigbluebuttonbn\local\config::DEFAULT_SHARED_SECRET,

            ]);

        }

        return null;

    }

    /**

     * Reset the mock server

     */

    public function reset_mock(): void {

        if (defined('TEST_MOD_BIGBLUEBUTTONBN_MOCK_SERVER')) {

            $this->send_mock_request('backoffice/reset');

        }

    }

}