7ebaea8fadc0727fc32962805ee7fa88bd2d63f9
[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();
69     /**
70      * Constructor
71      * @param array $config Config options
72      */
73     public function __construct(array $config=array()) {
75         $this->search = optional_param($this->get_varsearch(), self::DEFAULT_SEARCH, PARAM_NOTAGS);
77         foreach ($config as $name=>$value) {
78             $method = 'set_'.$name;
79             if (method_exists($this, $method)) {
80                 $this->$method($value);
81             }
82         }
83     }
84     /**
85      * The URL for this search
86      * @global moodle_page $PAGE
87      * @return moodle_url The URL for this page
88      */
89     final public function get_url() {
90         global $PAGE;
91         $params = array(
92             $this->get_varsearch()    => $this->get_search()
93         );
94         return ($this->url !== null)?new moodle_url($this->url, $params):new moodle_url($PAGE->url, $params);
95     }
96     /**
97      * The current search string
98      * @return string
99      */
100     final public function get_search() {
101         return ($this->search !== null)?$this->search:self::DEFAULT_SEARCH;
102     }
103     /**
104      * The total number of results
105      * @return int
106      */
107     final public function get_count() {
108         if ($this->totalcount === null) {
109             $this->search();
110         }
111         return $this->totalcount;
112     }
113     /**
114      * Returns an array of results from the search
115      * @return array
116      */
117     final public function get_results() {
118         if ($this->results === null) {
119             $this->search();
120         }
121         return $this->results;
122     }
123     /**
124      * Sets the page URL
125      * @param moodle_url $url
126      */
127     final public function set_url(moodle_url $url) {
128         $this->url = $url;
129     }
130     /**
131      * Invalidates the results collected so far
132      */
133     final public function invalidate_results() {
134         $this->results = null;
135         $this->totalcount = null;
136     }
137     /**
138      * Adds a required capability which all results will be checked against
139      * @param string $capability
140      * @param int|null $user
141      */
142     final public function require_capability($capability, $user=null) {
143         if (!is_int($user)) {
144             $user = null;
145         }
146         $this->requiredcapabilities[] = array(
147             'capability' => $capability,
148             'user' => $user
149         );
150     }
151     /**
152      * Executes the search
153      *
154      * @global moodle_database $DB
155      * @return int The number of results
156      */
157     final public function search() {
158         global $DB;
159         if (!is_null($this->results)) {
160             return $this->results;
161         }
163         $this->results = array();
164         $this->totalcount = 0;
165         $contextlevel = $this->get_itemcontextlevel();
166         list($sql, $params) = $this->get_searchsql();
167         $blocksz = 5000;
168         $offs = 0;
169         // Get total number, to avoid some incorrect iterations
170         $countsql = preg_replace('/ORDER BY.*/', '', $sql);
171         $totalcourses = $DB->count_records_sql("SELECT COUNT(*) FROM ($countsql) sel", $params);
172         // User to be checked is always the same (usually null, get it form first element)
173         $firstcap = reset($this->requiredcapabilities);
174         $userid = isset($firstcap['user']) ? $firstcap['user'] : null;
175         // Extract caps to check, this saves us a bunch of iterations
176         $requiredcaps = array();
177         foreach ($this->requiredcapabilities as $cap) {
178             $requiredcaps[] = $cap['capability'];
179         }
180         // Iterate while we have records and haven't reached MAXRESULTS
181         while ($totalcourses > $offs and $this->totalcount < self::$MAXRESULTS) {
182             $resultset = $DB->get_records_sql($sql, $params, $offs, $blocksz);
183             foreach ($resultset as $result) {
184                 context_instance_preload($result);
185                 $classname = context_helper::get_class_for_level($contextlevel);
186                 $context = $classname::instance($result->id);
187                 if (count($requiredcaps) > 0) {
188                     if (!has_all_capabilities($requiredcaps, $context, $userid)) {
189                         continue;
190                     }
191                 }
192                 $this->results[$result->id] = $result;
193                 $this->totalcount++;
194                 if ($this->totalcount >= self::$MAXRESULTS) {
195                     break;
196                 }
197             }
198             $offs += $blocksz;
199         }
201         return $this->totalcount;
202     }
204     final public function has_more_results() {
205         return $this->get_count() >= self::$MAXRESULTS;
206     }
208     /**
209      * Returns an array containing the SQL for the search and the params
210      * @return array
211      */
212     abstract protected function get_searchsql();
213     /**
214      * Gets the context level associated with this components items
215      * @return CONTEXT_*
216      */
217     abstract protected function get_itemcontextlevel();
218     /**
219      * Formats the results
220      */
221     abstract protected function format_results();
222     /**
223      * Gets the string used to transfer the search string for this compontents requests
224      * @return string
225      */
226     abstract public function get_varsearch();
229 /**
230  * A course search component
231  */
232 class restore_course_search extends restore_search_base {
234     static $VAR_SEARCH = 'search';
236     protected $currentcourseid = null;
237     protected $includecurrentcourse;
239     /**
240      * @param array $config
241      * @param int $currentcouseid The current course id so it can be ignored
242      */
243     public function __construct(array $config=array(), $currentcouseid = null) {
244         parent::__construct($config);
245         $this->setup_restrictions();
246         $this->currentcourseid = $currentcouseid;
247         $this->includecurrentcourse = false;
248     }
249     /**
250      * Sets up any access restrictions for the courses to be displayed in the search.
251      *
252      * This will typically call $this->require_capability().
253      */
254     protected function setup_restrictions() {
255         $this->require_capability('moodle/restore:restorecourse');
256     }
257     /**
258      *
259      * @global moodle_database $DB
260      */
261     protected function get_searchsql() {
262         global $DB;
264         list($ctxselect, $ctxjoin) = context_instance_preload_sql('c.id', CONTEXT_COURSE, 'ctx');
265         $params = array(
266             'fullnamesearch' => '%'.$this->get_search().'%',
267             'shortnamesearch' => '%'.$this->get_search().'%',
268             'siteid' => SITEID
269         );
271         $select     = " SELECT c.id,c.fullname,c.shortname,c.visible,c.sortorder ";
272         $from       = " FROM {course} c ";
273         $where      = " WHERE (".$DB->sql_like('c.fullname', ':fullnamesearch', false)." OR ".$DB->sql_like('c.shortname', ':shortnamesearch', false).") AND c.id <> :siteid";
274         $orderby    = " ORDER BY c.sortorder";
276         if ($this->currentcourseid !== null && !$this->includecurrentcourse) {
277             $where .= " AND c.id <> :currentcourseid";
278             $params['currentcourseid'] = $this->currentcourseid;
279         }
281         return array($select.$ctxselect.$from.$ctxjoin.$where.$orderby, $params);
282     }
283     protected function get_itemcontextlevel() {
284         return CONTEXT_COURSE;
285     }
286     protected function format_results() {}
287     public function get_varsearch() {
288         return self::$VAR_SEARCH;
289     }
290     public function set_include_currentcourse() {
291         $this->includecurrentcourse = true;
292     }
295 /**
296  * A category search component
297  */
298 class restore_category_search extends restore_search_base  {
300     static $VAR_SEARCH = 'catsearch';
302     public function __construct(array $config=array()) {
303         parent::__construct($config);
304         $this->require_capability('moodle/course:create');
305     }
306     /**
307      *
308      * @global moodle_database $DB
309      */
310     protected function get_searchsql() {
311         global $DB;
313         list($ctxselect, $ctxjoin) = context_instance_preload_sql('c.id', CONTEXT_COURSECAT, 'ctx');
314         $params = array(
315             'namesearch' => '%'.$this->get_search().'%',
316         );
318         $select     = " SELECT c.id,c.name,c.visible,c.sortorder,c.description,c.descriptionformat ";
319         $from       = " FROM {course_categories} c ";
320         $where      = " WHERE ".$DB->sql_like('c.name', ':namesearch', false);
321         $orderby    = " ORDER BY c.sortorder";
323         return array($select.$ctxselect.$from.$ctxjoin.$where.$orderby, $params);
324     }
325     protected function get_itemcontextlevel() {
326         return CONTEXT_COURSECAT;
327     }
328     protected function format_results() {}
329     public function get_varsearch() {
330         return self::$VAR_SEARCH;
331     }