[moodle.git] / user / classes / output / participants_filter.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/>.

/**
 * Class for rendering user filters on the course participants page.
 *
 * @package    core_user
 * @copyright  2020 Michael Hawkins <michaelh@moodle.com>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
namespace core_user\output;

use context_course;
use renderable;
use renderer_base;
use stdClass;
use templatable;

/**
 * Class for rendering user filters on the course participants page.
 *
 * @copyright  2020 Michael Hawkins <michaelh@moodle.com>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class participants_filter implements renderable, templatable {

    /** @var context_course $context The context where the filters are being rendered. */
    protected $context;

    /** @var string $tableregionid The table to be updated by this filter */
    protected $tableregionid;

    /** @var stdClass $course The course shown */
    protected $course;

    /**
     * Participants filter constructor.
     *
     * @param context_course $context The context where the filters are being rendered.
     * @param string $tableregionid The table to be updated by this filter
     */
    public function __construct(context_course $context, string $tableregionid) {
        $this->context = $context;
        $this->tableregionid = $tableregionid;

        $this->course = get_course($context->instanceid);
    }

    /**
     * Get data for all filter types.
     *
     * @return array
     */
    protected function get_filtertypes(): array {
        $filtertypes = [];

        $filtertypes[] = $this->get_keyword_filter();

        if ($filtertype = $this->get_enrolmentstatus_filter()) {
            $filtertypes[] = $filtertype;
        }

        if ($filtertype = $this->get_roles_filter()) {
            $filtertypes[] = $filtertype;
        }

        if ($filtertype = $this->get_enrolments_filter()) {
            $filtertypes[] = $filtertype;
        }

        if ($filtertype = $this->get_groups_filter()) {
            $filtertypes[] = $filtertype;
        }

        if ($filtertype = $this->get_accesssince_filter()) {
            $filtertypes[] = $filtertype;
        }

        return $filtertypes;
    }

    /**
     * Get data for the enrolment status filter.
     *
     * @return stdClass|null
     */
    protected function get_enrolmentstatus_filter(): ?stdClass {
        if (!has_capability('moodle/course:enrolreview', $this->context)) {
            return null;
        }

        return $this->get_filter_object(
            'status',
            get_string('participationstatus', 'core_enrol'),
            false,
            true,
            null,
            [
                (object) [
                    'value' => ENROL_USER_ACTIVE,
                    'title' => get_string('active'),
                ],
                (object) [
                    'value' => ENROL_USER_SUSPENDED,
                    'title'  => get_string('inactive'),
                ],
            ]
        );
    }

    /**
     * Get data for the roles filter.
     *
     * @return stdClass|null
     */
    protected function get_roles_filter(): ?stdClass {
        $roles = [];
        $roles += [-1 => get_string('noroles', 'role')];
        $roles += get_viewable_roles($this->context);

        if (has_capability('moodle/role:assign', $this->context)) {
            $roles += get_assignable_roles($this->context, ROLENAME_ALIAS);
        }

        return $this->get_filter_object(
            'roles',
            get_string('roles', 'core_role'),
            false,
            true,
            null,
            array_map(function($id, $title) {
                return (object) [
                    'value' => $id,
                    'title' => $title,
                ];
            }, array_keys($roles), array_values($roles))
        );
    }

    /**
     * Get data for the roles filter.
     *
     * @return stdClass|null
     */
    protected function get_enrolments_filter(): ?stdClass {
        if (!has_capability('moodle/course:enrolreview', $this->context)) {
            return null;
        }

        if ($this->course->id == SITEID) {
            // No enrolment methods for the site.
            return null;
        }

        $instances = enrol_get_instances($this->course->id, true);
        $plugins = enrol_get_plugins(false);

        return $this->get_filter_object(
            'enrolments',
            get_string('enrolmentinstances', 'core_enrol'),
            false,
            true,
            null,
            array_filter(array_map(function($instance) use ($plugins): ?stdClass {
                if (!array_key_exists($instance->enrol, $plugins)) {
                    return null;
                }

                return (object) [
                    'value' => $instance->id,
                    'title' => $plugins[$instance->enrol]->get_instance_name($instance),
                ];
            }, array_values($instances)))
        );
    }

    /**
     * Get data for the groups filter.
     *
     * @return stdClass|null
     */
    protected function get_groups_filter(): ?stdClass {
        global $USER;

        // Filter options for groups, if available.
        $seeallgroups = has_capability('moodle/site:accessallgroups', $this->context);
        $seeallgroups = $seeallgroups || ($this->course->groupmode != SEPARATEGROUPS);
        if ($seeallgroups) {
            $groups = [];
            $groups += [USERSWITHOUTGROUP => (object) [
                    'id' => USERSWITHOUTGROUP,
                    'name' => get_string('nogroup', 'group'),
                ]];
            $groups += groups_get_all_groups($this->course->id);
        } else {
            // Otherwise, just list the groups the user belongs to.
            $groups = groups_get_all_groups($this->course->id, $USER->id);
        }

        // Return no data if no groups found (which includes if the only value is 'No group').
        if (empty($groups) || (count($groups) === 1 && array_key_exists(-1, $groups))) {
            return null;
        }

        return $this->get_filter_object(
            'groups',
            get_string('groups', 'core_group'),
            false,
            true,
            null,
            array_map(function($group) {
                return (object) [
                    'value' => $group->id,
                    'title' => $group->name,
                ];
            }, array_values($groups))
        );
    }

    /**
     * Get data for the accesssince filter.
     *
     * @return stdClass|null
     */
    protected function get_accesssince_filter(): ?stdClass {
        global $CFG, $DB;

        $hiddenfields = [];
        if (!has_capability('moodle/course:viewhiddenuserfields', $this->context)) {
            $hiddenfields = array_flip(explode(',', $CFG->hiddenuserfields));
        }

        if (array_key_exists('lastaccess', $hiddenfields)) {
            return null;
        }

        // Get minimum lastaccess for this course and display a dropbox to filter by lastaccess going back this far.
        // We need to make it diferently for normal courses and site course.
        if (!$this->course->id == SITEID) {
            // Regular course.
            $params = [
                'courseid' => $this->course->id,
                'timeaccess' => 0,
            ];
            $select = 'courseid = :courseid AND timeaccess != :timeaccess';
            $minlastaccess = $DB->get_field_select('user_lastaccess', 'MIN(timeaccess)', $select, $params);
            $lastaccess0exists = $DB->record_exists('user_lastaccess', $params);
        } else {
            // Front page.
            $params = ['lastaccess' => 0];
            $select = 'lastaccess != :lastaccess';
            $minlastaccess = $DB->get_field_select('user', 'MIN(lastaccess)', $select, $params);
            $lastaccess0exists = $DB->record_exists('user', $params);
        }

        $now = usergetmidnight(time());
        $timeoptions = [];
        $criteria = get_string('usersnoaccesssince');

        $getoptions = function(int $count, string $singletype, string $type) use ($now, $minlastaccess): array {
            $values = [];
            for ($i = 1; $i <= $count; $i++) {
                $timestamp = strtotime("-{$i} {$type}", $now);
                if ($timestamp < $minlastaccess) {
                    break;
                }

                if ($i === 1) {
                    $title = get_string("num{$singletype}", 'moodle', $i);
                } else {
                    $title = get_string("num{$type}", 'moodle', $i);
                }

                $values[] = [
                    'value' => $timestamp,
                    'title' => $title,
                ];
            }

            return $values;
        };

        $values = array_merge(
            $getoptions(6, 'day', 'days'),
            $getoptions(10, 'week', 'weeks'),
            $getoptions(11, 'month', 'months'),
            $getoptions(1, 'year', 'years')
        );

        if ($lastaccess0exists) {
            $values[] = [
                'value' => time(),
                'title' => get_string('never', 'moodle'),
            ];
        }

        if (count($values) <= 1) {
            // Nothing to show.
            return null;
        }

        return $this->get_filter_object(
            'accesssince',
            get_string('usersnoaccesssince'),
            false,
            false,
            null,
            $values
        );
    }

    /**
     * Get data for the keywords filter.
     *
     * @return stdClass|null
     */
    protected function get_keyword_filter(): ?stdClass {
        return $this->get_filter_object(
            'keywords',
            get_string('filterbykeyword', 'core_user'),
            true,
            true,
            'core_user/local/participantsfilter/filtertypes/keyword',
            [],
            true
        );
    }

    /**
     * Export the renderer data in a mustache template friendly format.
     *
     * @param renderer_base $output Unused.
     * @return stdClass Data in a format compatible with a mustache template.
     */
    public function export_for_template(renderer_base $output): stdClass {
        return (object) [
            'tableregionid' => $this->tableregionid,
            'courseid' => $this->context->instanceid,
            'filtertypes' => $this->get_filtertypes(),
            'rownumber' => 1,
        ];

        return $data;
    }

    /**
     * Get a standardised filter object.
     *
     * @param string $name
     * @param string $title
     * @param bool $custom
     * @param bool $multiple
     * @param string|null $filterclass
     * @param array $values
     * @param bool $allowempty
     * @return stdClass|null
     */
    protected function get_filter_object(
        string $name,
        string $title,
        bool $custom,
        bool $multiple,
        ?string $filterclass,
        array $values,
        bool $allowempty = false
    ): ?stdClass {

        if (!$allowempty && empty($values)) {
            // Do not show empty filters.
            return null;
        }

        return (object) [
            'name' => $name,
            'title' => $title,
            'allowcustom' => $custom,
            'allowmultiple' => $multiple,
            'filtertypeclass' => $filterclass,
            'values' => $values,
        ];
    }
}
Commit	Line	Data
77ba77f1 AN	1	<?php
	2	// This file is part of Moodle - http://moodle.org/
	3	//
	4	// Moodle is free software: you can redistribute it and/or modify
	5	// it under the terms of the GNU General Public License as published by
	6	// the Free Software Foundation, either version 3 of the License, or
	7	// (at your option) any later version.
	8	//
	9	// Moodle is distributed in the hope that it will be useful,
	10	// but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	// GNU General Public License for more details.
	13	//
	14	// You should have received a copy of the GNU General Public License
	15	// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
	16
	17	/**
	18	* Class for rendering user filters on the course participants page.
	19	*
	20	* @package core_user
	21	* @copyright 2020 Michael Hawkins <michaelh@moodle.com>
	22	* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
	23	*/
	24	namespace core_user\output;
	25
	26	use context_course;
	27	use renderable;
	28	use renderer_base;
	29	use stdClass;
	30	use templatable;
	31
	32	/**
	33	* Class for rendering user filters on the course participants page.
	34	*
	35	* @copyright 2020 Michael Hawkins <michaelh@moodle.com>
	36	* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
	37	*/
	38	class participants_filter implements renderable, templatable {
	39
	40	/** @var context_course $context The context where the filters are being rendered. */
	41	protected $context;
	42
	43	/** @var string $tableregionid The table to be updated by this filter */
	44	protected $tableregionid;
	45
de83d435 AN	46	/** @var stdClass $course The course shown */
	47	protected $course;
	48
77ba77f1 AN	49	/**
	50	* Participants filter constructor.
	51	*
	52	* @param context_course $context The context where the filters are being rendered.
	53	* @param string $tableregionid The table to be updated by this filter
	54	*/
	55	public function __construct(context_course $context, string $tableregionid) {
	56	$this->context = $context;
	57	$this->tableregionid = $tableregionid;
de83d435 AN	58
de83d435 AN	59	$this->course = get_course($context->instanceid);
77ba77f1 AN	60	}
	61
	62	/**
	63	* Get data for all filter types.
	64	*
	65	* @return array
	66	*/
	67	protected function get_filtertypes(): array {
	68	$filtertypes = [];
	69
028ec17c AN	70	$filtertypes[] = $this->get_keyword_filter();
028ec17c AN	71
77ba77f1 AN	72	if ($filtertype = $this->get_enrolmentstatus_filter()) {
	73	$filtertypes[] = $filtertype;
	74	}
	75
ffc933ad AN	76	if ($filtertype = $this->get_roles_filter()) {
	77	$filtertypes[] = $filtertype;
	78	}
	79
fa3d57fe AN	80	if ($filtertype = $this->get_enrolments_filter()) {
	81	$filtertypes[] = $filtertype;
	82	}
	83
de83d435 AN	84	if ($filtertype = $this->get_groups_filter()) {
	85	$filtertypes[] = $filtertype;
	86	}
	87
fbcc6577 AN	88	if ($filtertype = $this->get_accesssince_filter()) {
	89	$filtertypes[] = $filtertype;
	90	}
	91
77ba77f1 AN	92	return $filtertypes;
	93	}
	94
	95	/**
	96	* Get data for the enrolment status filter.
	97	*
	98	* @return stdClass\|null
	99	*/
	100	protected function get_enrolmentstatus_filter(): ?stdClass {
	101	if (!has_capability('moodle/course:enrolreview', $this->context)) {
	102	return null;
	103	}
	104
	105	return $this->get_filter_object(
	106	'status',
	107	get_string('participationstatus', 'core_enrol'),
	108	false,
	109	true,
	110	null,
	111	[
	112	(object) [
	113	'value' => ENROL_USER_ACTIVE,
	114	'title' => get_string('active'),
	115	],
	116	(object) [
	117	'value' => ENROL_USER_SUSPENDED,
	118	'title' => get_string('inactive'),
	119	],
	120	]
	121	);
	122	}
	123
ffc933ad AN	124	/**
	125	* Get data for the roles filter.
	126	*
	127	* @return stdClass\|null
	128	*/
	129	protected function get_roles_filter(): ?stdClass {
	130	$roles = [];
	131	$roles += [-1 => get_string('noroles', 'role')];
	132	$roles += get_viewable_roles($this->context);
	133
	134	if (has_capability('moodle/role:assign', $this->context)) {
	135	$roles += get_assignable_roles($this->context, ROLENAME_ALIAS);
	136	}
	137
	138	return $this->get_filter_object(
	139	'roles',
	140	get_string('roles', 'core_role'),
	141	false,
	142	true,
	143	null,
	144	array_map(function($id, $title) {
	145	return (object) [
	146	'value' => $id,
	147	'title' => $title,
	148	];
	149	}, array_keys($roles), array_values($roles))
	150	);
	151	}
	152
fa3d57fe AN	153	/**
	154	* Get data for the roles filter.
	155	*
	156	* @return stdClass\|null
	157	*/
	158	protected function get_enrolments_filter(): ?stdClass {
	159	if (!has_capability('moodle/course:enrolreview', $this->context)) {
	160	return null;
	161	}
	162
	163	if ($this->course->id == SITEID) {
	164	// No enrolment methods for the site.
	165	return null;
	166	}
	167
	168	$instances = enrol_get_instances($this->course->id, true);
	169	$plugins = enrol_get_plugins(false);
	170
	171	return $this->get_filter_object(
	172	'enrolments',
	173	get_string('enrolmentinstances', 'core_enrol'),
	174	false,
	175	true,
	176	null,
	177	array_filter(array_map(function($instance) use ($plugins): ?stdClass {
	178	if (!array_key_exists($instance->enrol, $plugins)) {
	179	return null;
	180	}
	181
	182	return (object) [
	183	'value' => $instance->id,
	184	'title' => $plugins[$instance->enrol]->get_instance_name($instance),
	185	];
	186	}, array_values($instances)))
	187	);
	188	}
	189
de83d435 AN	190	/**
	191	* Get data for the groups filter.
	192	*
	193	* @return stdClass\|null
	194	*/
	195	protected function get_groups_filter(): ?stdClass {
	196	global $USER;
	197
	198	// Filter options for groups, if available.
	199	$seeallgroups = has_capability('moodle/site:accessallgroups', $this->context);
	200	$seeallgroups = $seeallgroups \|\| ($this->course->groupmode != SEPARATEGROUPS);
	201	if ($seeallgroups) {
	202	$groups = [];
	203	$groups += [USERSWITHOUTGROUP => (object) [
	204	'id' => USERSWITHOUTGROUP,
	205	'name' => get_string('nogroup', 'group'),
	206	]];
	207	$groups += groups_get_all_groups($this->course->id);
	208	} else {
	209	// Otherwise, just list the groups the user belongs to.
	210	$groups = groups_get_all_groups($this->course->id, $USER->id);
	211	}
	212
d85315ee MH	213	// Return no data if no groups found (which includes if the only value is 'No group').
d85315ee MH	214	if (empty($groups) \|\| (count($groups) === 1 && array_key_exists(-1, $groups))) {
de83d435 AN	215	return null;
	216	}
	217
	218	return $this->get_filter_object(
	219	'groups',
	220	get_string('groups', 'core_group'),
	221	false,
	222	true,
	223	null,
	224	array_map(function($group) {
	225	return (object) [
	226	'value' => $group->id,
	227	'title' => $group->name,
	228	];
	229	}, array_values($groups))
	230	);
	231	}
	232
fbcc6577 AN	233	/**
	234	* Get data for the accesssince filter.
	235	*
	236	* @return stdClass\|null
	237	*/
	238	protected function get_accesssince_filter(): ?stdClass {
	239	global $CFG, $DB;
	240
	241	$hiddenfields = [];
	242	if (!has_capability('moodle/course:viewhiddenuserfields', $this->context)) {
	243	$hiddenfields = array_flip(explode(',', $CFG->hiddenuserfields));
	244	}
	245
	246	if (array_key_exists('lastaccess', $hiddenfields)) {
	247	return null;
	248	}
	249
	250	// Get minimum lastaccess for this course and display a dropbox to filter by lastaccess going back this far.
	251	// We need to make it diferently for normal courses and site course.
	252	if (!$this->course->id == SITEID) {
	253	// Regular course.
	254	$params = [
	255	'courseid' => $this->course->id,
	256	'timeaccess' => 0,
	257	];
	258	$select = 'courseid = :courseid AND timeaccess != :timeaccess';
	259	$minlastaccess = $DB->get_field_select('user_lastaccess', 'MIN(timeaccess)', $select, $params);
	260	$lastaccess0exists = $DB->record_exists('user_lastaccess', $params);
	261	} else {
	262	// Front page.
	263	$params = ['lastaccess' => 0];
	264	$select = 'lastaccess != :lastaccess';
	265	$minlastaccess = $DB->get_field_select('user', 'MIN(lastaccess)', $select, $params);
	266	$lastaccess0exists = $DB->record_exists('user', $params);
	267	}
	268
	269	$now = usergetmidnight(time());
	270	$timeoptions = [];
	271	$criteria = get_string('usersnoaccesssince');
	272
	273	$getoptions = function(int $count, string $singletype, string $type) use ($now, $minlastaccess): array {
	274	$values = [];
	275	for ($i = 1; $i <= $count; $i++) {
	276	$timestamp = strtotime("-{$i} {$type}", $now);
	277	if ($timestamp < $minlastaccess) {
	278	break;
	279	}
	280
	281	if ($i === 1) {
	282	$title = get_string("num{$singletype}", 'moodle', $i);
	283	} else {
	284	$title = get_string("num{$type}", 'moodle', $i);
	285	}
	286
	287	$values[] = [
	288	'value' => $timestamp,
	289	'title' => $title,
	290	];
	291	}
	292
	293	return $values;
	294	};
	295
	296	$values = array_merge(
297	$getoptions(6, 'day', 'days'),
298	$getoptions(10, 'week', 'weeks'),
299	$getoptions(11, 'month', 'months'),
300	$getoptions(1, 'year', 'years')
301	);
302
303	if ($lastaccess0exists) {
304	$values[] = [
305	'value' => time(),
306	'title' => get_string('never', 'moodle'),
307	];
308	}
309
310	if (count($values) <= 1) {
311	// Nothing to show.
312	return null;
313	}
314
315	return $this->get_filter_object(
316	'accesssince',
317	get_string('usersnoaccesssince'),
318	false,
319	false,
320	null,
321	$values
322	);
323	}
324
028ec17c AN	325	/**
	326	* Get data for the keywords filter.
	327	*
	328	* @return stdClass\|null
	329	*/
	330	protected function get_keyword_filter(): ?stdClass {
	331	return $this->get_filter_object(
	332	'keywords',
	333	get_string('filterbykeyword', 'core_user'),
	334	true,
	335	true,
	336	'core_user/local/participantsfilter/filtertypes/keyword',
	337	[],
	338	true
	339	);
	340	}
	341
77ba77f1 AN	342	/**
	343	* Export the renderer data in a mustache template friendly format.
	344	*
	345	* @param renderer_base $output Unused.
	346	* @return stdClass Data in a format compatible with a mustache template.
	347	*/
	348	public function export_for_template(renderer_base $output): stdClass {
	349	return (object) [
	350	'tableregionid' => $this->tableregionid,
	351	'courseid' => $this->context->instanceid,
	352	'filtertypes' => $this->get_filtertypes(),
3d60881d	353	'rownumber' => 1,
77ba77f1 AN	354	];
	355
	356	return $data;
	357	}
	358
	359	/**
	360	* Get a standardised filter object.
	361	*
	362	* @param string $name
	363	* @param string $title
	364	* @param bool $custom
	365	* @param bool $multiple
	366	* @param string\|null $filterclass
	367	* @param array $values
028ec17c	368	* @param bool $allowempty
77ba77f1 AN	369	* @return stdClass\|null
	370	*/
	371	protected function get_filter_object(
	372	string $name,
	373	string $title,
	374	bool $custom,
	375	bool $multiple,
	376	?string $filterclass,
028ec17c AN	377	array $values,
028ec17c AN	378	bool $allowempty = false
77ba77f1	379	): ?stdClass {
028ec17c AN	380
028ec17c AN	381	if (!$allowempty && empty($values)) {
77ba77f1 AN	382	// Do not show empty filters.
	383	return null;
	384	}
	385
	386	return (object) [
	387	'name' => $name,
	388	'title' => $title,
	389	'allowcustom' => $custom,
	390	'allowmultiple' => $multiple,
	391	'filtertypeclass' => $filterclass,
	392	'values' => $values,
	393	];
	394	}
	395	}