moodle_local_treestudyplan/classes/courseinfo.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/>.
/**
 * Class to process information about a course
 * @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');
require_once($CFG->libdir.'/gradelib.php');
require_once($CFG->dirroot.'/course/lib.php');

use core_course\local\repository\caching_content_item_readonly_repository;
use core_course\local\repository\content_item_readonly_repository;
use grade_item;
use grade_scale;
use grade_outcome;

/**
 * Class to process information about a course
 */
class courseinfo {
    /**
     * Table name used in this class
     * @var string */
    const TABLE = 'course';

    /** @var stdClass */
    private $course;
    /** @var \context */
    private $context;
    /** @var \context */
    private $coursecontext;
    /** @var studyitem */
    private $studyitem;
    /** @var array */
    private static $contentitems = null;
    /**
     * Cache of enrolled students in a particular course
     * @var array
     */
    private static $coursestudents = [];
    /**
     * Return database identifier
     * @return int
     */
    public function id() {
        return $this->course->id;
    }

    /**
     * Return short name
     * @return string
     */
    public function shortname() {
        return $this->course->shortname;
    }

    /**
     * Return course record
     * @return \stdClass
     */
    public function course() {
        return $this->course;
    }

    /**
     * Return course context
     * @return \context
     */
    public function course_context() {
        return $this->coursecontext;
    }

    /**
     * Return course's category context
     * @return \context
     */
    public function category_context() {
        return $this->context;
    }

    /**
     * Get content items (activity icons) from the repository
     * @return content_item[]
     */
    protected function get_contentitems() {
        global $PAGE;
        if (empty(static::$contentitems)) {
            $PAGE->set_context(\context_system::instance());
            static::$contentitems = (new content_item_readonly_repository())->find_all();
        }
        return static::$contentitems;
    }

    /**
     * Check if current user is teacher in this course
     * @return book
     */
    protected function am_teacher(): bool {
        global $USER;
        return is_enrolled($this->coursecontext, $USER, 'mod/assign:grade');
    }

    /**
     * Check if specified user can select gradables in this course
     * @param int $userid User id to check for . Leave empty to check current user
     */
    protected function i_can_select_gradables($userid = -1) {
        global $USER, $DB;
        if ($userid <= 0) {
            $usr = $USER;
        } else {
            $usr = $DB->get_record('user', ['id' => $userid, 'deleted' => 0]);
        }
        return($usr && is_enrolled($this->coursecontext, $usr, 'local/treestudyplan:selectowngradables'));
    }

    /**
     * Get specific contentitem (activity icons) by name
     * @param mixed $name Name of content item
     * @return content_item|null
     */
    public static function get_contentitem($name) {
        $contentitems = static::get_contentitems();
        for ($i = 0; $i < count($contentitems); $i++) {
            if ($contentitems[$i]->get_name() == $name) {
                return $contentitems[$i];
            }
        }
        return null;
    }

    /**
     * Construct courseinfo based on course id and
     * @param int $id Course id
     * @param studyitem|null $studyitem Studyitem linking this course (if applicable)
     */
    public function __construct($id, studyitem $studyitem = null) {
        global $DB;
        $this->studyitem = $studyitem;
        $this->course = \get_course($id);
        $this->context = \context_coursecat::instance($this->course->category);
        $this->coursecontext = \context_course::instance($this->course->id);
    }

    /**
     * Check if a course with the given ID exists
     * @param int $id Course id
     * @return bool
     */
    public static function exists($id) {
        global $DB;
        return is_numeric($id) && $DB->record_exists(self::TABLE, ['id' => $id]);
    }

    /**
     * Find course id from shortname
     * @param string $shortname Shortname of the course
     * @return int Course id
     */
    public static function id_from_shortname($shortname) {
        global $DB;

        return $DB->get_field(self::TABLE, "id", ['shortname' => $shortname]);
    }

    /**
     * Determine course timing [future, present or past] based on a course date
     * @param stdClass $course Course database record
     * @return string 'future', 'present' or 'past'
     */
    public static function coursetiming($course) {
        $now = time();
        if ($now > $course->startdate) {
            if ($course->enddate > 0 && $now > $course->enddate) {
                return "past";
            } else {
                return "present";
            }
        } else {
            return "future";
        }
    }

