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

/**

 * Mylearning widget class contains the courses user enrolled and not completed.

 *

 * @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\mylearning;

use block_dash\local\widget\abstract_widget;

use block_dash\local\widget\mylearning\mylearning_layout;

use context_module;

use context_course;

use html_writer;

use cm_info;

use moodle_url;

/**

 * Mylearning widget class contains the courses user enrolled and not completed.

 */

class mylearning_widget extends abstract_widget {

    /**

     * Get the name of widget.

     *

     * @return void

     */

    public function get_name() {

        return get_string('widget:mylearning', 'block_dash');

    }

    /**

     * Check the widget support uses the query method to build the widget.

     *

     * @return bool

     */

    public function supports_query() {

        return false;

    }

    /**

     * Layout class widget will use to render the widget content.

     *

     * @return \abstract_layout

     */

    public function layout() {

        return new mylearning_layout($this);

    }

    /**

     * Pre defined preferences that widget uses.

     *

     * @return array

     */

    public function widget_preferences() {

        $preferences = [

            'datasource' => 'mylearning',

            'layout' => 'mylearning',

        ];

        return $preferences;

    }

    /**

     * Build widget data and send to layout thene the layout will render the widget.

     *

     * @return void

     */

    public function build_widget() {

        global $USER, $CFG, $DB;

        $userid = $USER->id;

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

        require_once($CFG->dirroot.'/course/renderer.php');

        $completed = $DB->get_records_sql(

            'SELECT * FROM {course_completions} cc

            WHERE cc.userid = :userid AND cc.timecompleted > 0',

            ['userid' => $userid]

        );

        $completedcourses = array_column($completed, 'course');

        $basefields = [

            'id', 'category', 'sortorder', 'format',

            'shortname', 'fullname', 'idnumber', 'summary',

            'startdate', 'visible',

            'groupmode', 'groupmodeforce', 'cacherev',

        ];

        $courses = enrol_get_my_courses($basefields, null, 0, [], false, 0, $completedcourses);

        array_walk($courses, function($course) {

            $courseelement = (class_exists('\core_course_list_element'))

            ? new \core_course_list_element($course) : new \course_in_list($course);

            $summary = (new \coursecat_helper($course))->get_course_formatted_summary($courseelement);

            $category = (class_exists('\core_course_category'))

            ? \core_course_category::get($course->category) : \coursecat::get($course->category);

            $course->courseimage = $this->courseimage($course);

            $course->category = (isset($category->name) ? format_string($category->name) : '');

            $course->badges = $this->badges($course);

            $course->coursecontent = $this->coursecontent($course);

            $course->contacts = $this->contacts($course);

            $course->customfields = $this->customfields($course);

            $course->courseurl = new \moodle_url('/course/view.php', ['id' => $course->id]);

            $course->summary = shorten_text($summary, 200);

            $course->fullname = $courseelement->get_formatted_fullname();

        });

        $this->data = (!empty($courses)) ? ['courses' => array_values($courses)] : [];

        return $this->data;

    }

    /**

     * After records are relieved from database each field has a chance to transform the data.

     * Example: Convert unix timestamp into a human readable date format

     *

     * @param \stdClass $course

     * @return mixed

     * @throws \moodle_exception

     */

    public function courseimage($course) {

        global $DB, $CFG;

        require_once("$CFG->dirroot/course/lib.php");

        if ($course = $DB->get_record('course', ['id' => $course->id])) {

            if (block_dash_is_totara()) {

                $image = course_get_image($course->id)->out();

            } else {

                $image = \core_course\external\course_summary_exporter::get_course_image($course);

            }

            if ($image == '') {

                $courseimage = get_config('local_dash', 'courseimage');

                if ($courseimage != '') {

                    $image = moodle_url::make_pluginfile_url(

                        \context_system::instance()->id,

                        'local_dash',

                        'courseimage',

                        null,

                        null,

                        $courseimage

                    );

                }

            }

            return $image;

        }

        return false;

    }

    /**

     * Generate the Course contents like sections and activities.

     *

     * @param stdclass $record

     * @return array

     */

    public function coursecontent($record) {

        global $CFG;

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

        $options = ['name' => 'excludecontents', 'value' => true];

        $contents = self::get_course_contents($record->id, [$options]);

        return $contents;

    }

    /**

     * List of badges available in the course.

     *

     * @param \stdclass $record

     * @return void

     */

