moodle_local_treestudyplan/classes/cascadecohortsync.php

<?php
// This file is part of the Studyplan plugin for Moodle
//
// 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 <https://www.gnu.org/licenses/>.
/**
 *
 * @package    local_treestudyplan
 * @copyright  2023 P.M. Kuipers
 * @license    https://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

namespace local_treestudyplan;
defined('MOODLE_INTERNAL') || die();

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

use \local_treestudyplan\studyplan;

class cascadecohortsync {
    private const METHOD = "cohort";
    private $studyplan;
    private $studyplanid;

    public function __construct(studyplan $studyplan) {
        $this->studyplan = $studyplan;
        $this->studyplanid = $studyplan->id();
    }

    private static function array_remove_value($array, $value) {
        $a = [];
        foreach ($array as $v) {
            if ($v != $value) {
                $a[] = $v;
            }
        }
        return $a;
    }

    private static function uploadenrolmentmethods_get_group($courseid, $groupname) {
        // Function shamelessly copied from tool/uploadenrolmentmethods/locallib.php.
        global $DB, $CFG;

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

        // Check to see if the group name already exists in this course.
        if ($DB->record_exists('groups', array('name' => $groupname, 'courseid' => $courseid))) {
            $group = $DB->get_record('groups', array('name' => $groupname, 'courseid' => $courseid));
            return $group->id;
        }
        // The named group doesn't exist, so create a new one in the course.
        $groupdata = new \stdClass();
        $groupdata->courseid = $courseid;
        $groupdata->name = $groupname;
        $groupid = groups_create_group($groupdata);

        return $groupid;
    }

    public function sync() {
        global $DB;

        /*  Explainer:
            This script uses {enrol}.customtext4 to store a json array of all studyplans that need this cohort sync to exist.
            Since the cohort-sync enrolment method uses only customint1 and customint2, this is a safe place to store the data.
            (Should the cohortsync script at any future time be modified to use customtext fields, it is still extremely unlikely
            that customtext4 will be used.)
            Because of the overhead involved in keeping an extra table up to date and clean it up if cohort syncs are
            removed outside of this script, it was determined to be the simplest and cleanest solution.
        */

        $enrol = \enrol_get_plugin(self::METHOD);
        // Find the courses that need to be synced to the associated cohorts.
        $courseids = $this->studyplan->get_linked_course_ids();
        // And find the cohorts that are linked to this studyplan.
        $cohortids = $this->studyplan->get_linked_cohort_ids();

        foreach ($courseids as $courseid) {
            $course = \get_course($courseid);

            // First create any nonexistent links.
            foreach ($cohortids as $cohortid) {
                $cohort = $DB->get_record('cohort', ['id' => $cohortid]);

                $instanceparams = [
                    'courseid' => $courseid,
                    'customint1' => $cohortid,
                    'enrol' => self::METHOD,
                    'roleid' => get_config("local_treestudyplan", "csync_roleid"),
                ];

                $instancenewparams = [
                    'customint1' => $cohortid,
                    'enrol' => self::METHOD,
                    'roleid' => get_config("local_treestudyplan", "csync_roleid"),
                ];

                // Create group: .

                // 1:   check if a link exists.
                // If not, make it (maybe use some of the custom text to list the studyplans involved).
                if ($instance = $DB->get_record('enrol', $instanceparams)) {

                    // It already exists.
                    // Check if this studyplan is already referenced in customtext4 in json format.

                    // TODO: Check this code - Maybe add option to not remember manually added stuff .
                    $plans = json_decode($instance->customtext4);
                    if ($plans == false || !is_array(($plans))) {
                        // If the data was not an array (null or garbled), count it as manually added.
                        // This will prevent it's deletion upon.
                        if (get_config("local_treestudyplan", "csync_remember_manual_csync")) {
                            $plans = ["manual"];
                        } else {
                            $plans = [];
                        }
                    }
                    if (!in_array($this->studyplanid , $plans)) {
                        // If not, add it to the reference.

                        $plans[] = (int)($this->studyplanid);
                        $enrol->update_instance($instance, (object)["customtext4" => json_encode($plans)]);
                    }

                } else {

                    // If method members should be added to a group, create it or get its ID.

                    if (get_config("local_treestudyplan", "csync_creategroup")) {
                        // Make or get new new cohort group - but only on creating of instances.
                        $groupname = $cohort->name." ".strtolower(\get_string('defaultgroupname', 'core_group'));

                        // And make sure the .
                        $instancenewparams['customint2'] = self::uploadenrolmentmethods_get_group($courseid, $groupname);
                    }

                    if ($instanceid = $enrol->add_instance($course, $instancenewparams)) {
                        // Also record the (as of yet only) studyplans id requiring this association.
                        // In the customtext4 field in json format.

                        $instance = $DB->get_record('enrol', array('id' => $instanceid));
                        $enrol->update_instance($instance, (object)["customtext4" => json_encode([(int)($this->studyplanid)])]);

                        // Successfully added a valid new instance, so now instantiate it.
                        // First synchronise the enrolment.
                        $cohorttrace = new \null_progress_trace();
                        $result = enrol_cohort_sync($cohorttrace, $cohortid);
                        $cohorttrace->finished();

                    }
                }
            }

            /* 2:   Check if there are cohort links for this studyplan in this course that should be removed.
                    A: Check if there are cohort links that are no longer related to this studyplan.
                    B: Check if these links are valid through another studyplan...
                    If no one uses the link anymore, deactivate it...

                    This does not remove the sync from courses that are unlinked from a studplan.
                    But maybe we do not want that anyway, since it is generally a good idea to keep student
                    access to courses available .
            */

            if (get_config("local_treestudyplan", "csync_autoremove")) {
                // Only try the autoremove if the option is enabled.

                // Find all cohort syncs for this course.
                $searchparams = [
                    'courseid' => $courseid,
                    'enrol' => self::METHOD,
                    'roleid' => get_config("local_treestudyplan", "csync_roleid"),
                ];

                $records = $DB->get_records("enrol", $searchparams);
                foreach ($records as $instance) {
                    if (!empty($instance->customtext4)) {
                        // Only check the records that have studyplan information in the customtext4 field.
                        // First check if the cohort is not one of the cohort id's we have associated.
                        if (!in_array($instance->customint1, $cohortids)) {

                            // So it may or may not need to be removed.
                            $plans = json_decode($instance->customtext4);
                            if ($plans !== null && is_array($plans)) {
                                // If a valid array is not returned, better leave it be, we don't want to mess with it.
                                // Otherwise, check if we should remove it.
                                if (in_array($this->studyplanid, $plans)) {

                                    // If this plan was referenced before.
                                    // First remove the link.
                                    $fplans = self::array_remove_value($plans, $this->studyplanid);
                                    if (count($fplans) == 0) {
                                        // Delete the sync if there are no studyplan references left.

                                        $enrol->delete_instance($instance);
                                    } else {
                                        // Otherwise just update the references so this studyplan is no longer linked.

                                        $enrol->update_instance($instance, (object)["customtext4" => json_encode($fplans)]);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

    }
}