Laurent David
6729c4b955
* In the bigbluebutton_proxy::action_url call to submodules, we need a way to get the instance this is called upon so we can have information (parameters) for this instance settings (like the new settings introduced by subplugins). * Add the optional instanceid parameter in join/create/getMeetingInfo calls
568 lines
19 KiB
PHP
568 lines
19 KiB
PHP
<?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/>.
|
|
|
|
namespace mod_bigbluebuttonbn\local\proxy;
|
|
|
|
use cache;
|
|
use completion_info;
|
|
use Exception;
|
|
use mod_bigbluebuttonbn\completion\custom_completion;
|
|
use mod_bigbluebuttonbn\instance;
|
|
use mod_bigbluebuttonbn\local\config;
|
|
use mod_bigbluebuttonbn\local\exceptions\bigbluebutton_exception;
|
|
use mod_bigbluebuttonbn\local\exceptions\server_not_available_exception;
|
|
use moodle_url;
|
|
use stdClass;
|
|
use user_picture;
|
|
|
|
/**
|
|
* The bigbluebutton proxy class.
|
|
*
|
|
* This class acts as a proxy between Moodle and the BigBlueButton API server,
|
|
* and handles all requests relating to the server and meetings.
|
|
*
|
|
* @package mod_bigbluebuttonbn
|
|
* @copyright 2010 onwards, 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 bigbluebutton_proxy extends proxy_base {
|
|
|
|
/**
|
|
* Minimum poll interval for remote bigbluebutton server in seconds.
|
|
*/
|
|
const MIN_POLL_INTERVAL = 2;
|
|
|
|
/**
|
|
* Default poll interval for remote bigbluebutton server in seconds.
|
|
*/
|
|
const DEFAULT_POLL_INTERVAL = 5;
|
|
|
|
/**
|
|
* Builds and returns a url for joining a BigBlueButton meeting.
|
|
*
|
|
* @param instance $instance
|
|
* @param string|null $createtime
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function get_join_url(
|
|
instance $instance,
|
|
?string $createtime
|
|
): string {
|
|
return self::internal_get_join_url($instance, $createtime);
|
|
}
|
|
|
|
/**
|
|
* Builds and returns a url for joining a BigBlueButton meeting.
|
|
*
|
|
* @param instance $instance
|
|
* @param string|null $createtime
|
|
* @param string $username
|
|
* @return string
|
|
*/
|
|
public static function get_guest_join_url(
|
|
instance $instance,
|
|
?string $createtime,
|
|
string $username
|
|
): string {
|
|
return self::internal_get_join_url($instance, $createtime, $username, true);
|
|
}
|
|
|
|
/**
|
|
* Internal helper method to builds and returns a url for joining a BigBlueButton meeting.
|
|
*
|
|
* @param instance $instance
|
|
* @param string|null $jointime = null
|
|
* @param string|null $userfullname
|
|
* @param bool $isguestjoin
|
|
* @return string
|
|
*/
|
|
private static function internal_get_join_url(
|
|
instance $instance,
|
|
?string $jointime,
|
|
string $userfullname = null,
|
|
bool $isguestjoin = false
|
|
): string {
|
|
$data = [
|
|
'meetingID' => $instance->get_meeting_id(),
|
|
'fullName' => $userfullname ?? $instance->get_user_fullname(),
|
|
'password' => $instance->get_current_user_password(),
|
|
'logoutURL' => $isguestjoin ? $instance->get_guest_access_url()->out(false) : $instance->get_logout_url()->out(false),
|
|
'role' => $instance->get_current_user_role()
|
|
];
|
|
|
|
if (!$isguestjoin) {
|
|
$data['userID'] = $instance->get_user_id();
|
|
$data['guest'] = "false";
|
|
} else {
|
|
$data['guest'] = "true";
|
|
}
|
|
|
|
if (!is_null($jointime)) {
|
|
$data['createTime'] = $jointime;
|
|
}
|
|
$currentlang = current_language();
|
|
if (!empty(trim($currentlang))) {
|
|
$data['userdata-bbb_override_default_locale'] = $currentlang;
|
|
}
|
|
if ($instance->is_profile_picture_enabled()) {
|
|
$user = $instance->get_user();
|
|
if (!empty($user->picture)) {
|
|
$data['avatarURL'] = self::get_avatar_url($user)->out(false);
|
|
}
|
|
}
|
|
return self::action_url('join', $data, [], $instance->get_instance_id());
|
|
}
|
|
|
|
/**
|
|
* Get user avatar URL
|
|
*
|
|
* @param stdClass $user
|
|
* @return moodle_url
|
|
*/
|
|
private static function get_avatar_url(stdClass $user): moodle_url {
|
|
global $PAGE;
|
|
$userpicture = new user_picture($user);
|
|
$userpicture->includetoken = true;
|
|
$userpicture->size = 3; // Size f3.
|
|
return $userpicture->get_url($PAGE);
|
|
}
|
|
|
|
/**
|
|
* Perform api request on BBB.
|
|
*
|
|
* @return null|string
|
|
*/
|
|
public static function get_server_version(): ?string {
|
|
$cache = cache::make('mod_bigbluebuttonbn', 'serverinfo');
|
|
$serverversion = $cache->get('serverversion');
|
|
|
|
if (!$serverversion) {
|
|
$xml = self::fetch_endpoint_xml('');
|
|
if (!$xml || $xml->returncode != 'SUCCESS') {
|
|
return null;
|
|
}
|
|
|
|
if (!isset($xml->version)) {
|
|
return null;
|
|
}
|
|
|
|
$serverversion = (string) $xml->version;
|
|
$cache->set('serverversion', $serverversion);
|
|
}
|
|
|
|
return (double) $serverversion;
|
|
}
|
|
|
|
/**
|
|
* Helper for getting the owner userid of a bigbluebuttonbn instance.
|
|
*
|
|
* @param stdClass $bigbluebuttonbn BigBlueButtonBN instance
|
|
* @return int ownerid (a valid user id or null if not registered/found)
|
|
*/
|
|
public static function get_instance_ownerid(stdClass $bigbluebuttonbn): int {
|
|
global $DB;
|
|
|
|
$filters = [
|
|
'bigbluebuttonbnid' => $bigbluebuttonbn->id,
|
|
'log' => 'Add',
|
|
];
|
|
|
|
return (int) $DB->get_field('bigbluebuttonbn_logs', 'userid', $filters);
|
|
}
|
|
|
|
/**
|
|
* Helper evaluates if a voicebridge number is unique.
|
|
*
|
|
* @param int $instance
|
|
* @param int $voicebridge
|
|
* @return bool
|
|
*/
|
|
public static function is_voicebridge_number_unique(int $instance, int $voicebridge): bool {
|
|
global $DB;
|
|
if ($voicebridge == 0) {
|
|
return true;
|
|
}
|
|
$select = 'voicebridge = ' . $voicebridge;
|
|
if ($instance != 0) {
|
|
$select .= ' AND id <>' . $instance;
|
|
}
|
|
if (!$DB->get_records_select('bigbluebuttonbn', $select)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Helper function validates a remote resource.
|
|
*
|
|
* @param string $url
|
|
* @return bool
|
|
*/
|
|
public static function is_remote_resource_valid(string $url): bool {
|
|
$urlhost = parse_url($url, PHP_URL_HOST);
|
|
$serverurlhost = parse_url(\mod_bigbluebuttonbn\local\config::get('server_url'), PHP_URL_HOST);
|
|
|
|
if ($urlhost == $serverurlhost) {
|
|
// Skip validation when the recording URL host is the same as the configured BBB server.
|
|
return true;
|
|
}
|
|
|
|
$cache = cache::make('mod_bigbluebuttonbn', 'validatedurls');
|
|
|
|
if ($cachevalue = $cache->get($urlhost)) {
|
|
// Skip validation when the recording URL was already validated.
|
|
return $cachevalue == 1;
|
|
}
|
|
|
|
$curl = new curl();
|
|
$curl->head($url);
|
|
|
|
$isvalid = false;
|
|
if ($info = $curl->get_info()) {
|
|
if ($info['http_code'] == 200) {
|
|
$isvalid = true;
|
|
} else {
|
|
debugging(
|
|
"Resources hosted by {$urlhost} are unreachable. Server responded with {$info['http_code']}",
|
|
DEBUG_DEVELOPER
|
|
);
|
|
$isvalid = false;
|
|
}
|
|
|
|
// Note: When a cache key is not found, it returns false.
|
|
// We need to distinguish between a result not found, and an invalid result.
|
|
$cache->set($urlhost, $isvalid ? 1 : 0);
|
|
}
|
|
|
|
return $isvalid;
|
|
}
|
|
|
|
/**
|
|
* Helper function enqueues one user for being validated as for completion.
|
|
*
|
|
* @param stdClass $bigbluebuttonbn
|
|
* @param int $userid
|
|
* @return void
|
|
*/
|
|
public static function enqueue_completion_event(stdClass $bigbluebuttonbn, int $userid): void {
|
|
try {
|
|
// Create the instance of completion_update_state task.
|
|
$task = new \mod_bigbluebuttonbn\task\completion_update_state();
|
|
// Add custom data.
|
|
$data = [
|
|
'bigbluebuttonbn' => $bigbluebuttonbn,
|
|
'userid' => $userid,
|
|
];
|
|
$task->set_custom_data($data);
|
|
// CONTRIB-7457: Task should be executed by a user, maybe Teacher as Student won't have rights for overriding.
|
|
// $ task -> set_userid ( $ user -> id );.
|
|
// Enqueue it.
|
|
\core\task\manager::queue_adhoc_task($task);
|
|
} catch (Exception $e) {
|
|
mtrace("Error while enqueuing completion_update_state task. " . (string) $e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper function enqueues completion trigger.
|
|
*
|
|
* @param stdClass $bigbluebuttonbn
|
|
* @param int $userid
|
|
* @return void
|
|
*/
|
|
public static function update_completion_state(stdClass $bigbluebuttonbn, int $userid) {
|
|
global $CFG;
|
|
require_once($CFG->libdir . '/completionlib.php');
|
|
list($course, $cm) = get_course_and_cm_from_instance($bigbluebuttonbn, 'bigbluebuttonbn');
|
|
$completion = new completion_info($course);
|
|
if (!$completion->is_enabled($cm)) {
|
|
mtrace("Completion not enabled");
|
|
return;
|
|
}
|
|
|
|
$bbbcompletion = new custom_completion($cm, $userid);
|
|
if ($bbbcompletion->get_overall_completion_state()) {
|
|
mtrace("Completion for userid $userid and bigbluebuttonid {$bigbluebuttonbn->id} updated.");
|
|
$completion->update_state($cm, COMPLETION_COMPLETE, $userid, true);
|
|
} else {
|
|
// Still update state to current value (prevent unwanted caching).
|
|
$completion->update_state($cm, COMPLETION_UNKNOWN, $userid);
|
|
mtrace("Activity not completed for userid $userid and bigbluebuttonid {$bigbluebuttonbn->id}.");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper function returns an array with the profiles (with features per profile) for the different types
|
|
* of bigbluebuttonbn instances.
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function get_instance_type_profiles(): array {
|
|
$instanceprofiles = [
|
|
instance::TYPE_ALL => [
|
|
'id' => instance::TYPE_ALL,
|
|
'name' => get_string('instance_type_default', 'bigbluebuttonbn'),
|
|
'features' => ['all']
|
|
],
|
|
instance::TYPE_ROOM_ONLY => [
|
|
'id' => instance::TYPE_ROOM_ONLY,
|
|
'name' => get_string('instance_type_room_only', 'bigbluebuttonbn'),
|
|
'features' => ['showroom', 'welcomemessage', 'voicebridge', 'waitformoderator', 'userlimit',
|
|
'recording', 'sendnotifications', 'lock', 'preuploadpresentation', 'permissions', 'schedule', 'groups',
|
|
'modstandardelshdr', 'availabilityconditionsheader', 'tagshdr', 'competenciessection',
|
|
'completionattendance', 'completionengagement', 'availabilityconditionsheader']
|
|
],
|
|
instance::TYPE_RECORDING_ONLY => [
|
|
'id' => instance::TYPE_RECORDING_ONLY,
|
|
'name' => get_string('instance_type_recording_only', 'bigbluebuttonbn'),
|
|
'features' => ['showrecordings', 'importrecordings', 'availabilityconditionsheader']
|
|
],
|
|
];
|
|
return $instanceprofiles;
|
|
}
|
|
|
|
/**
|
|
* Helper function returns an array with the profiles (with features per profile) for the different types
|
|
* of bigbluebuttonbn instances that the user is allowed to create.
|
|
*
|
|
* @param bool $room
|
|
* @param bool $recording
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function get_instance_type_profiles_create_allowed(bool $room, bool $recording): array {
|
|
$profiles = self::get_instance_type_profiles();
|
|
if (!$room) {
|
|
unset($profiles[instance::TYPE_ROOM_ONLY]);
|
|
unset($profiles[instance::TYPE_ALL]);
|
|
}
|
|
if (!$recording) {
|
|
unset($profiles[instance::TYPE_RECORDING_ONLY]);
|
|
unset($profiles[instance::TYPE_ALL]);
|
|
}
|
|
return $profiles;
|
|
}
|
|
|
|
/**
|
|
* Helper function returns an array with the profiles (with features per profile) for the different types
|
|
* of bigbluebuttonbn instances.
|
|
*
|
|
* @param array $profiles
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function get_instance_profiles_array(array $profiles = []): array {
|
|
$profilesarray = [];
|
|
foreach ($profiles as $key => $profile) {
|
|
$profilesarray[$profile['id']] = $profile['name'];
|
|
}
|
|
return $profilesarray;
|
|
}
|
|
|
|
/**
|
|
* Return the status of an activity [open|not_started|ended].
|
|
*
|
|
* @param instance $instance
|
|
* @return string
|
|
*/
|
|
public static function view_get_activity_status(instance $instance): string {
|
|
$now = time();
|
|
if (!empty($instance->get_instance_var('openingtime')) && $now < $instance->get_instance_var('openingtime')) {
|
|
// The activity has not been opened.
|
|
return 'not_started';
|
|
}
|
|
if (!empty($instance->get_instance_var('closingtime')) && $now > $instance->get_instance_var('closingtime')) {
|
|
// The activity has been closed.
|
|
return 'ended';
|
|
}
|
|
// The activity is open.
|
|
return 'open';
|
|
}
|
|
|
|
/**
|
|
* Ensure that the remote server was contactable.
|
|
*
|
|
* @param instance $instance
|
|
*/
|
|
public static function require_working_server(instance $instance): void {
|
|
$version = null;
|
|
try {
|
|
$version = self::get_server_version();
|
|
} catch (server_not_available_exception $e) {
|
|
self::handle_server_not_available($instance);
|
|
}
|
|
|
|
if (empty($version)) {
|
|
self::handle_server_not_available($instance);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handle the server not being available.
|
|
*
|
|
* @param instance $instance
|
|
*/
|
|
public static function handle_server_not_available(instance $instance): void {
|
|
\core\notification::add(
|
|
self::get_server_not_available_message($instance),
|
|
\core\notification::ERROR
|
|
);
|
|
redirect(self::get_server_not_available_url($instance));
|
|
}
|
|
|
|
/**
|
|
* Get message when server not available
|
|
*
|
|
* @param instance $instance
|
|
* @return string
|
|
*/
|
|
public static function get_server_not_available_message(instance $instance): string {
|
|
if ($instance->is_admin()) {
|
|
return get_string('view_error_unable_join', 'mod_bigbluebuttonbn');
|
|
} else if ($instance->is_moderator()) {
|
|
return get_string('view_error_unable_join_teacher', 'mod_bigbluebuttonbn');
|
|
} else {
|
|
return get_string('view_error_unable_join_student', 'mod_bigbluebuttonbn');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get URL to the page displaying that the server is not available
|
|
*
|
|
* @param instance $instance
|
|
* @return string
|
|
*/
|
|
public static function get_server_not_available_url(instance $instance): string {
|
|
if ($instance->is_admin()) {
|
|
return new moodle_url('/admin/settings.php', ['section' => 'modsettingbigbluebuttonbn']);
|
|
} else if ($instance->is_moderator()) {
|
|
return new moodle_url('/course/view.php', ['id' => $instance->get_course_id()]);
|
|
} else {
|
|
return new moodle_url('/course/view.php', ['id' => $instance->get_course_id()]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a Meeting
|
|
*
|
|
* @param array $data
|
|
* @param array $metadata
|
|
* @param string|null $presentationname
|
|
* @param string|null $presentationurl
|
|
* @param int|null $instanceid
|
|
* @return array
|
|
* @throws bigbluebutton_exception
|
|
*/
|
|
public static function create_meeting(
|
|
array $data,
|
|
array $metadata,
|
|
?string $presentationname = null,
|
|
?string $presentationurl = null,
|
|
?int $instanceid = null
|
|
): array {
|
|
$createmeetingurl = self::action_url('create', $data, $metadata, $instanceid);
|
|
|
|
$curl = new curl();
|
|
if (!is_null($presentationname) && !is_null($presentationurl)) {
|
|
$payload = "<?xml version='1.0' encoding='UTF-8'?><modules><module name='presentation'><document url='" .
|
|
$presentationurl . "' /></module></modules>";
|
|
|
|
$xml = $curl->post($createmeetingurl, $payload);
|
|
} else {
|
|
$xml = $curl->get($createmeetingurl);
|
|
}
|
|
|
|
self::assert_returned_xml($xml);
|
|
|
|
if (empty($xml->meetingID)) {
|
|
throw new bigbluebutton_exception('general_error_cannot_create_meeting');
|
|
}
|
|
|
|
if ($xml->hasBeenForciblyEnded === 'true') {
|
|
throw new bigbluebutton_exception('index_error_forciblyended');
|
|
}
|
|
|
|
return [
|
|
'meetingID' => (string) $xml->meetingID,
|
|
'internalMeetingID' => (string) $xml->internalMeetingID,
|
|
'attendeePW' => (string) $xml->attendeePW,
|
|
'moderatorPW' => (string) $xml->moderatorPW
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Get meeting info for a given meeting id
|
|
*
|
|
* @param string $meetingid
|
|
* @param int|null $instanceid
|
|
* @return array
|
|
*/
|
|
public static function get_meeting_info(string $meetingid, ?int $instanceid = null): array {
|
|
$xmlinfo = self::fetch_endpoint_xml('getMeetingInfo', ['meetingID' => $meetingid], [], $instanceid);
|
|
self::assert_returned_xml($xmlinfo, ['meetingid' => $meetingid]);
|
|
return (array) $xmlinfo;
|
|
}
|
|
|
|
/**
|
|
* Perform end meeting on BBB.
|
|
*
|
|
* @param string $meetingid
|
|
* @param string $modpw
|
|
* @param int|null $instanceid
|
|
*/
|
|
public static function end_meeting(string $meetingid, string $modpw, ?int $instanceid = null): void {
|
|
$xml = self::fetch_endpoint_xml('end', ['meetingID' => $meetingid, 'password' => $modpw], [], $instanceid);
|
|
self::assert_returned_xml($xml, ['meetingid' => $meetingid]);
|
|
}
|
|
|
|
/**
|
|
* Helper evaluates if the bigbluebutton server used belongs to blindsidenetworks domain.
|
|
*
|
|
* @return bool
|
|
*/
|
|
public static function is_bn_server() {
|
|
if (config::get('bn_server')) {
|
|
return true;
|
|
}
|
|
$parsedurl = parse_url(config::get('server_url'));
|
|
if (!isset($parsedurl['host'])) {
|
|
return false;
|
|
}
|
|
$h = $parsedurl['host'];
|
|
$hends = explode('.', $h);
|
|
$hendslength = count($hends);
|
|
return ($hends[$hendslength - 1] == 'com' && $hends[$hendslength - 2] == 'blindsidenetworks');
|
|
}
|
|
|
|
/**
|
|
* Get the poll interval as it is set in the configuration
|
|
*
|
|
* If configuration value is under the threshold of {@see self::MIN_POLL_INTERVAL},
|
|
* then return the {@see self::MIN_POLL_INTERVAL} value.
|
|
*
|
|
* @return int the poll interval in seconds
|
|
*/
|
|
public static function get_poll_interval(): int {
|
|
$pollinterval = intval(config::get('poll_interval'));
|
|
if ($pollinterval < self::MIN_POLL_INTERVAL) {
|
|
$pollinterval = self::MIN_POLL_INTERVAL;
|
|
}
|
|
return $pollinterval;
|
|
}
|
|
}
|