    /**
     * Determine course timing for this course [future, present or past]
     * @return string 'future', 'present' or 'past'
     */
    public function timing() {
        return self::coursetiming($this->course);
    }

    /**
     * Determine proper display name for this course based on config settings, custom fields etc...
     * @return string Display name for the course
     */
    public function displayname() {
        $displayfield = get_config("local_treestudyplan", "display_field");
        if ($displayfield == "idnumber") {
            $idnumber = trim(preg_replace("/\s+/u", " ", $this->course->idnumber));
            if (strlen($idnumber) > 0) {
                return $this->course->idnumber;
            }
        } else if ($displayfield == "fullname") {
            $fullname = trim(preg_replace("/\s+/u", " ", $this->course->fullname));
            if (strlen($fullname) > 0) {
                return $fullname;
            }
        } else if (strpos( $displayfield , "customfield_") === 0) {
            $fieldname = substr($displayfield, strlen("customfield_"));

            $handler = \core_customfield\handler::get_handler('core_course', 'course');
            $datas = $handler->get_instance_data($this->course->id);
            foreach ($datas as $data) {
                if ($data->get_field()->get('shortname') == $fieldname) {
                    $value = trim(preg_replace("/\s+/u", " ", $data->get_value()));
                    if (strlen($value) > 0) {
                        return $value;
                    }
                }
            }
        }
        // Fallback to shortname when the specified display field fails, since shortname is never empty.
        return $this->course->shortname;
    }

    /**
     * Webservice structure for basic info
     * @param int $value Webservice requirement constant
     */
    public static function simple_structure($value = VALUE_REQUIRED): \external_description {
        return new \external_single_structure([
            "id" => new \external_value(PARAM_INT, 'linked course id'),
            "fullname" => new \external_value(PARAM_TEXT, 'linked course name'),
            "shortname" => new \external_value(PARAM_TEXT, 'linked course shortname'),
            "displayname" => new \external_value(PARAM_TEXT, 'linked course displayname'),
            "context" => contextinfo::structure(VALUE_OPTIONAL),
        ], 'referenced course information', $value);
    }

    /**
     * Webservice model for basic info
     * @return array Webservice data model
     */
    public function simple_model() {
        $contextinfo = new contextinfo($this->context);
        $info = [
            'id' => $this->course->id,
            'fullname' => $this->course->fullname,
            'shortname' => $this->course->shortname,
            'displayname' => $this->displayname(),
            'context' => $contextinfo->model()
        ];

        return $info;
    }

    /**
     * Webservice structure for editor info
     * @param int $value Webservice requirement constant
     */
    public static function editor_structure($value = VALUE_REQUIRED): \external_description {
        return new \external_single_structure([
            "id" => new \external_value(PARAM_INT, 'linked course id'),
            "fullname" => new \external_value(PARAM_TEXT, 'linked course name'),
            "shortname" => new \external_value(PARAM_TEXT, 'linked course shortname'),
            "displayname" => new \external_value(PARAM_TEXT, 'linked course displayname'),
            "context" => contextinfo::structure(VALUE_OPTIONAL),
            "ctxid" => new \external_value(PARAM_INT, 'course context id name'),
            "grades" => new \external_multiple_structure(gradeinfo::editor_structure(),
                            'grade list (legacy list)', VALUE_OPTIONAL),
            "completion" => corecompletioninfo::editor_structure(VALUE_OPTIONAL),
            "competency" => coursecompetencyinfo::editor_structure(VALUE_OPTIONAL),
            "timing" => new \external_value(PARAM_TEXT, '(past|present|future)'),
            "startdate" => new \external_value(PARAM_TEXT, 'Course start date'),
            "enddate" => new \external_value(PARAM_TEXT, 'Course end date'),
            "amteacher" => new \external_value(PARAM_BOOL, 'Requesting user is teacher in this course'),
            "canupdatecourse" => new \external_value(PARAM_BOOL, "If the current user can update this course"),
            "canselectgradables" => new \external_value(PARAM_BOOL, 'Requesting user can change selected gradables'),
            "numenrolled" => new \external_value(PARAM_INT, 'number of students from this studyplan enrolled in the course'),
            "tag" => new \external_value(PARAM_TEXT, 'Tag'),
            "extrafields" => self::extrafields_structure(),
        ], 'referenced course information', $value);
    }

