Merge branch 'MDL-38766/MOODLE_23_STABLE' of github.com:kemitix/moodle into MOODLE_23...
[moodle.git] / backup / util / ui / restore_ui_components.php
1 <?php
3 // This file is part of Moodle - http://moodle.org/
4 //
5 // Moodle is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // Moodle is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
18 /**
19  * This file contains components used by the restore UI
20  *
21  * @package   moodlecore
22  * @copyright 2010 Sam Hemelryk
23  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24  */
26 /**
27  * A base class that can be used to build a specific search upon
28  */
29 abstract class restore_search_base implements renderable {
31     /**
32      * The default values for this components params
33      */
34     const DEFAULT_SEARCH = '';
36     /**
37      * The param used to convey the current search string
38      * @var string
39      */
40     static $VAR_SEARCH = 'search';
42     static $MAXRESULTS = 10;
43     /**
44      * The current search string
45      * @var string|null
46      */
47     private $search = null;
48     /**
49      * The URL for this page including required params to return to it
50      * @var moodle_url
51      */
52     private $url = null;
53     /**
54      * The results of the search
55      * @var array|null
56      */
57     private $results = null;
58     /**
59      * The total number of results available
60      * @var int
61      */
62     private $totalcount = null;
63     /**
64      * Array of capabilities required for each item in the search
65      * @var array
66      */
67     private $requiredcapabilities = array();
68     /**
69      * Indicates if we have more than maxresults found.
70      * @var boolean
71      */
72     private $hasmoreresults = false;
74     /**
75      * Constructor
76      * @param array $config Config options
77      */
78     public function __construct(array $config=array()) {
80         $this->search = optional_param($this->get_varsearch(), self::DEFAULT_SEARCH, PARAM_NOTAGS);
82         foreach ($config as $name=>$value) {
83             $method = 'set_'.$name;
84             if (method_exists($this, $method)) {
85                 $this->$method($value);
86             }
87         }
88     }
89     /**
90      * The URL for this search
91      * @global moodle_page $PAGE
92      * @return moodle_url The URL for this page
93      */
94     final public function get_url() {
95         global $PAGE;
96         $params = array(
97             $this->get_varsearch()    => $this->get_search()
98         );
99         return ($this->url !== null)?new moodle_url($this->url, $params):new moodle_url($PAGE->url, $params);
100     }
101     /**
102      * The current search string
103      * @return string
104      */
105     final public function get_search() {
106         return ($this->search !== null)?$this->search:self::DEFAULT_SEARCH;
107     }
108     /**
109      * The total number of results
110      * @return int
111      */
112     final public function get_count() {
113         if ($this->totalcount === null) {
114             $this->search();
115         }
116         return $this->totalcount;
117     }
118     /**
119      * Returns an array of results from the search
120      * @return array
121      */
122     final public function get_results() {
123         if ($this->results === null) {
124             $this->search();
125         }
126         return $this->results;
127     }
128     /**
129      * Sets the page URL
130      * @param moodle_url $url
131      */
132     final public function set_url(moodle_url $url) {
133         $this->url = $url;
134     }
135     /**
136      * Invalidates the results collected so far
137      */
138     final public function invalidate_results() {
139         $this->results = null;
140         $this->totalcount = null;
141     }
142     /**
143      * Adds a required capability which all results will be checked against
144      * @param string $capability
145      * @param int|null $user
146      */
147     final public function require_capability($capability, $user=null) {
148         if (!is_int($user)) {
149             $user = null;
150         }
151         $this->requiredcapabilities[] = array(
152             'capability' => $capability,
153             'user' => $user
154         );
155     }
156     /**
157      * Executes the search
158      *
159      * @global moodle_database $DB
160      * @return int The number of results
161      */
162     final public function search() {
163         global $DB;
164         if (!is_null($this->results)) {
165             return $this->results;
166         }
168         $this->results = array();
169         $this->totalcount = 0;
170         $contextlevel = $this->get_itemcontextlevel();
171         list($sql, $params) = $this->get_searchsql();
172         $blocksz = 5000;
173         $offs = 0;
174         // Get total number, to avoid some incorrect iterations
175         $countsql = preg_replace('/ORDER BY.*/', '', $sql);
176         $totalcourses = $DB->count_records_sql("SELECT COUNT(*) FROM ($countsql) sel", $params);
177         // User to be checked is always the same (usually null, get it form first element)
178         $firstcap = reset($this->requiredcapabilities);
179         $userid = isset($firstcap['user']) ? $firstcap['user'] : null;
180         // Extract caps to check, this saves us a bunch of iterations
181         $requiredcaps = array();
182         foreach ($this->requiredcapabilities as $cap) {
183             $requiredcaps[] = $cap['capability'];
184         }
185         // Iterate while we have records and haven't reached $this->maxresults.
186         while ($totalcourses > $offs and $this->totalcount < self::$MAXRESULTS) {
187             $resultset = $DB->get_records_sql($sql, $params, $offs, $blocksz);
188             foreach ($resultset as $result) {
189                 context_instance_preload($result);
190                 $context = get_context_instance($contextlevel, $result->id);
191                 if (count($requiredcaps) > 0) {
192                     if (!has_all_capabilities($requiredcaps, $context, $userid)) {
193                         continue;
194                     }
195                 }
196                 // Check if we are over the limit.
197                 if ($this->totalcount+1 > self::$MAXRESULTS) {
198                     $this->hasmoreresults = true;
199                     break;
200                 }
201                 // If not, then continue.
202                 $this->totalcount++;
203                 $this->results[$result->id] = $result;
204             }
205             $offs += $blocksz;
206         }
208         return $this->totalcount;
209     }
211     final public function has_more_results() {
212         if ($this->results === null) {
213             $this->search();
214         }
215         return $this->hasmoreresults;
216     }
218     /**
219      * Returns an array containing the SQL for the search and the params
220      * @return array
221      */
222     abstract protected function get_searchsql();
223     /**
224      * Gets the context level associated with this components items
225      * @return CONTEXT_*
226      */
227     abstract protected function get_itemcontextlevel();
228     /**
229      * Formats the results
230      */
231     abstract protected function format_results();
232     /**
233      * Gets the string used to transfer the search string for this compontents requests
234      * @return string
235      */
236     abstract public function get_varsearch();
239 /**
240  * A course search component
241  */
242 class restore_course_search extends restore_search_base {
244     static $VAR_SEARCH = 'search';
246     protected $currentcourseid = null;
247     protected $includecurrentcourse;
249     /**
250      * @param array $config
251      * @param int $currentcouseid The current course id so it can be ignored
252      */
253     public function __construct(array $config=array(), $currentcouseid = null) {
254         parent::__construct($config);
255         $this->setup_restrictions();
256         $this->currentcourseid = $currentcouseid;
257         $this->includecurrentcourse = false;
258     }
259     /**
260      * Sets up any access restrictions for the courses to be displayed in the search.
261      *
262      * This will typically call $this->require_capability().
263      */
264     protected function setup_restrictions() {
265         $this->require_capability('moodle/restore:restorecourse');
266     }
267     /**
268      *
269      * @global moodle_database $DB
270      */
271     protected function get_searchsql() {
272         global $DB;
274         list($ctxselect, $ctxjoin) = context_instance_preload_sql('c.id', CONTEXT_COURSE, 'ctx');
275         $params = array(
276             'fullnamesearch' => '%'.$this->get_search().'%',
277             'shortnamesearch' => '%'.$this->get_search().'%',
278             'siteid' => SITEID
279         );
281         $select     = " SELECT c.id,c.fullname,c.shortname,c.visible,c.sortorder ";
282         $from       = " FROM {course} c ";
283         $where      = " WHERE (".$DB->sql_like('c.fullname', ':fullnamesearch', false)." OR ".$DB->sql_like('c.shortname', ':shortnamesearch', false).") AND c.id <> :siteid";
284         $orderby    = " ORDER BY c.sortorder";
286         if ($this->currentcourseid !== null && !$this->includecurrentcourse) {
287             $where .= " AND c.id <> :currentcourseid";
288             $params['currentcourseid'] = $this->currentcourseid;
289         }
291         return array($select.$ctxselect.$from.$ctxjoin.$where.$orderby, $params);
292     }
293     protected function get_itemcontextlevel() {
294         return CONTEXT_COURSE;
295     }
296     protected function format_results() {}
297     public function get_varsearch() {
298         return self::$VAR_SEARCH;
299     }
300     public function set_include_currentcourse() {
301         $this->includecurrentcourse = true;
302     }
305 /**
306  * A category search component
307  */
308 class restore_category_search extends restore_search_base  {
310     static $VAR_SEARCH = 'catsearch';
312     public function __construct(array $config=array()) {
313         parent::__construct($config);
314         $this->require_capability('moodle/course:create');
315     }
316     /**
317      *
318      * @global moodle_database $DB
319      */
320     protected function get_searchsql() {
321         global $DB;
323         list($ctxselect, $ctxjoin) = context_instance_preload_sql('c.id', CONTEXT_COURSECAT, 'ctx');
324         $params = array(
325             'namesearch' => '%'.$this->get_search().'%',
326         );
328         $select     = " SELECT c.id,c.name,c.visible,c.sortorder,c.description,c.descriptionformat ";
329         $from       = " FROM {course_categories} c ";
330         $where      = " WHERE ".$DB->sql_like('c.name', ':namesearch', false);
331         $orderby    = " ORDER BY c.sortorder";
333         return array($select.$ctxselect.$from.$ctxjoin.$where.$orderby, $params);
334     }
335     protected function get_itemcontextlevel() {
336         return CONTEXT_COURSECAT;
337     }
338     protected function format_results() {}
339     public function get_varsearch() {
340         return self::$VAR_SEARCH;
341     }