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

/**

 * Class containing data for my overview block.

 *

 * @package    block_myoverview

 * @copyright  2017 Ryan Wyllie <ryan@moodle.com>

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

namespace block_myoverview\output;

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

use core_competency\url;

use renderable;

use renderer_base;

use templatable;

use stdClass;

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

/**

 * Class containing data for my overview block.

 *

 * @copyright  2018 Bas Brands <bas@moodle.com>

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

class main implements renderable, templatable {

    /**

     * Store the grouping preference.

     *

     * @var string String matching the grouping constants defined in myoverview/lib.php

     */

    private $grouping;

    /**

     * Store the sort preference.

     *

     * @var string String matching the sort constants defined in myoverview/lib.php

     */

    private $sort;

    /**

     * Store the view preference.

     *

     * @var string String matching the view/display constants defined in myoverview/lib.php

     */

    private $view;

    /**

     * Store the paging preference.

     *

     * @var string String matching the paging constants defined in myoverview/lib.php

     */

    private $paging;

    /**

     * Store the display categories config setting.

     *

     * @var boolean

     */

    private $displaycategories;

    /**

     * Store the configuration values for the myoverview block.

     *

     * @var array Array of available layouts matching view/display constants defined in myoverview/lib.php

     */

    private $layouts;

    /**

     * Store a course grouping option setting

     *

     * @var boolean

     */

    private $displaygroupingallincludinghidden;

    /**

     * Store a course grouping option setting.

     *

     * @var boolean

     */

    private $displaygroupingall;

    /**

     * Store a course grouping option setting.

     *

     * @var boolean

     */

    private $displaygroupinginprogress;

    /**

     * Store a course grouping option setting.

     *

     * @var boolean

     */

    private $displaygroupingfuture;

    /**

     * Store a course grouping option setting.

     *

     * @var boolean

     */

    private $displaygroupingpast;

    /**

     * Store a course grouping option setting.

     *

     * @var boolean

     */

    private $displaygroupingfavourites;

    /**

     * Store a course grouping option setting.

     *

     * @var boolean

     */

    private $displaygroupinghidden;

    /**

     * Store a course grouping option setting.

     *

     * @var bool

     */

    private $displaygroupingcustomfield;

    /**

     * Store the custom field used by customfield grouping.

     *

     * @var string

     */

    private $customfiltergrouping;

    /**

     * Store the selected custom field value to group by.

     *

     * @var string

     */

    private $customfieldvalue;

    /** @var bool true if grouping selector should be shown, otherwise false. */

    protected $displaygroupingselector;

    /**

     * main constructor.

     * Initialize the user preferences

     *

     * @param string $grouping Grouping user preference

     * @param string $sort Sort user preference

     * @param string $view Display user preference

     * @param int $paging

     * @param string $customfieldvalue

     *

     * @throws \dml_exception

     */

    public function __construct($grouping, $sort, $view, $paging, $customfieldvalue = null) {

        global $CFG;

        // Get plugin config.

        $config = get_config('block_myoverview');

        // Build the course grouping option name to check if the given grouping is enabled afterwards.

        $groupingconfigname = 'displaygrouping'.$grouping;

        // Check the given grouping and remember it if it is enabled.

        if ($grouping && $config->$groupingconfigname == true) {

            $this->grouping = $grouping;

            // Otherwise fall back to another grouping in a reasonable order.

            // This is done to prevent one-time UI glitches in the case when a user has chosen a grouping option previously which

            // was then disabled by the admin in the meantime.

        } else {

            $this->grouping = $this->get_fallback_grouping($config);

        }

        unset ($groupingconfigname);

        // Remember which custom field value we were using, if grouping by custom field.

        $this->customfieldvalue = $customfieldvalue;

        // Check and remember the given sorting.

        if ($sort) {

            $this->sort = $sort;

        } else if ($CFG->courselistshortnames) {

            $this->sort = BLOCK_MYOVERVIEW_SORTING_SHORTNAME;

        } else {

            $this->sort = BLOCK_MYOVERVIEW_SORTING_TITLE;

        }

        // In case sorting remembered is shortname and display extended course names not checked,

        // we should revert sorting to title.

        if (!$CFG->courselistshortnames && $sort == BLOCK_MYOVERVIEW_SORTING_SHORTNAME) {

            $this->sort = BLOCK_MYOVERVIEW_SORTING_TITLE;

        }

        // Check and remember the given view.

        $this->view = $view ? $view : BLOCK_MYOVERVIEW_VIEW_CARD;

        // Check and remember the given page size, `null` indicates no page size set

        // while a `0` indicates a paging size of `All`.

        if (!is_null($paging) && $paging == BLOCK_MYOVERVIEW_PAGING_ALL) {

            $this->paging = BLOCK_MYOVERVIEW_PAGING_ALL;

        } else {

            $this->paging = $paging ? $paging : BLOCK_MYOVERVIEW_PAGING_12;

        }

        // Check and remember if the course categories should be shown or not.

        if (!$config->displaycategories) {

            $this->displaycategories = BLOCK_MYOVERVIEW_DISPLAY_CATEGORIES_OFF;

        } else {

            $this->displaycategories = BLOCK_MYOVERVIEW_DISPLAY_CATEGORIES_ON;

        }

        // Get and remember the available layouts.

        $this->set_available_layouts();

        $this->view = $view ? $view : reset($this->layouts);

        // Check and remember if the particular grouping options should be shown or not.

        $this->displaygroupingallincludinghidden = $config->displaygroupingallincludinghidden;

        $this->displaygroupingall = $config->displaygroupingall;

        $this->displaygroupinginprogress = $config->displaygroupinginprogress;

        $this->displaygroupingfuture = $config->displaygroupingfuture;

        $this->displaygroupingpast = $config->displaygroupingpast;

        $this->displaygroupingfavourites = $config->displaygroupingfavourites;

        $this->displaygroupinghidden = $config->displaygroupinghidden;

        $this->displaygroupingcustomfield = ($config->displaygroupingcustomfield && $config->customfiltergrouping);

        $this->customfiltergrouping = $config->customfiltergrouping;

        // Check and remember if the grouping selector should be shown at all or not.

        // It will be shown if more than 1 grouping option is enabled.

        $displaygroupingselectors = array($this->displaygroupingallincludinghidden,

                $this->displaygroupingall,

                $this->displaygroupinginprogress,

                $this->displaygroupingfuture,

                $this->displaygroupingpast,

                $this->displaygroupingfavourites,

                $this->displaygroupinghidden);

        $displaygroupingselectorscount = count(array_filter($displaygroupingselectors));

        if ($displaygroupingselectorscount > 1 || $this->displaygroupingcustomfield) {

            $this->displaygroupingselector = true;

        } else {

            $this->displaygroupingselector = false;

        }

        unset ($displaygroupingselectors, $displaygroupingselectorscount);

    }

    /**

     * Determine the most sensible fallback grouping to use (in cases where the stored selection

     * is no longer available).

     * @param object $config

     * @return string

     */

    private function get_fallback_grouping($config) {

        if ($config->displaygroupingall == true) {

            return BLOCK_MYOVERVIEW_GROUPING_ALL;

        }

        if ($config->displaygroupingallincludinghidden == true) {

            return BLOCK_MYOVERVIEW_GROUPING_ALLINCLUDINGHIDDEN;

        }

        if ($config->displaygroupinginprogress == true) {

            return BLOCK_MYOVERVIEW_GROUPING_INPROGRESS;

        }

        if ($config->displaygroupingfuture == true) {

            return BLOCK_MYOVERVIEW_GROUPING_FUTURE;

        }

        if ($config->displaygroupingpast == true) {

            return BLOCK_MYOVERVIEW_GROUPING_PAST;

        }

        if ($config->displaygroupingfavourites == true) {

            return BLOCK_MYOVERVIEW_GROUPING_FAVOURITES;

        }

        if ($config->displaygroupinghidden == true) {

            return BLOCK_MYOVERVIEW_GROUPING_HIDDEN;

        }

        if ($config->displaygroupingcustomfield == true) {

            return BLOCK_MYOVERVIEW_GROUPING_CUSTOMFIELD;

        }

        // In this case, no grouping option is enabled and the grouping is not needed at all.

        // But it's better not to leave $this->grouping unset for any unexpected case.

        return BLOCK_MYOVERVIEW_GROUPING_ALLINCLUDINGHIDDEN;

    }

    /**

     * Set the available layouts based on the config table settings,

     * if none are available, defaults to the cards view.

     *

     * @throws \dml_exception

     *

     */

    public function set_available_layouts() {

        if ($config = get_config('block_myoverview', 'layouts')) {

            $this->layouts = explode(',', $config);

        } else {

            $this->layouts = array(BLOCK_MYOVERVIEW_VIEW_CARD);

        }

    }

    /**

     * Get the user preferences as an array to figure out what has been selected.

     *

     * @return array $preferences Array with the pref as key and value set to true

     */

    public function get_preferences_as_booleans() {

        $preferences = [];

        $preferences[$this->sort] = true;

        $preferences[$this->grouping] = true;

        // Only use the user view/display preference if it is in available layouts.

        if (in_array($this->view, $this->layouts)) {

            $preferences[$this->view] = true;

        } else {

            $preferences[reset($this->layouts)] = true;

        }

        return $preferences;

    }

    /**

     * Format a layout into an object for export as a Context variable to template.

     *

     * @param string $layoutname

     *

     * @return \stdClass $layout an object representation of a layout

     * @throws \coding_exception

     */

    public function format_layout_for_export($layoutname) {

        $layout = new stdClass();

        $layout->id = $layoutname;

        $layout->name = get_string($layoutname, 'block_myoverview');

        $layout->active = $this->view == $layoutname ? true : false;

        $layout->arialabel = get_string('aria:' . $layoutname, 'block_myoverview');

        return $layout;

    }

    /**

     * Get the available layouts formatted for export.

     *

     * @return array an array of objects representing available layouts

     */

    public function get_formatted_available_layouts_for_export() {

        return array_map(array($this, 'format_layout_for_export'), $this->layouts);

    }

    /**

     * Get the list of values to add to the grouping dropdown

     * @return object[] containing name, value and active fields

     */

    public function get_customfield_values_for_export() {

        global $DB, $USER;

        if (!$this->displaygroupingcustomfield) {

            return [];

        }

        // Get the relevant customfield ID within the core_course/course component/area.

        $fieldid = $DB->get_field_sql("

            SELECT f.id

              FROM {customfield_field} f

              JOIN {customfield_category} c ON c.id = f.categoryid

             WHERE f.shortname = :shortname AND c.component = 'core_course' AND c.area = 'course'

        ", ['shortname' => $this->customfiltergrouping]);

        if (!$fieldid) {

            return [];

        }

        $courses = enrol_get_all_users_courses($USER->id, true);

        if (!$courses) {

            return [];

        }

        list($csql, $params) = $DB->get_in_or_equal(array_keys($courses), SQL_PARAMS_NAMED);

        $select = "instanceid $csql AND fieldid = :fieldid";

        $params['fieldid'] = $fieldid;

        $distinctablevalue = $DB->sql_compare_text('value');

        $values = $DB->get_records_select_menu('customfield_data', $select, $params, '',

            "DISTINCT $distinctablevalue, $distinctablevalue AS value2");

        \core_collator::asort($values, \core_collator::SORT_NATURAL);

        $values = array_filter($values);

        if (!$values) {

            return [];

        }

        $field = \core_customfield\field_controller::create($fieldid);

        $isvisible = $field->get_configdata_property('visibility') == \core_course\customfield\course_handler::VISIBLETOALL;

        // Only visible fields to everybody supporting course grouping will be displayed.

        if (!$field->supports_course_grouping() || !$isvisible) {

            return []; // The field shouldn't have been selectable in the global settings, but just skip it now.

        }

        $values = $field->course_grouping_format_values($values);

        $customfieldactive = ($this->grouping === BLOCK_MYOVERVIEW_GROUPING_CUSTOMFIELD);

        $ret = [];

        foreach ($values as $value => $name) {

            $ret[] = (object)[

                'name' => $name,

                'value' => $value,

                'active' => ($customfieldactive && ($this->customfieldvalue == $value)),

            ];

        }

        return $ret;

    }

    /**

     * Export this data so it can be used as the context for a mustache template.

     *

     * @param \renderer_base $output

     * @return array Context variables for the template

     * @throws \coding_exception

     *

     */

    public function export_for_template(renderer_base $output) {

        global $CFG, $USER;

        $nocoursesurl = $output->image_url('courses', 'block_myoverview')->out();

        $newcourseurl = '';

        $coursecat = \core_course_category::user_top();

        if ($coursecat && ($category = \core_course_category::get_nearest_editable_subcategory($coursecat, ['create']))) {

            $newcourseurl = new \moodle_url('/course/edit.php', ['category' => $category->id]);

        }

        $customfieldvalues = $this->get_customfield_values_for_export();

        $selectedcustomfield = '';

        if ($this->grouping == BLOCK_MYOVERVIEW_GROUPING_CUSTOMFIELD) {

            foreach ($customfieldvalues as $field) {

                if ($field->value == $this->customfieldvalue) {

                    $selectedcustomfield = $field->name;

                    break;

                }

            }

            // If the selected custom field value has not been found (possibly because the field has

            // been changed in the settings) find a suitable fallback.

            if (!$selectedcustomfield) {

                $this->grouping = $this->get_fallback_grouping(get_config('block_myoverview'));

                if ($this->grouping == BLOCK_MYOVERVIEW_GROUPING_CUSTOMFIELD) {

                    // If the fallback grouping is still customfield, then select the first field.

                    $firstfield = reset($customfieldvalues);

                    if ($firstfield) {

                        $selectedcustomfield = $firstfield->name;

                        $this->customfieldvalue = $firstfield->value;

                    }

                }

            }

        }

        $preferences = $this->get_preferences_as_booleans();

        $availablelayouts = $this->get_formatted_available_layouts_for_export();

        $sort = '';

        if ($this->sort == BLOCK_MYOVERVIEW_SORTING_SHORTNAME) {

            $sort = 'shortname';

        } else {

            $sort = $this->sort == BLOCK_MYOVERVIEW_SORTING_TITLE ? 'fullname' : 'ul.timeaccess desc';

        }

        $defaultvariables = [

            'totalcoursecount' => count(enrol_get_all_users_courses($USER->id, true)),

            'nocoursesimg' => $nocoursesurl,

            'newcourseurl' => $newcourseurl,

            'grouping' => $this->grouping,

            'sort' => $sort,

            // If the user preference display option is not available, default to first available layout.

            'view' => in_array($this->view, $this->layouts) ? $this->view : reset($this->layouts),

            'paging' => $this->paging,

            'layouts' => $availablelayouts,

            'displaycategories' => $this->displaycategories,

            'displaydropdown' => (count($availablelayouts) > 1) ? true : false,

            'displaygroupingallincludinghidden' => $this->displaygroupingallincludinghidden,

            'displaygroupingall' => $this->displaygroupingall,

            'displaygroupinginprogress' => $this->displaygroupinginprogress,

            'displaygroupingfuture' => $this->displaygroupingfuture,

            'displaygroupingpast' => $this->displaygroupingpast,

            'displaygroupingfavourites' => $this->displaygroupingfavourites,

            'displaygroupinghidden' => $this->displaygroupinghidden,

            'displaygroupingselector' => $this->displaygroupingselector,

            'displaygroupingcustomfield' => $this->displaygroupingcustomfield && $customfieldvalues,

            'customfieldname' => $this->customfiltergrouping,

            'customfieldvalue' => $this->customfieldvalue,

            'customfieldvalues' => $customfieldvalues,

            'selectedcustomfield' => $selectedcustomfield,

            'showsortbyshortname' => $CFG->courselistshortnames,

        ];

        return array_merge($defaultvariables, $preferences);

    }

    /**

     * Export this data so it can be used as the context for a mustache template.

     *

     * @param \renderer_base $output

     * @return array Context variables for the template

     * @throws \coding_exception

     *

     */

    public function export_for_zero_state_template(renderer_base $output) {

        global $CFG, $DB;

        $nocoursesimg = $output->image_url('courses', 'block_myoverview');

        $coursecat = \core_course_category::user_top();

        if ($coursecat) {

            $category = \core_course_category::get_nearest_editable_subcategory($coursecat, ['moodle/course:request']);

            if ($category && $category->can_request_course()) {

                // Add Request a course button.

                $button = new \single_button(

                    new \moodle_url('/course/request.php', ['category' => $category->id]),

                    get_string('requestcourse'),

                    'post',

                    \single_button::BUTTON_PRIMARY

                );

                return $this->generate_zero_state_data(

                    $nocoursesimg,

                    [$button->export_for_template($output)],

                    ['title' => 'zero_request_title', 'intro' => 'zero_request_intro']

                );

            }

            $totalcourses = $DB->count_records_select('course', 'category > 0');

            if (!$totalcourses && ($category = \core_course_category::get_nearest_editable_subcategory($coursecat, ['create']))) {

                // Add Quickstart guide and Create course buttons.

                $quickstarturl = $CFG->coursecreationguide;

                if ($quickstarturl) {

                    $quickstartbutton = new \single_button(

                        new \moodle_url($quickstarturl, ['lang' => current_language()]),

                        get_string('viewquickstart', 'block_myoverview'),

                        'get',

                    );

                    $buttons = [$quickstartbutton->export_for_template($output)];

                }

                $createbutton = new \single_button(

                    new \moodle_url('/course/edit.php', ['category' => $category->id]),

                    get_string('createcourse', 'block_myoverview'),

                    'post',

                    \single_button::BUTTON_PRIMARY

                );

                $buttons[] = $createbutton->export_for_template($output);

                return $this->generate_zero_state_data(

                    $nocoursesimg,

                    $buttons,

                    ['title' => 'zero_nocourses_title', 'intro' => 'zero_nocourses_intro']

                );

            }

            if ($categorytocreate = \core_course_category::get_nearest_editable_subcategory($coursecat, ['create'])) {

                $createbutton = new \single_button(

                    new \moodle_url('/course/edit.php', ['category' => $categorytocreate->id]),

                    get_string('createcourse', 'block_myoverview'),

                    'post',

                    \single_button::BUTTON_PRIMARY

                );

                $buttons = [$createbutton->export_for_template($output)];

                if ($categorytomanage = \core_course_category::get_nearest_editable_subcategory($coursecat, ['manage'])) {

                    // Add a Manage course button.

                    $managebutton = new \single_button(

                        new \moodle_url('/course/management.php', ['category' => $categorytomanage->id]),

                        get_string('managecourses')

                    );

                    $buttons[] = $managebutton->export_for_template($output);

                    return $this->generate_zero_state_data(

                        $nocoursesimg,

                        array_reverse($buttons),

                        ['title' => 'zero_default_title', 'intro' => 'zero_default_intro']

                    );

                }

                return $this->generate_zero_state_data(

                    $nocoursesimg,

                    $buttons,

                    ['title' => 'zero_default_title', 'intro' => 'zero_default_intro']

                );

            }

        }

        return $this->generate_zero_state_data(

            $nocoursesimg,

            [],

            ['title' => 'zero_default_title', 'intro' => 'zero_default_intro']

        );

    }

    /**

     * Generate the state zero data.

     *

     * @param \moodle_url $imageurl The URL to the image to show

     * @param string[] $buttons Exported {@see \single_button} instances

     * @param array $strings Title and intro strings for the zero state if needed.

     * @return array Context variables for the template

     */

    private function generate_zero_state_data(\moodle_url $imageurl, array $buttons, array $strings) {

        global $CFG;

        // Documentation data.

        $dochref = new \moodle_url($CFG->docroot, ['lang' => current_language()]);

        $quickstart = new \moodle_url($CFG->coursecreationguide, ['lang' => current_language()]);

        $docparams = [

            'quickhref' => $quickstart->out(),

            'quicktitle' => get_string('viewquickstart', 'block_myoverview'),

            'quicktarget' => '_blank',

            'dochref' => $dochref->out(),

            'doctitle' => get_string('documentation'),

            'doctarget' => $CFG->doctonewwindow ? '_blank' : '_self',

        ];

        return [

            'nocoursesimg' => $imageurl->out(),

            'title' => ($strings['title']) ? get_string($strings['title'], 'block_myoverview') : '',

            'intro' => ($strings['intro']) ? get_string($strings['intro'], 'block_myoverview', $docparams) : '',

            'buttons' => $buttons,

        ];

    }

}