    /**
     * Webservice model for editor info
     * @param studyitem $studyitem Specify a specific study item to check gradable selections for. Leave empty to use default
     * @return array Webservice data model
     */
    public function editor_model() {
        $contextinfo = new contextinfo($this->context);
        $timing = $this->timing();

        if (isset($this->studyitem)) {
            $numenrolled = $this->count_enrolled_students($this->studyitem->studyline()->studyplan()->find_linked_userids());
        } else {
            $numenrolled = 0;
        }

        $info = [
            'id' => $this->course->id,
            'fullname' => $this->course->fullname,
            'shortname' => $this->course->shortname,
            'displayname' => $this->displayname(),
            'context' => $contextinfo->model(),
            'ctxid' => $this->coursecontext->id,
            'timing' => $timing,
            'startdate' => date("Y-m-d", $this->course->startdate),
            'enddate' => date("Y-m-d", $this->course->enddate),
            'amteacher' => $this->am_teacher(),
            'canupdatecourse' => \has_capability("moodle/course:update", $this->coursecontext),
            'canselectgradables' => $this->i_can_select_gradables(),
            'tag' => "Editormodel",
            'extrafields' => $this->extrafields_model(true),
            'grades' => [],
            'numenrolled' => $numenrolled,
        ];

        if (isset($this->studyitem)) {
            $aggregator = $this->studyitem->studyline()->studyplan()->aggregator();

            if ($aggregator->use_manualactivityselection()) {
                $gradables = gradeinfo::list_course_gradables($this->course, $this->studyitem );
                foreach ($gradables as $gradable) {
                    $info['grades'][] = $gradable->editor_model($this->studyitem);
                }
            }
            if ($aggregator->use_corecompletioninfo())  {
                $cc = new corecompletioninfo($this->course, $this->studyitem);
                $studentlist = $this->studyitem->studyline()->studyplan()->find_linked_userids();
                $info['completion'] = $cc->editor_model($studentlist);
            }
            if ($aggregator->use_coursecompetencies())  {
                $ci = new coursecompetencyinfo($this->course, $this->studyitem);
                $studentlist = $this->studyitem->studyline()->studyplan()->find_linked_userids();
                $info['competency'] = $ci->editor_model($studentlist);
            }
        }
        return $info;
    }

    /**
     * Webservice structure for userinfo
     * @param int $value Webservice requirement constant
     */
    public static function user_structure($value = VALUE_REQUIRED): \external_description {
        return new \external_single_structure([
            "id" => new \external_value(PARAM_INT, 'linked course id'),
            "fullname" => new \external_value(PARAM_TEXT, 'linked course name'),
            "shortname" => new \external_value(PARAM_TEXT, 'linked course shortname'),
            "displayname" => new \external_value(PARAM_TEXT, 'linked course displayname'),
            "context" => contextinfo::structure(VALUE_OPTIONAL),
            "ctxid" => new \external_value(PARAM_INT, 'course context id name'),
            "grades" => new \external_multiple_structure(gradeinfo::user_structure(), 'grade list (legacy list)', VALUE_OPTIONAL),
            "completion" => corecompletioninfo::user_structure(VALUE_OPTIONAL),
            "competency" => coursecompetencyinfo::user_structure(VALUE_OPTIONAL),
            "timing" => new \external_value(PARAM_TEXT, '(past|present|future)'),
            "startdate" => new \external_value(PARAM_TEXT, 'Course start date'),
            "enddate" => new \external_value(PARAM_TEXT, 'Course end date'),
            "enrolled" => new \external_value(PARAM_BOOL, 'True if student is enrolled as student in this course'),
            "extrafields" => self::extrafields_structure(),
            "showprogressbar" => new \external_value(PARAM_BOOL, "Whether to show the progress bar in the header"),
        ], 'course information', $value);
    }

