mirror of
https://github.com/moodle/moodle.git
synced 2025-08-07 09:56:38 +02:00
571 lines
20 KiB
PHP
571 lines
20 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/>.
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace core_reportbuilder\local\helpers;
|
|
|
|
use stdClass;
|
|
use invalid_parameter_exception;
|
|
use core\persistent;
|
|
use core_reportbuilder\datasource;
|
|
use core_reportbuilder\manager;
|
|
use core_reportbuilder\table\{custom_report_table_view, system_report_table};
|
|
use core_reportbuilder\local\models\{audience as audience_model, column, filter, report as report_model, schedule};
|
|
use core_tag_tag;
|
|
|
|
/**
|
|
* Helper class for manipulating custom reports and their elements (columns, filters, conditions, etc)
|
|
*
|
|
* @package core_reportbuilder
|
|
* @copyright 2021 Paul Holden <paulh@moodle.com>
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
class report {
|
|
|
|
/**
|
|
* Create custom report
|
|
*
|
|
* @param stdClass $data
|
|
* @param bool $default If $default is set to true it will populate report with default layout as defined by the selected
|
|
* source. These include pre-defined columns, filters and conditions.
|
|
* @return report_model
|
|
*/
|
|
public static function create_report(stdClass $data, bool $default = true): report_model {
|
|
$data->name = trim($data->name);
|
|
$data->type = datasource::TYPE_CUSTOM_REPORT;
|
|
|
|
// Create report persistent.
|
|
$report = manager::create_report_persistent($data);
|
|
|
|
// Add datasource default columns, filters and conditions to the report.
|
|
if ($default) {
|
|
$source = $report->get('source');
|
|
/** @var datasource $datasource */
|
|
$datasource = new $source($report);
|
|
$datasource->add_default_columns();
|
|
$datasource->add_default_filters();
|
|
$datasource->add_default_conditions();
|
|
}
|
|
|
|
// Report tags.
|
|
if (property_exists($data, "tags")) {
|
|
core_tag_tag::set_item_tags('core_reportbuilder', 'reportbuilder_report', $report->get('id'),
|
|
$report->get_context(), $data->tags);
|
|
}
|
|
|
|
return $report;
|
|
}
|
|
|
|
/**
|
|
* Update custom report
|
|
*
|
|
* @param stdClass $data
|
|
* @return report_model
|
|
*/
|
|
public static function update_report(stdClass $data): report_model {
|
|
$report = report_model::get_record(['id' => $data->id, 'type' => datasource::TYPE_CUSTOM_REPORT]);
|
|
if ($report === false) {
|
|
throw new invalid_parameter_exception('Invalid report');
|
|
}
|
|
|
|
$report->set_many([
|
|
'name' => trim($data->name),
|
|
'uniquerows' => $data->uniquerows,
|
|
])->update();
|
|
|
|
// Report tags.
|
|
if (property_exists($data, "tags")) {
|
|
core_tag_tag::set_item_tags('core_reportbuilder', 'reportbuilder_report', $report->get('id'),
|
|
$report->get_context(), $data->tags);
|
|
}
|
|
|
|
return $report;
|
|
}
|
|
|
|
|
|
/**
|
|
* Duplicate custom report
|
|
*
|
|
* @param report_model $report The report to duplicate.
|
|
* @param string $reportname
|
|
* @param bool $duplicateaudiences
|
|
* @param bool $duplicateschedules
|
|
* @return report_model The duplicated report.
|
|
*/
|
|
public static function duplicate_report(
|
|
report_model $report,
|
|
string $reportname,
|
|
bool $duplicateaudiences,
|
|
bool $duplicateschedules,
|
|
): report_model {
|
|
$reportinstance = manager::get_report_from_persistent($report);
|
|
|
|
// Copy the original report, removing properties to be re-created when duplicating.
|
|
$record = $report->to_record();
|
|
unset($record->id, $record->usercreated);
|
|
|
|
// Create new report.
|
|
$record->name = $reportname;
|
|
$record->tags = core_tag_tag::get_item_tags_array('core_reportbuilder', 'reportbuilder_report', $report->get('id'));
|
|
$newreport = static::create_report($record, false);
|
|
|
|
// Duplicate report content.
|
|
$columns = array_map(fn($column) => $column->get_persistent(), $reportinstance->get_active_columns());
|
|
static::duplicate_report_content($columns, $newreport->get('id'));
|
|
|
|
$conditions = array_map(fn($condition) => $condition->get_persistent(), $reportinstance->get_active_conditions());
|
|
static::duplicate_report_content($conditions, $newreport->get('id'));
|
|
|
|
$filters = array_map(fn($filter) => $filter->get_persistent(), $reportinstance->get_active_filters());
|
|
static::duplicate_report_content($filters, $newreport->get('id'));
|
|
|
|
// Duplicate audiences.
|
|
if ($duplicateaudiences) {
|
|
$audiencemap = [];
|
|
|
|
foreach (audience::get_base_records($report->get('id')) as $audienceinstance) {
|
|
|
|
// If user can't edit the current audience then do not copy it.
|
|
if (!$audienceinstance->user_can_edit()) {
|
|
continue;
|
|
}
|
|
|
|
$audiencerecord = $audienceinstance->get_persistent()->to_record();
|
|
$audiencerecordid = $audiencerecord->id;
|
|
unset($audiencerecord->id, $audiencerecord->usercreated);
|
|
|
|
$newaudience = (new audience_model(0, $audiencerecord))
|
|
->set('reportid', $newreport->get('id'))
|
|
->create();
|
|
|
|
$audiencemap[$audiencerecordid] = $newaudience->get('id');
|
|
}
|
|
|
|
// Duplicate schedules and map them to the new audience ids.
|
|
if ($duplicateschedules) {
|
|
foreach (schedule::get_records(['reportid' => $report->get('id')]) as $schedule) {
|
|
$schedulerecord = $schedule->to_record();
|
|
unset($schedulerecord->id, $schedulerecord->usercreated);
|
|
|
|
// Map new audience ids with the old ones.
|
|
$audiences = array_map(
|
|
fn($audienceid) => $audiencemap[$audienceid] ?? 0,
|
|
(array) json_decode($schedulerecord->audiences),
|
|
);
|
|
|
|
(new schedule(0, $schedulerecord))
|
|
->set_many([
|
|
'reportid' => $newreport->get('id'),
|
|
'audiences' => json_encode($audiences),
|
|
])
|
|
->create();
|
|
}
|
|
}
|
|
}
|
|
|
|
return $newreport;
|
|
}
|
|
|
|
/**
|
|
* Delete custom report
|
|
*
|
|
* @param int $reportid
|
|
* @return bool
|
|
* @throws invalid_parameter_exception
|
|
*/
|
|
public static function delete_report(int $reportid): bool {
|
|
$report = report_model::get_record(['id' => $reportid, 'type' => datasource::TYPE_CUSTOM_REPORT]);
|
|
if ($report === false) {
|
|
throw new invalid_parameter_exception('Invalid report');
|
|
}
|
|
|
|
// Report tags.
|
|
core_tag_tag::remove_all_item_tags('core_reportbuilder', 'reportbuilder_report', $report->get('id'));
|
|
|
|
return $report->delete();
|
|
}
|
|
|
|
/**
|
|
* Add given column to report
|
|
*
|
|
* @param int $reportid
|
|
* @param string $uniqueidentifier
|
|
* @return column
|
|
* @throws invalid_parameter_exception
|
|
*/
|
|
public static function add_report_column(int $reportid, string $uniqueidentifier): column {
|
|
$report = manager::get_report_from_id($reportid);
|
|
|
|
// Ensure column is available.
|
|
if (!array_key_exists($uniqueidentifier, $report->get_columns())) {
|
|
throw new invalid_parameter_exception('Invalid column');
|
|
}
|
|
|
|
$column = new column(0, (object) [
|
|
'reportid' => $reportid,
|
|
'uniqueidentifier' => $uniqueidentifier,
|
|
'columnorder' => column::get_max_columnorder($reportid, 'columnorder') + 1,
|
|
'sortorder' => column::get_max_columnorder($reportid, 'sortorder') + 1,
|
|
]);
|
|
|
|
return $column->create();
|
|
}
|
|
|
|
/**
|
|
* Delete given column from report
|
|
*
|
|
* @param int $reportid
|
|
* @param int $columnid
|
|
* @return bool
|
|
* @throws invalid_parameter_exception
|
|
*/
|
|
public static function delete_report_column(int $reportid, int $columnid): bool {
|
|
global $DB;
|
|
|
|
$column = column::get_record(['id' => $columnid, 'reportid' => $reportid]);
|
|
if ($column === false) {
|
|
throw new invalid_parameter_exception('Invalid column');
|
|
}
|
|
|
|
// After deletion, re-index remaining report columns.
|
|
if ($result = $column->delete()) {
|
|
$sqlupdateorder = '
|
|
UPDATE {' . column::TABLE . '}
|
|
SET columnorder = columnorder - 1
|
|
WHERE reportid = :reportid
|
|
AND columnorder > :columnorder';
|
|
|
|
$DB->execute($sqlupdateorder, ['reportid' => $reportid, 'columnorder' => $column->get('columnorder')]);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Re-order given column within a report
|
|
*
|
|
* @param int $reportid
|
|
* @param int $columnid
|
|
* @param int $position
|
|
* @return bool
|
|
* @throws invalid_parameter_exception
|
|
*/
|
|
public static function reorder_report_column(int $reportid, int $columnid, int $position): bool {
|
|
$column = column::get_record(['id' => $columnid, 'reportid' => $reportid]);
|
|
if ($column === false) {
|
|
throw new invalid_parameter_exception('Invalid column');
|
|
}
|
|
|
|
// Get the rest of the report columns, excluding the one we are moving.
|
|
$columns = column::get_records_select('reportid = :reportid AND id <> :id', [
|
|
'reportid' => $reportid,
|
|
'id' => $columnid,
|
|
], 'columnorder');
|
|
|
|
return static::reorder_persistents_by_field($column, $columns, $position, 'columnorder');
|
|
}
|
|
|
|
/**
|
|
* Re-order given column sorting within a report
|
|
*
|
|
* @param int $reportid
|
|
* @param int $columnid
|
|
* @param int $position
|
|
* @return bool
|
|
* @throws invalid_parameter_exception
|
|
*/
|
|
public static function reorder_report_column_sorting(int $reportid, int $columnid, int $position): bool {
|
|
$column = column::get_record(['id' => $columnid, 'reportid' => $reportid]);
|
|
if ($column === false) {
|
|
throw new invalid_parameter_exception('Invalid column');
|
|
}
|
|
|
|
// Get the rest of the report columns, excluding the one we are moving.
|
|
$columns = column::get_records_select('reportid = :reportid AND id <> :id', [
|
|
'reportid' => $reportid,
|
|
'id' => $columnid,
|
|
], 'sortorder');
|
|
|
|
return static::reorder_persistents_by_field($column, $columns, $position, 'sortorder');
|
|
}
|
|
|
|
/**
|
|
* Toggle sorting options for given column within a report
|
|
*
|
|
* @param int $reportid
|
|
* @param int $columnid
|
|
* @param bool $enabled
|
|
* @param int $direction
|
|
* @return bool
|
|
* @throws invalid_parameter_exception
|
|
*/
|
|
public static function toggle_report_column_sorting(int $reportid, int $columnid, bool $enabled,
|
|
int $direction = SORT_ASC): bool {
|
|
|
|
$column = column::get_record(['id' => $columnid, 'reportid' => $reportid]);
|
|
if ($column === false) {
|
|
throw new invalid_parameter_exception('Invalid column');
|
|
}
|
|
|
|
return $column->set_many([
|
|
'sortenabled' => $enabled,
|
|
'sortdirection' => $direction,
|
|
])->update();
|
|
}
|
|
|
|
/**
|
|
* Add given condition to report
|
|
*
|
|
* @param int $reportid
|
|
* @param string $uniqueidentifier
|
|
* @return filter
|
|
* @throws invalid_parameter_exception
|
|
*/
|
|
public static function add_report_condition(int $reportid, string $uniqueidentifier): filter {
|
|
$report = manager::get_report_from_id($reportid);
|
|
|
|
// Ensure condition is available.
|
|
if (!array_key_exists($uniqueidentifier, $report->get_conditions())) {
|
|
throw new invalid_parameter_exception('Invalid condition');
|
|
}
|
|
|
|
// Ensure condition wasn't already added.
|
|
if (array_key_exists($uniqueidentifier, $report->get_active_conditions())) {
|
|
throw new invalid_parameter_exception('Duplicate condition');
|
|
}
|
|
|
|
$condition = new filter(0, (object) [
|
|
'reportid' => $reportid,
|
|
'uniqueidentifier' => $uniqueidentifier,
|
|
'iscondition' => true,
|
|
'filterorder' => filter::get_max_filterorder($reportid, true) + 1,
|
|
]);
|
|
|
|
return $condition->create();
|
|
}
|
|
|
|
/**
|
|
* Delete given condition from report
|
|
*
|
|
* @param int $reportid
|
|
* @param int $conditionid
|
|
* @return bool
|
|
* @throws invalid_parameter_exception
|
|
*/
|
|
public static function delete_report_condition(int $reportid, int $conditionid): bool {
|
|
global $DB;
|
|
|
|
$condition = filter::get_condition_record($reportid, $conditionid);
|
|
if ($condition === false) {
|
|
throw new invalid_parameter_exception('Invalid condition');
|
|
}
|
|
|
|
// After deletion, re-index remaining report conditions.
|
|
if ($result = $condition->delete()) {
|
|
$sqlupdateorder = '
|
|
UPDATE {' . filter::TABLE . '}
|
|
SET filterorder = filterorder - 1
|
|
WHERE reportid = :reportid
|
|
AND filterorder > :filterorder
|
|
AND iscondition = 1';
|
|
|
|
$DB->execute($sqlupdateorder, ['reportid' => $reportid, 'filterorder' => $condition->get('filterorder')]);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Re-order given condition within a report
|
|
*
|
|
* @param int $reportid
|
|
* @param int $conditionid
|
|
* @param int $position
|
|
* @return bool
|
|
* @throws invalid_parameter_exception
|
|
*/
|
|
public static function reorder_report_condition(int $reportid, int $conditionid, int $position): bool {
|
|
$condition = filter::get_condition_record($reportid, $conditionid);
|
|
if ($condition === false) {
|
|
throw new invalid_parameter_exception('Invalid condition');
|
|
}
|
|
|
|
// Get the rest of the report conditions, excluding the one we are moving.
|
|
$conditions = filter::get_records_select('reportid = :reportid AND iscondition = 1 AND id <> :id', [
|
|
'reportid' => $reportid,
|
|
'id' => $conditionid,
|
|
], 'filterorder');
|
|
|
|
return static::reorder_persistents_by_field($condition, $conditions, $position, 'filterorder');
|
|
}
|
|
|
|
/**
|
|
* Add given filter to report
|
|
*
|
|
* @param int $reportid
|
|
* @param string $uniqueidentifier
|
|
* @return filter
|
|
* @throws invalid_parameter_exception
|
|
*/
|
|
public static function add_report_filter(int $reportid, string $uniqueidentifier): filter {
|
|
$report = manager::get_report_from_id($reportid);
|
|
|
|
// Ensure filter is available.
|
|
if (!array_key_exists($uniqueidentifier, $report->get_filters())) {
|
|
throw new invalid_parameter_exception('Invalid filter');
|
|
}
|
|
|
|
// Ensure filter wasn't already added.
|
|
if (array_key_exists($uniqueidentifier, $report->get_active_filters())) {
|
|
throw new invalid_parameter_exception('Duplicate filter');
|
|
}
|
|
|
|
$filter = new filter(0, (object) [
|
|
'reportid' => $reportid,
|
|
'uniqueidentifier' => $uniqueidentifier,
|
|
'filterorder' => filter::get_max_filterorder($reportid) + 1,
|
|
]);
|
|
|
|
return $filter->create();
|
|
}
|
|
|
|
/**
|
|
* Delete given filter from report
|
|
*
|
|
* @param int $reportid
|
|
* @param int $filterid
|
|
* @return bool
|
|
* @throws invalid_parameter_exception
|
|
*/
|
|
public static function delete_report_filter(int $reportid, int $filterid): bool {
|
|
global $DB;
|
|
|
|
$filter = filter::get_filter_record($reportid, $filterid);
|
|
if ($filter === false) {
|
|
throw new invalid_parameter_exception('Invalid filter');
|
|
}
|
|
|
|
// After deletion, re-index remaining report filters.
|
|
if ($result = $filter->delete()) {
|
|
$sqlupdateorder = '
|
|
UPDATE {' . filter::TABLE . '}
|
|
SET filterorder = filterorder - 1
|
|
WHERE reportid = :reportid
|
|
AND filterorder > :filterorder
|
|
AND iscondition = 0';
|
|
|
|
$DB->execute($sqlupdateorder, ['reportid' => $reportid, 'filterorder' => $filter->get('filterorder')]);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Re-order given filter within a report
|
|
*
|
|
* @param int $reportid
|
|
* @param int $filterid
|
|
* @param int $position
|
|
* @return bool
|
|
* @throws invalid_parameter_exception
|
|
*/
|
|
public static function reorder_report_filter(int $reportid, int $filterid, int $position): bool {
|
|
$filter = filter::get_filter_record($reportid, $filterid);
|
|
if ($filter === false) {
|
|
throw new invalid_parameter_exception('Invalid filter');
|
|
}
|
|
|
|
// Get the rest of the report filters, excluding the one we are moving.
|
|
$filters = filter::get_records_select('reportid = :reportid AND iscondition = 0 AND id <> :id', [
|
|
'reportid' => $reportid,
|
|
'id' => $filterid,
|
|
], 'filterorder');
|
|
|
|
return static::reorder_persistents_by_field($filter, $filters, $position, 'filterorder');
|
|
}
|
|
|
|
/**
|
|
* Get total row count for given custom or system report
|
|
*
|
|
* @param int $reportid
|
|
* @param array $parameters Applicable for system reports only
|
|
* @return int
|
|
*/
|
|
public static function get_report_row_count(int $reportid, array $parameters = []): int {
|
|
$report = new report_model($reportid);
|
|
if ($report->get('type') === datasource::TYPE_CUSTOM_REPORT) {
|
|
$table = custom_report_table_view::create($report->get('id'));
|
|
} else {
|
|
$table = system_report_table::create($report->get('id'), $parameters);
|
|
$table->guess_base_url();
|
|
}
|
|
$table->setup();
|
|
return $table->get_total_row_count();
|
|
}
|
|
|
|
/**
|
|
* @deprecated since Moodle 4.1 - please do not use this function any more, {@see custom_report_column_cards_exporter}
|
|
*/
|
|
#[\core\attribute\deprecated('custom_report_column_cards_exporter', since: '4.1', final: true)]
|
|
public static function get_available_columns() {
|
|
\core\deprecation::emit_deprecation_if_present([self::class, __FUNCTION__]);
|
|
}
|
|
|
|
/**
|
|
* Duplicate report content to given report ID
|
|
*
|
|
* @param persistent[] $persistents
|
|
* @param int $reportid
|
|
*/
|
|
private static function duplicate_report_content(array $persistents, int $reportid): void {
|
|
foreach ($persistents as $persistent) {
|
|
$record = $persistent->to_record();
|
|
unset($record->id, $record->usercreated);
|
|
|
|
/** @var persistent $persistentclass */
|
|
$persistentclass = get_class($persistent);
|
|
|
|
(new $persistentclass(0, $record))
|
|
->set('reportid', $reportid)
|
|
->create();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper method for re-ordering given persistents (columns, filters, etc)
|
|
*
|
|
* @param persistent $persistent The persistent we are moving
|
|
* @param persistent[] $persistents The rest of the persistents
|
|
* @param int $position
|
|
* @param string $field The field we need to update
|
|
* @return bool
|
|
*/
|
|
private static function reorder_persistents_by_field(persistent $persistent, array $persistents, int $position,
|
|
string $field): bool {
|
|
|
|
// Splice into new position.
|
|
array_splice($persistents, $position - 1, 0, [$persistent]);
|
|
|
|
$fieldorder = 1;
|
|
foreach ($persistents as $persistent) {
|
|
$persistent->set($field, $fieldorder++)
|
|
->update();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|