1<?php
2// This file is part of Moodle - http://moodle.org/
3//
4// Moodle is free software: you can redistribute it and/or modify
5// it under the terms of the GNU General Public License as published by
6// the Free Software Foundation, either version 3 of the License, or
7// (at your option) any later version.
8//
9// Moodle is distributed in the hope that it will be useful,
10// but WITHOUT ANY WARRANTY; without even the implied warranty of
11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12// GNU General Public License for more details.
13//
14// You should have received a copy of the GNU General Public License
15// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
16
17/**
18 * Class handles conditional availability information for an activity.
19 *
20 * @package core_availability
21 * @copyright 2014 The Open University
22 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23 */
24
25namespace core_availability;
26
27defined('MOODLE_INTERNAL') || die();
28
29/**
30 * Class handles conditional availability information for an activity.
31 *
32 * @package core_availability
33 * @copyright 2014 The Open University
34 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
35 */
36class info_module extends info {
37    /** @var \cm_info Activity. */
38    protected $cm;
39
40    /**
41     * Constructs with item details.
42     *
43     * @param \cm_info $cm Course-module object
44     */
45    public function __construct(\cm_info $cm) {
46        parent::__construct($cm->get_course(), $cm->visible, $cm->availability);
47        $this->cm = $cm;
48    }
49
50    protected function get_thing_name() {
51        // We cannot access $cm->name as a property at this point, because this
52        // code may itself run in response to the $cm->name property access, and
53        // PHP magic function properties do not allow recursion (because PHP).
54        return '<AVAILABILITY_CMNAME_' . $this->cm->id . '/>';
55    }
56
57    protected function set_in_database($availability) {
58        global $DB;
59        $DB->set_field('course_modules', 'availability', $availability,
60                array('id' => $this->cm->id));
61    }
62
63    /**
64     * Gets the course-module object. Intended for use by conditions.
65     *
66     * @return \cm_info Course module
67     */
68    public function get_course_module() {
69        return $this->cm;
70    }
71
72    public function get_context() {
73        return \context_module::instance($this->cm->id);
74    }
75
76    /**
77     * Tests against a user list. Users who cannot access the activity due to
78     * availability restrictions will be removed from the list.
79     *
80     * Note this only includes availability restrictions (those handled within
81     * this API) and not other ways of restricting access.
82     *
83     * This test ONLY includes conditions which are marked as being applied to
84     * user lists. For example, group conditions are included but date
85     * conditions are not included.
86     *
87     * When called on a module, this test DOES also include restrictions on the
88     * section (if any).
89     *
90     * The function operates reasonably efficiently i.e. should not do per-user
91     * database queries. It is however likely to be fairly slow.
92     *
93     * @param array $users Array of userid => object
94     * @return array Filtered version of input array
95     */
96    public function filter_user_list(array $users) {
97        global $CFG;
98        if (!$CFG->enableavailability) {
99            return $users;
100        }
101
102        // Apply section filtering first.
103        $section = $this->cm->get_modinfo()->get_section_info(
104                $this->cm->sectionnum, MUST_EXIST);
105        $sectioninfo = new info_section($section);
106        $filtered = $sectioninfo->filter_user_list($users);
107
108        // Now do base class (module) filtering on top.
109        return parent::filter_user_list($filtered);
110    }
111
112    protected function get_view_hidden_capability() {
113        return 'moodle/course:ignoreavailabilityrestrictions';
114    }
115
116    public function get_user_list_sql($onlyactive = true) {
117        global $CFG, $DB;
118        if (!$CFG->enableavailability) {
119            return array('', array());
120        }
121
122        // Get query for section (if any) and module.
123        $section = $this->cm->get_modinfo()->get_section_info(
124                $this->cm->sectionnum, MUST_EXIST);
125        $sectioninfo = new info_section($section);
126        $sectionresult = $sectioninfo->get_user_list_sql($onlyactive);
127        $moduleresult = parent::get_user_list_sql($onlyactive);
128
129        if (!$sectionresult[0]) {
130            return $moduleresult;
131        }
132        if (!$moduleresult[0]) {
133            return $sectionresult;
134        }
135
136        return array($DB->sql_intersect(array($sectionresult[0], $moduleresult[0]), 'id'),
137                array_merge($sectionresult[1], $moduleresult[1]));
138    }
139
140    /**
141     * Checks if an activity is visible to the given user.
142     *
143     * Unlike other checks in the availability system, this check includes the
144     * $cm->visible flag. It is equivalent to $cm->uservisible.
145     *
146     * If you have already checked (or do not care whether) the user has access
147     * to the course, you can set $checkcourse to false to save it checking
148     * course access.
149     *
150     * When checking for the current user, you should generally not call
151     * this function. Instead, use get_fast_modinfo to get a cm_info object,
152     * then simply check the $cm->uservisible flag. This function is intended
153     * to obtain that information for a separate course-module object that
154     * wasn't loaded with get_fast_modinfo, or for a different user.
155     *
156     * This function has a performance cost unless the availability system is
157     * disabled, and you supply a $cm object with necessary fields, and you
158     * don't check course access.
159     *
160     * @param int|\stdClass|\cm_info $cmorid Object or id representing activity
161     * @param int $userid User id (0 = current user)
162     * @param bool $checkcourse If true, checks whether the user has course access
163     * @return bool True if the activity is visible to the specified user
164     * @throws \moodle_exception If the cmid doesn't exist
165     */
166    public static function is_user_visible($cmorid, $userid = 0, $checkcourse = true) {
167        global $USER, $DB, $CFG;
168
169        // Evaluate user id.
170        if (!$userid) {
171            $userid = $USER->id;
172        }
173
174        // If this happens to be already called with a cm_info for the right user
175        // then just return uservisible.
176        if (($cmorid instanceof \cm_info) && $cmorid->get_modinfo()->userid == $userid) {
177            return $cmorid->uservisible;
178        }
179
180        // If the $cmorid isn't an object or doesn't have required fields, load it.
181        if (is_object($cmorid) && isset($cmorid->course) && isset($cmorid->visible)) {
182            $cm = $cmorid;
183        } else {
184            if (is_object($cmorid)) {
185                $cmorid = $cmorid->id;
186            }
187            $cm = $DB->get_record('course_modules', array('id' => $cmorid));
188            if (!$cm) {
189                // In some error cases, the course module may not exist.
190                debugging('info_module::is_user_visible called with invalid cmid ' . $cmorid, DEBUG_DEVELOPER);
191                return false;
192            }
193        }
194
195        // If requested, check user can access the course.
196        if ($checkcourse) {
197            $coursecontext = \context_course::instance($cm->course);
198            if (!is_enrolled($coursecontext, $userid, '', true) &&
199                    !has_capability('moodle/course:view', $coursecontext, $userid)) {
200                return false;
201            }
202        }
203
204        // If availability is disabled, then all we need to do is check the visible flag.
205        if (!$CFG->enableavailability && $cm->visible) {
206            return true;
207        }
208
209        // When availability is enabled, access can depend on 3 things:
210        // 1. $cm->visible
211        // 2. $cm->availability
212        // 3. $section->availability (for activity section and possibly for
213        //    parent sections)
214        // As a result we cannot take short cuts any longer and must get
215        // standard modinfo.
216        $modinfo = get_fast_modinfo($cm->course, $userid);
217        $cms = $modinfo->get_cms();
218        if (!isset($cms[$cm->id])) {
219            // In some cases this might get called with a cmid that is no longer
220            // available, for example when a module is hidden at system level.
221            debugging('info_module::is_user_visible called with invalid cmid ' . $cm->id, DEBUG_DEVELOPER);
222            return false;
223        }
224        return $cms[$cm->id]->uservisible;
225    }
226}
227