    /**
     * List all users enrolled in a course as student by userid
     * @param int $courseid Course id of the course to check
     * @return int[] Array if user ids
     */
    public static function get_course_students($courseid): array {
        global $CFG;
        if (!array_key_exists($courseid, self::$coursestudents)) {
            $students = [];
            $context = \context_course::instance($courseid);
            foreach (explode(', ', $CFG->gradebookroles) as $roleid) {
                $roleid = trim($roleid);
                $students = array_keys(get_role_users($roleid, $context, false, 'u.id', 'u.id ASC'));
            }
            self::$coursestudents[$courseid] = $students;
        }
        return self::$coursestudents[$courseid];
    }

    /**
     * Check if a user is enrolled as a student in this course
     * (Has a gradebook role)
     * @param int $userid The user Id to check
     */
    public function is_enrolled_student($userid): bool {
        global $CFG;
        foreach (explode(', ', $CFG->gradebookroles) as $roleid) {
            if (user_has_role_assignment($userid, $roleid, $this->coursecontext->id)) {
                return true;
            }
        }
        return false;
    }

    /**
     * List how many users from a list  also enrolled as students
     * (Has a gradebook role)
     * @param int[] $userids The user Ids to check
     */
    private function count_enrolled_students(array $userids) {
        $count = 0;
        foreach ($userids as $userid) {
            if ($this->is_enrolled_student($userid)) {
                $count++;
            }
        }
        return $count;
    }

    /**
     * Webservice model for user info
     * @param int $userid ID of user to check specific info for
     * @return array Webservice data model
     */
    public function user_model($userid) {
        global $DB;
        $contextinfo = new contextinfo($this->context);

        $timing = $this->timing();

        $info = [
            'id' => $this->course->id,
            'fullname' => $this->course->fullname,
            'shortname' => $this->course->shortname,
            'displayname' => $this->displayname(),
            'context' => $contextinfo->model(),
            'ctxid' => $this->coursecontext->id,
            'timing' => $timing,
            'startdate' => date("Y-m-d", $this->course->startdate),
            'enddate' => date("Y-m-d", $this->course->enddate),
            'grades' => [],
            'enrolled' => $this->is_enrolled_student($userid),
            'extrafields' => $this->extrafields_model(),
            'showprogressbar' => get_config("local_treestudyplan", "courseprogressbar"),
        ];

        if (isset($this->studyitem)) {
            $aggregator = $this->studyitem->studyline()->studyplan()->aggregator();

            if ($aggregator->use_manualactivityselection()) {
                $gradables = gradeinfo::list_studyitem_gradables($this->studyitem);
                foreach ($gradables as $gi) {
                    $info['grades'][] = $gi->user_model($userid);
                }
            }
            if ($aggregator->use_corecompletioninfo())  {
                $cc = new corecompletioninfo($this->course, $this->studyitem);
                $info['completion'] = $cc->user_model($userid);
            }
            if ($aggregator->use_coursecompetencies())  {
                $ci = new coursecompetencyinfo($this->course, $this->studyitem);
                $info['competency'] = $ci->user_model($userid);
            }
        }
        return $info;
    }

    /**
     * Webservice structure for extra fields
     * @param int $value Webservice requirement constant
     */
    public static function extrafields_structure($value = VALUE_REQUIRED): \external_description {
        return new \external_multiple_structure(new \external_single_structure([
            "title" => new \external_value(PARAM_RAW, 'title'),
            "value" => new \external_value(PARAM_RAW, 'value'),
            "position" => new \external_value(PARAM_TEXT, 'position'),
            "type" => new \external_value(PARAM_TEXT, 'value type'),
            "fieldname" => new \external_value(PARAM_TEXT, 'field name'),
            "checked" => new \external_value(PARAM_BOOL, 'checkbox value', VALUE_OPTIONAL),
            "courseid" => new \external_value(PARAM_TEXT, 'course id number'),
        ], 'referenced course information'), $value);
    }

