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

/**
 * Group widget external functions contains the add memebrs, get non group members list.
 *
 * @package    block_dash
 * @copyright  2022 bdecent gmbh <https://bdecent.de>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

namespace block_dash\local\widget\groups;

defined('MOODLE_INTERNAL') || die('No direct access');

require_once($CFG->libdir . '/externallib.php');
use external_api;

require_once($CFG->dirroot . '/user/selector/lib.php');
require_once($CFG->dirroot . '/group/lib.php');

/**
 * Group widget external function definitions.
 */
class external extends external_api {

    /**
     * Get the users details if not assigned to the group.
     *
     * @return \external_function_parameters
     */
    public static function get_non_members_parameters() {

        return new \external_function_parameters([
            'query' => new \external_value(PARAM_RAW,
                'Query string (full or partial user full name or other details)'),
            'groupid' => new \external_value(PARAM_INT, 'group id (0 if none)'),
        ]);
    }

    /**
     * Returns result type for get_relevant_users function.
     *
     * @return \external_description Result type
     */
    public static function get_non_members_returns() {
        return new \external_multiple_structure(
                new \external_single_structure([
                    'id' => new \external_value(PARAM_INT, 'User id'),
                    'fullname' => new \external_value(PARAM_RAW, 'Full name as text'),
                ]));
    }

    /**
     * Searches for users given a query, taking into account the current user's permissions and
     * possibly a course to check within.
     *
     * @param string $query Query text
     * @param int $groupid Course id or 0 if no restriction
     * @return array Defined return structure
     */
    public static function get_non_members($query, $groupid) {
        global $CFG, $PAGE;

        // Validate parameter.
        [
            'query' => $query,
            'groupid' => $groupid,
        ] = self::validate_parameters(self::get_non_members_parameters(), [
            'query' => $query,
            'groupid' => $groupid,
        ]);

        // Validate the context (search page is always system context).
        $systemcontext = \context_system::instance();
        self::validate_context($systemcontext);
        $group = groups_get_group($groupid);
        $courseid = $group->courseid;
        if ($group) {
            $potentialmembersselector = new \group_non_members_selector('addselect', [
                'groupid' => $groupid, 'courseid' => $courseid,
            ]);
            $users = $potentialmembersselector->find_users($query);
            $list = [];
            foreach ($users as $role => $user) {
                $list = array_merge($list, $user);
            }
            array_walk($list, function(&$user) use ($potentialmembersselector) {
                $user = ['id' => $user->id, 'fullname' => fullname($user)];
            });

            return $list;
        }
        return ['id' => '0', 'fullname' => 'No source'];
    }

    /**
     * Add members.
     *
     * @return void
     */
    public static function add_members_parameters() {

        return new \external_function_parameters(
            [
                'formdata' => new \external_value(PARAM_RAW, 'The data from the user notes'),
            ]
        );
    }
    /**
     * Retuns the redirect course url and created pulse id for save method.
     *
     * @return void
     */
    public static function add_members_returns() {
        return new \external_value(PARAM_BOOL, 'Result of members added.');
    }

    /**
     * Add memebers to the selected group.
     *
     * @param \stdclass $formdata
     * @return bool
     */
    public static function add_members($formdata) {
        // Validate parameter.
        [
            'formdata' => $formdata,
        ] = self::validate_parameters(self::add_members_parameters(), [
            'formdata' => $formdata,
        ]);
        parse_str($formdata, $data);
        $groupid = $data['groupid'];
        $users = $data['users'];
        if (!empty($users) && is_array($users)) {
            foreach ($users as $user) {
                groups_add_member($groupid, $user);
            }
            return true;
        }
        return false;
    }

    /**
     * Prameters definition that helps to leave from the own group.
     *
     * @return \external_function_parameters
     */
    public static function leave_group_parameters() {
        return new \external_function_parameters([
            'groupid' => new \external_value(PARAM_INT, 'group id (0 if none)'),
        ]);
    }

    /**
     * Return data of leave group service.
     *
     * @return \external_value
     */
    public static function leave_group_returns() {
        return new \external_value(PARAM_BOOL, 'Result of members added.');
    }

    /**
     * Remove the user from the own group.
     *
     * @param int $groupid
     * @return void
     */
    public static function leave_group($groupid) {
        global $USER;

        ['groupid' => $groupid] = self::validate_parameters(self::leave_group_parameters(), [
            'groupid' => $groupid,
        ]);

        if ($groupid && isloggedin()) {
            return groups_remove_member($groupid, $USER->id);
        }

        return false;
    }

    /**
     * Prameters definition that helps to create groups in the selected course.
     *
     * @return \external_function_parameters
     */
    public static function create_group_parameters() {
        return new \external_function_parameters([
            'formdata' => new \external_value(PARAM_RAW, 'The data from the user notes'),
        ]);
    }

    /**
     * Returns the status of group creation in course.
     *
     * @return void
     */
    public static function create_group_returns() {
        return new \external_value(PARAM_BOOL, 'Result of members added.');
    }

    /**
     * Create the group in the selected course.
     *
     * @param stdclass $formdata
     * @return void
     */
    public static function create_group($formdata) {
        global $USER;

        [
            'formdata' => $formdata,
        ] = self::validate_parameters(self::add_members_parameters(), [
            'formdata' => $formdata,
        ]);

        // TODO: TEST Require capability.
        if ($formdata) {
            parse_str($formdata, $data);
            $data = (object) $data;
            if ($groupid = groups_create_group($data)) {
                groups_add_member($groupid, $USER->id);
                return true;
            }
        }
        return false;
    }
}