    public function badges($record) {

        global $USER, $CFG;

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

        $badges = badges_get_badges(BADGE_TYPE_COURSE, $record->id);

        $userbadges = badges_get_user_badges($USER->id, $record->id);

        $userbadges = array_column($userbadges, 'id');

        $coursecontext = \context_course::instance($record->id);

        $images = array_map(function($badge) use ($coursecontext, $userbadges) {

            $collected = (in_array($badge->id, $userbadges)) ? 'collected' : '';

            return html_writer::tag('li', print_badge_image($badge, $coursecontext, 'f1'), ['class' => $collected]);

        }, $badges);

        $heading = html_writer::tag('h5', get_string('badgestitle', 'block_dash'));

        $content = html_writer::tag('ul', implode('', $images));

        if ($images) {

            return html_writer::tag('div', $heading.$content, ['class' => 'badge-block']);

        }

    }

    /**

     * Contacts staff users list with profile pic.

     *

     * @param stdclass $record

     * @return array

     */

    public function contacts($record) {

        global $DB;

        $courserecord = get_course($record->id);

        $course = (class_exists('\core_course_list_element'))

            ? new \core_course_list_element($courserecord) : new \course_in_list($courserecord);

        $contacts = $course->get_course_contacts();

        $data = array_map(function($user) {

            global $PAGE;

            // Set the user picture data.

            $user = \core_user::get_user($user['user']->id);

            $userpicture = new \user_picture($user);

            $userpicture->size = 0; // Size f2.

            $profileurl = new \moodle_url('/user/profile.php', ['id' => $user->id]);

            $link = html_writer::empty_tag('img', [

                'src' => $userpicture->get_url($PAGE)->out(false),

                'alt' => fullname($user),

                'role' => "presentation",

            ]);

            $link .= html_writer::tag('span', fullname($user));

            $html = html_writer::start_tag('li', ['class' => 'contact-user']);

            $html .= html_writer::link($profileurl, $link);

            $html .= html_writer::end_tag('li');

            return $html;

        }, $contacts);

        if ($data) {

            $heading = html_writer::tag('h5', get_string('coursestafftitle', 'block_dash'));

            $content = html_writer::tag('ul', implode('', $data));

            return html_writer::tag('div', $heading.$content, ['class' => 'course-staff-block']);

        }

    }

    /**

     * Get course custom fields with data.

     *

     * @param stdclass $record

     * @return void

     */

    public function customfields($record) {

        global $CFG;

        $courserecord = get_course($record->id);

        $output = [];

        if (class_exists('\core_course_list_element')) {

            $course = new \core_course_list_element($courserecord);

            if ($course->has_custom_fields()) {

                foreach ($course->get_custom_fields() as $field) {

                    $output[] = [

                        'fieldname' => format_string($field->get_field()->get('name')),

                        'value' => ($field->export_value()) ? $field->export_value() : '-',

                    ];

                }

                return $output;

            }

        } else {

            $fields = get_course_custom_fields($record->id);

            if ($fields) {

                foreach ($fields as $field) {

                    $type = $field->datatype;

                    if (file_exists($CFG->dirroot.'/totara/customfield/field/'.$type.'/field.class.php')) {

                        require_once($CFG->dirroot.'/totara/customfield/field/'.$type.'/field.class.php');

                        $classname = 'customfield_'.$type;

                        $output[] = [

                            'fieldname' => format_string($field->fullname),

                            'value' => $classname::display_item_data($field->data),

                        ];

                    }

                }

                return $output;

            }

        }

    }

    /**

     * Get current course module progress. count of completion enable modules and count of completed modules.

     *

     * @param stdclass $course

     * @param int $userid

     * @return array Modules progress

     */

    protected function activity_progress($course, $userid) {

        $completion = new \completion_info($course);

        // First, let's make sure completion is enabled.

        if (!$completion->is_enabled()) {

            return null;

        }

        $result = [];

        // Get the number of modules that support completion.

        $modules = $completion->get_activities();

        $completionactivities = $completion->get_criteria(COMPLETION_CRITERIA_TYPE_ACTIVITY);

        $count = count($completionactivities);

        if (!$count) {

            return null;

        }

        // Get the number of modules that have been completed.

        $completed = 0;

        foreach ($completionactivities as $activity) {

            $cmid = $activity->moduleinstance;

            if (isset($modules[$cmid])) {

                $data = $completion->get_data($modules[$cmid], true, $userid);

                $completed += $data->completionstate == COMPLETION_INCOMPLETE ? 0 : 1;

            }

        }

        $percent = ($completed / $count) * 100;

        return ['count' => $count, 'completed' => $completed, 'percent' => $percent] + $result;

    }