    /**
     * Webservice model for basic info
     * @param $includeteachervisible Include custom fiel
     * @return array Webservice data model
     */
    public function extrafields_model($includeteachervisible=false) {
        $list = [];
        for ($i=1; $i <= 5; $i++) {
            $field = get_config('local_treestudyplan', 'courseinfo'.$i.'_field');
            if ($field) {
                $title = self::extrafields_localize_title(get_config('local_treestudyplan', 'courseinfo'.$i.'_title'));
                $pos = get_config('local_treestudyplan', 'courseinfo'.$i.'_position');
                [$value, $type, $raw] = $this->extrafields_value($field, $includeteachervisible);
                if ($type) {
                    $list[] = [
                        "title" => $title,
                        "value" => $value,
                        "position" => $pos,
                        "type" => $type,
                        "fieldname" => $field,
                        "courseid" => $this->course->id,
                        "checked" => ($type=="checkbox") ? ($raw ? true : false):null,
                    ];
                }
            }
        }
        return $list;
    }

    protected static function extrafields_localize_title($field) {
        $lang = trim(current_language());
        $lines = explode("\n", $field);
        $title = "";
        $fallback = ""; // Fallback to first title
        foreach ($lines as $l) {
            $parts = explode("|", $l, 2);
            if (count($parts) > 0) {
                // Set the first line as fallback.
                if (empty($firsttitle) && !empty($parts[0])) {
                    $fallback = $parts[0];
                }
                if (count($parts) == 1 && empty($title)) {
                    // Set line without language as default if no localized line found
                    $title = trim($parts[0]);
                } else if (trim($parts[1]) == $lang) {
                    return trim($parts[0]);
                }
            }
        }

        // Return default title or fall back to first localizef title.
        return (strlen($title) > 0)?$title:$fallback;
    }

    /**
     * Determine value and type of an extra field for this course
     * @return array [value, type] of the field for this
     */
    protected function extrafields_value($fieldname, $includeteachervisible=false) {
        global $PAGE;
        if ($fieldname == "description") {
            // Process embedded files.
            $value = \file_rewrite_pluginfile_urls(
                // The description content
                $this->course()->summary,
                // The pluginfile URL which will serve the request.
                'pluginfile.php',
                // The combination of contextid / component / filearea / itemid
                // form the virtual bucket that file are stored in.
                $this->coursecontext->id, // System instance is always used for this
                'course',
                'summary',
                ''
            );
            return [$value, "textarea", $this->course()->summary];
        } else if ($fieldname == "idnumber") {
            $idnumber = trim(preg_replace("/\s+/u", " ", $this->course->idnumber));
            return [$idnumber, "text", $this->course->idnumber];
        }  else if ($fieldname == "contacts") {
            $cle = new \core_course_list_element($this->course());
            $contacts = $cle->get_course_contacts();
            $value = "";
            foreach ($contacts as $uid => $contact) {
                if (strlen($value) > 0) {
                    $value .= ", ";
                }
                $value .= $contact["username"];
            }
            if (empty($value)) {
                $value = get_string("none");
            }
            return [$value, "text", $value];
        }  else if (strpos( $fieldname , "customfield_") === 0) {
            $fieldshortname = substr($fieldname, strlen("customfield_"));

            $handler = \core_customfield\handler::get_handler('core_course', 'course');
            $datas = $handler->get_instance_data($this->course->id);
            foreach ($datas as $data) {
                $field = $data->get_field();
                $fshortname = $field->get('shortname');
                if ($fshortname == $fieldshortname) {
                    $visibility = $field->get_configdata_property("visibility");
                    $raw = $data->get_value();
                    $type = $field->get('type');

                    // Only show if visibility is "Everyone" or ("Teachers" and in teacher view )
                    if ($visibility > 0 && ($visibility == 2 || $includeteachervisible)) {
                        if ($type == "date") {
                            // Date should be converted to YYYY-MM-DD so the javascript can properly format it.
                            if ($raw == 0) {
                                $value = "";
                            } else {
                                // Convert to YYYY-MM-DD format.
                                $value = date("Y-m-d", $raw);
                            }
                        } else {
                            // Everything else can just use the export value.
                            $PAGE->set_context(\context_system::instance());
                            $value = $data->export_value();
                        }

                        return [$value, $type, $raw];
                    }
                }
            }
        }
        // Fallback to empty if finding a match fails.
        return [null, null, null];
    }
}