mirror of
https://github.com/moodle/moodle.git
synced 2025-08-04 16:36:37 +02:00
4399e4759a
This feature adds an admin tool for creating custom licenses. Now custom licenses can be added and amended in Moodle, and the site default can be set to a custom license. Core licenses remain hard-coded and are uneditable, so they will always require update within Moodle core updates, and maintain their internationalisation through core language strings. This also includes fundamental changes to the license API including the addition of license caching and deprecation of no longer required admin settings for license management.
401 lines
12 KiB
PHP
401 lines
12 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/>.
|
|
|
|
|
|
/**
|
|
* A namespace contains license specific functions
|
|
*
|
|
* @since Moodle 2.0
|
|
* @package core
|
|
* @subpackage lib
|
|
* @copyright 2010 Dongsheng Cai <dongsheng@moodle.com>
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
class license_manager {
|
|
|
|
/**
|
|
* License is a core license and can not be updated or deleted.
|
|
*/
|
|
const CORE_LICENSE = 0;
|
|
|
|
/**
|
|
* License is a custom license and can be updated and/or deleted.
|
|
*/
|
|
const CUSTOM_LICENSE = 1;
|
|
|
|
/**
|
|
* Integer representation of boolean for a license that is enabled.
|
|
*/
|
|
const LICENSE_ENABLED = 1;
|
|
|
|
/**
|
|
* Integer representation of boolean for a license that is disabled.
|
|
*/
|
|
const LICENSE_DISABLED = 0;
|
|
|
|
/**
|
|
* Integer for moving a license up order.
|
|
*/
|
|
const LICENSE_MOVE_UP = -1;
|
|
|
|
/**
|
|
* Integer for moving a license down order.
|
|
*/
|
|
const LICENSE_MOVE_DOWN = 1;
|
|
|
|
/**
|
|
* Save a license record.
|
|
*
|
|
* @param object $license {
|
|
* shortname => string a shortname of license, will be refered by files table[required]
|
|
* fullname => string the fullname of the license [required]
|
|
* source => string the homepage of the license type[required]
|
|
* enabled => int is it enabled?
|
|
* version => int a version number used by moodle [required]
|
|
* }
|
|
*/
|
|
static public function save($license) {
|
|
|
|
$existinglicense = self::get_license_by_shortname($license->shortname);
|
|
|
|
if (!empty($existinglicense)) {
|
|
$id = $existinglicense->id;
|
|
if ($existinglicense->custom == self::CORE_LICENSE) {
|
|
// Can only update the enabled status and sortorder for core licenses.
|
|
$existinglicense->enabled = $license->enabled;
|
|
$existinglicense->sortorder = $license->sortorder;
|
|
$license = $existinglicense;
|
|
}
|
|
$license->id = $id;
|
|
self::update($license);
|
|
} else {
|
|
self::create($license);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Adding a new license type
|
|
*
|
|
* @deprecated Since Moodle 3.9, MDL-45184.
|
|
* @todo MDL-67344 This will be deleted in Moodle 4.3.
|
|
* @see license_manager::save()
|
|
*
|
|
* @param object $license the license record to add.
|
|
*
|
|
* @return bool true on success.
|
|
*/
|
|
public function add($license) : bool {
|
|
debugging('add() is deprecated. Please use license_manager::save() instead.', DEBUG_DEVELOPER);
|
|
|
|
return self::save($license);
|
|
}
|
|
|
|
/**
|
|
* Create a license record.
|
|
*
|
|
* @param object $license the license to create record for.
|
|
*/
|
|
static protected function create($license) {
|
|
global $DB;
|
|
|
|
$licensecount = count(self::get_licenses());
|
|
$license->sortorder = $licensecount + 1;
|
|
// Enable all created license by default.
|
|
$license->enabled = self::LICENSE_ENABLED;
|
|
// API can only create custom licenses, core licenses
|
|
// are directly created at install or upgrade.
|
|
$license->custom = self::CUSTOM_LICENSE;
|
|
|
|
$DB->insert_record('license', $license);
|
|
self::reset_license_cache();
|
|
}
|
|
|
|
/**
|
|
* Read licens record(s) from database.
|
|
*
|
|
* @param array $params license parameters to return licenses for.
|
|
*
|
|
* @return array $filteredlicenses object[] of licenses.
|
|
*/
|
|
static public function read(array $params = []) {
|
|
$licenses = self::get_licenses();
|
|
|
|
$filteredlicenses = [];
|
|
|
|
foreach ($licenses as $shortname => $license) {
|
|
$filtermatch = true;
|
|
foreach ($params as $key => $value) {
|
|
if ($license->$key != $value) {
|
|
$filtermatch = false;
|
|
}
|
|
}
|
|
if ($filtermatch) {
|
|
$filteredlicenses[$shortname] = $license;
|
|
}
|
|
}
|
|
return $filteredlicenses;
|
|
|
|
}
|
|
|
|
/**
|
|
* Update a license record.
|
|
*
|
|
* @param object $license the license to update record for.
|
|
*
|
|
* @throws \moodle_exception if attempting to update a core license.
|
|
*/
|
|
static protected function update($license) {
|
|
global $DB;
|
|
|
|
$DB->update_record('license', $license);
|
|
self::reset_license_cache();
|
|
}
|
|
|
|
/**
|
|
* Delete a custom license.
|
|
*
|
|
* @param string $licenseshortname the shortname of license.
|
|
*
|
|
* @throws \moodle_exception when attempting to delete a license you are not allowed to.
|
|
*/
|
|
static public function delete($licenseshortname) {
|
|
global $DB;
|
|
|
|
$licensetodelete = self::get_license_by_shortname($licenseshortname);
|
|
|
|
if (!empty($licensetodelete)) {
|
|
if ($licensetodelete->custom == self::CUSTOM_LICENSE) {
|
|
// Check that the license is not in use by any files, if so it cannot be deleted.
|
|
$countfilesusinglicense = $DB->count_records('files', ['license' => $licenseshortname]);
|
|
if ($countfilesusinglicense > 0) {
|
|
throw new moodle_exception('cannotdeletelicenseinuse', 'license');
|
|
}
|
|
$deletedsortorder = $licensetodelete->sortorder;
|
|
$DB->delete_records('license', ['id' => $licensetodelete->id]);
|
|
|
|
// We've deleted a license, so update our list of licenses so we don't save the deleted license again.
|
|
self::reset_license_cache();
|
|
$licenses = self::get_licenses();
|
|
|
|
foreach ($licenses as $license) {
|
|
if ($license->sortorder > $deletedsortorder) {
|
|
$license->sortorder = $license->sortorder - 1;
|
|
self::save($license);
|
|
}
|
|
}
|
|
|
|
} else {
|
|
throw new moodle_exception('cannotdeletecore', 'license');
|
|
}
|
|
} else {
|
|
throw new moodle_exception('licensenotfoundshortname', 'license', $licenseshortname);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get license records.
|
|
*
|
|
* @return array|false object[] of license records of false if none.
|
|
*/
|
|
static public function get_licenses() {
|
|
global $DB;
|
|
|
|
$cache = \cache::make('core', 'license');
|
|
$licenses = $cache->get('licenses');
|
|
|
|
if (empty($licenses)) {
|
|
$licenses = [];
|
|
$records = $DB->get_records_select('license', null, null, 'sortorder ASC');
|
|
foreach ($records as $license) {
|
|
// Interpret core license strings for internationalisation.
|
|
if ($license->custom == self::CORE_LICENSE) {
|
|
$license->fullname = get_string($license->shortname, 'license');
|
|
}
|
|
$licenses[$license->shortname] = $license;
|
|
}
|
|
$cache->set('licenses', $licenses);
|
|
}
|
|
|
|
return $licenses;
|
|
}
|
|
|
|
/**
|
|
* Change the sort order of a license (and it's sibling license as a result).
|
|
*
|
|
* @param int $direction value to change sortorder of license by.
|
|
* @param string $licenseshortname the shortname of license to changes sortorder for.
|
|
*
|
|
* @throws \moodle_exception if attempting to use invalid direction value.
|
|
*/
|
|
static public function change_license_sortorder(int $direction, string $licenseshortname) : void {
|
|
|
|
if ($direction != self::LICENSE_MOVE_UP && $direction != self::LICENSE_MOVE_DOWN) {
|
|
throw new coding_exception(
|
|
'Must use a valid licence API move direction constant (LICENSE_MOVE_UP or LICENSE_MOVE_DOWN)');
|
|
}
|
|
|
|
$licenses = self::get_licenses();
|
|
$licensetoupdate = $licenses[$licenseshortname];
|
|
|
|
$currentsortorder = $licensetoupdate->sortorder;
|
|
$targetsortorder = $currentsortorder + $direction;
|
|
|
|
if ($targetsortorder > 0 && $targetsortorder <= count($licenses) ) {
|
|
foreach ($licenses as $license) {
|
|
if ($license->sortorder == $targetsortorder) {
|
|
$license->sortorder = $license->sortorder - $direction;
|
|
self::update($license);
|
|
}
|
|
}
|
|
$licensetoupdate->sortorder = $targetsortorder;
|
|
self::update($licensetoupdate);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get license record by shortname
|
|
*
|
|
* @param string $name the shortname of license
|
|
* @return object|null the license or null if no license found.
|
|
*/
|
|
static public function get_license_by_shortname(string $name) {
|
|
$licenses = self::read(['shortname' => $name]);
|
|
|
|
if (!empty($licenses)) {
|
|
$license = reset($licenses);
|
|
} else {
|
|
$license = null;
|
|
}
|
|
|
|
return $license;
|
|
}
|
|
|
|
/**
|
|
* Enable a license
|
|
* @param string $license the shortname of license
|
|
* @return boolean
|
|
*/
|
|
static public function enable($license) {
|
|
if ($license = self::get_license_by_shortname($license)) {
|
|
$license->enabled = self::LICENSE_ENABLED;
|
|
self::update($license);
|
|
}
|
|
self::set_active_licenses();
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Disable a license
|
|
* @param string $license the shortname of license
|
|
* @return boolean
|
|
*/
|
|
static public function disable($license) {
|
|
global $CFG;
|
|
// Site default license cannot be disabled!
|
|
if ($license == $CFG->sitedefaultlicense) {
|
|
print_error('error');
|
|
}
|
|
if ($license = self::get_license_by_shortname($license)) {
|
|
$license->enabled = self::LICENSE_DISABLED;
|
|
self::update($license);
|
|
}
|
|
self::set_active_licenses();
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Store active licenses in global config.
|
|
*/
|
|
static protected function set_active_licenses() {
|
|
$licenses = self::read(['enabled' => self::LICENSE_ENABLED]);
|
|
$result = array();
|
|
foreach ($licenses as $l) {
|
|
$result[] = $l->shortname;
|
|
}
|
|
set_config('licenses', implode(',', $result));
|
|
}
|
|
|
|
/**
|
|
* Get the globally configured active licenses.
|
|
*
|
|
* @return array of license objects.
|
|
* @throws \coding_exception
|
|
*/
|
|
static public function get_active_licenses() {
|
|
global $CFG;
|
|
|
|
$result = [];
|
|
|
|
if (!empty($CFG->licenses)) {
|
|
$activelicenses = explode(',', $CFG->licenses);
|
|
$licenses = self::get_licenses();
|
|
foreach ($licenses as $license) {
|
|
if (in_array($license->shortname, $activelicenses)) {
|
|
// Interpret core license strings for internationalisation.
|
|
if (isset($license->custom) && $license->custom == self::CORE_LICENSE) {
|
|
$license->fullname = get_string($license->shortname, 'license');
|
|
}
|
|
$result[$license->shortname] = $license;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Get the globally configured active licenses as an array.
|
|
*
|
|
* @return array $licenses an associative array of licenses shaped as ['shortname' => 'fullname']
|
|
*/
|
|
static public function get_active_licenses_as_array() {
|
|
$activelicenses = self::get_active_licenses();
|
|
|
|
$licenses = [];
|
|
foreach ($activelicenses as $license) {
|
|
$licenses[$license->shortname] = $license->fullname;
|
|
}
|
|
|
|
return $licenses;
|
|
}
|
|
|
|
/**
|
|
* Install moodle built-in licenses.
|
|
*/
|
|
static public function install_licenses() {
|
|
global $CFG;
|
|
|
|
require_once($CFG->libdir . '/db/upgradelib.php');
|
|
|
|
upgrade_core_licenses();
|
|
}
|
|
|
|
/**
|
|
* Reset the license cache so it rebuilds next time licenses are fetched.
|
|
*/
|
|
static public function reset_license_cache() {
|
|
$cache = \cache::make('core', 'license');
|
|
$cache->delete('licenses');
|
|
}
|
|
}
|