    /**

     * Get course contents. Modified version of course/externallib class method get_course_contents.

     *

     * @param int $courseid course id

     * @return array

     * @since Moodle 2.9 Options available

     * @since Moodle 2.2

     */

    public static function get_course_contents($courseid) {

        global $CFG, $DB, $USER, $PAGE;

        // Include library files.

        require_once($CFG->dirroot . "/course/lib.php");

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

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

        $filters = [];

        // Retrieve the course.

        $course = $DB->get_record('course', ['id' => $courseid], '*', MUST_EXIST);

        if ($course->id != SITEID) {

            // Check course format exist.

            if (file_exists($CFG->dirroot . '/course/format/' . $course->format . '/lib.php')) {

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

            }

        }

        // Now security checks.

        $context = context_course::instance($course->id);

        // TODO: course content view capability check.

        $canupdatecourse = true;

        // Create return value.

        $coursecontents = [];

        if ($canupdatecourse || $course->visible

                || has_capability('moodle/course:viewhiddencourses', $context)) {

            $modinfo = get_fast_modinfo($course);

            $sections = $modinfo->get_section_info_all();

            $courseformat = course_get_format($course);

            $coursenumsections = $courseformat->get_last_section_number();

            $stealthmodules = [];   // Array to keep all the modules available but not visible in a course section/topic.

            $completioninfo = new \completion_info($course);

            $modinfosections = $modinfo->get_sections();

            foreach ($sections as $key => $section) {

                // This becomes true when we are filtering and we found the value to filter with.

                $sectionfound = false;

                $sectionvalues = [];

                $sectionvalues['id'] = $section->id;

                $sectionvalues['name'] = get_section_name($course, $section);

                $sectionvalues['visible'] = $section->visible;

                $options = (object) ['noclean' => true];

                list($sectionvalues['summary'], $sectionvalues['summaryformat']) =

                        external_format_text($section->summary, $section->summaryformat,

                                $context->id, 'course', 'section', $section->id, $options);

                $sectionvalues['section'] = $section->section;

                $sectionvalues['hiddenbynumsections'] = $section->section > $coursenumsections ? 1 : 0;

                $sectionvalues['uservisible'] = $section->uservisible;

                if (!empty($section->availableinfo)) {

                    $sectionvalues['availabilityinfo'] = \core_availability\info::format_info($section->availableinfo, $course);

                }

                $sectioncontents = [];

                // For each module of the section.

                $sectionactivitycompleted = $sectionactivitycount = 0;

                if (!empty($modinfosections[$section->section])) {

                    foreach ($modinfosections[$section->section] as $cmid) {

                        $cm = $modinfo->cms[$cmid];

                        $cminfo = cm_info::create($cm);

                        // Stop here if the module is not visible to the user on the course main page:

                        // The user can't access the module and the user can't view the module on the course page.

                        if (!$cm->uservisible) {

                            continue;

                        }

                        // This becomes true when we are filtering and we found the value to filter with.

                        $modfound = false;

                        $module = [];

                        $modcontext = context_module::instance($cm->id);

                        $module['id'] = $cm->id;

                        $module['name'] = external_format_string($cm->name, $modcontext->id);

                        $module['instance'] = $cm->instance;

                        $module['contextid'] = $modcontext->id;

                        $module['modname'] = (string) $cm->modname;

                        $module['modplural'] = (string) $cm->modplural;

                        $module['modicon'] = $cm->get_icon_url()->out(false);

                        $module['indent'] = $cm->indent;

                        $module['onclick'] = $cm->onclick;

                        $module['afterlink'] = $cm->afterlink;

                        $module['customdata'] = json_encode($cm->customdata);

                        $module['completion'] = $cm->completion;

                        $module['noviewlink'] = plugin_supports('mod', $cm->modname, FEATURE_NO_VIEW_LINK, false);

                        // Check module completion.

                        $completion = $completioninfo->is_enabled($cm);

                        if ($completion != COMPLETION_DISABLED) {

                            if (class_exists('\core_completion\cm_completion_details')) {

                                $cmcompletion = \core_completion\cm_completion_details::get_instance($cm, $USER->id);

                                $exporter = new \core_completion\external\completion_info_exporter($course, $cm, $USER->id);

                                $renderer = $PAGE->get_renderer('core');

                                $modulecompletiondata = (array)$exporter->export($renderer);

                                $module['completiondata'] = $modulecompletiondata;

                            } else {

                                $data = $completioninfo->get_data($cm);

                                $module['completiondata']['state'] = $data->completionstate;

                            }

                            $sectionactivitycompleted += $module['completiondata']['state'] ? 1 : 0;

                            $sectionactivitycount += 1;

                        }

                        if (!empty($cm->showdescription) || $module['noviewlink']) {

                            // We want to use the external format. However from reading get_formatted_content(), $cm->content

                            // Format is always FORMAT_HTML.

                            $options = ['noclean' => true];

                            list($module['description'], $descriptionformat) = external_format_text($cm->content,

                                FORMAT_HTML, $modcontext->id, $cm->modname, 'intro', $cm->id, $options);

                        }

                        // Url of the module.

                        $url = $cm->url;

                        if ($url) {

                            $module['url'] = $url->out(false);

                        } else {

                            $module['url'] = (new \moodle_url('/mod/'.$cm->modname.'/view.php', ['id' => $cm->id]))->out(false);

                        }

                        $canviewhidden = has_capability('moodle/course:viewhiddenactivities',

                                            context_module::instance($cm->id));

                        // User that can view hidden module should know about the visibility.

                        $module['visible'] = $cm->visible;

                        $module['visibleoncoursepage'] = $cm->visibleoncoursepage;

                        $module['uservisible'] = $cm->uservisible;

                        if (!empty($cm->availableinfo)) {

                            $module['availabilityinfo'] = \core_availability\info::format_info($cm->availableinfo, $course);

                        }

                        // Availability date (also send to user who can see hidden module).

                        if ($CFG->enableavailability && ($canviewhidden || $canupdatecourse)) {

                            $module['availability'] = $cm->availability;

                        }

                        // Assign result to $sectioncontents, there is an exception,

                        // Stealth activities in non-visible sections for students go to a special section.

                        if (!empty($filters['includestealthmodules']) && !$section->uservisible && $cm->is_stealth()) {

                            $stealthmodules[] = $module;

                        } else {

                            $sectioncontents[] = $module;

                        }

                    }

                }

                $sectionvalues['activitycompleted'] = $sectionactivitycompleted;

                $sectionvalues['activitycount'] = $sectionactivitycount;

                if ($sectionactivitycount > 0 && ($sectionactivitycount - $sectionactivitycompleted) == 0) {

                    $sectionvalues['completed'] = 1;

                }

                $sectionvalues['modules'] = $sectioncontents;

                $sectionvalues['hidemodules'] = count($sectioncontents) > 0 ? false : true;

                // Assign result to $coursecontents.

                $coursecontents[$key] = $sectionvalues;

                // Break the loop if we are filtering.

                if ($sectionfound) {

                    break;

                }

            }

            // Now that we have iterated over all the sections and activities, check the visibility.

            // We didn't this before to be able to retrieve stealth activities.

            foreach ($coursecontents as $sectionnumber => $sectioncontents) {

                $section = $sections[$sectionnumber];

                // Show the section if the user is permitted to access it OR

                // if it's not available but there is some available info text which explains the reason & should display OR

                // the course is configured to show hidden sections name.

                $showsection = $section->uservisible ||

                    ($section->visible && !$section->available && !empty($section->availableinfo)) ||

                    (!$section->visible && empty($courseformat->get_course()->hiddensections));

                if (!$showsection) {

                    unset($coursecontents[$sectionnumber]);

                    continue;

                }

                // Remove section and modules information if the section is not visible for the user.

                if (!$section->uservisible) {

                    $coursecontents[$sectionnumber]['modules'] = [];

                    // Remove summary information if the section is completely hidden only,

                    // Even if the section is not user visible, the summary is always displayed among the availability information.

                    if (!$section->visible) {

                        $coursecontents[$sectionnumber]['summary'] = '';

                    }

                }

            }

            // Include stealth modules in special section (without any info).

            if (!empty($stealthmodules)) {

                $coursecontents[] = [

                    'id' => -1,

                    'name' => '',

                    'summary' => '',

                    'summaryformat' => FORMAT_MOODLE,

                    'modules' => $stealthmodules,

                ];

            }

        }

        return $coursecontents;

    }

}