121a113c1bbcda34e27712017e8727d137b435e2
[moodle.git] / calendar / classes / local / event / data_access / event_vault.php
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/>.
17 /**
18  * Event vault class
19  *
20  * @package    core_calendar
21  * @copyright  2017 Ryan Wyllie <ryan@moodle.com>
22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
25 namespace core_calendar\local\event\data_access;
27 defined('MOODLE_INTERNAL') || die();
29 use core_calendar\local\event\entities\action_event_interface;
30 use core_calendar\local\event\entities\event_interface;
31 use core_calendar\local\event\exceptions\limit_invalid_parameter_exception;
32 use core_calendar\local\event\factories\action_factory_interface;
33 use core_calendar\local\event\factories\event_factory_interface;
34 use core_calendar\local\event\strategies\raw_event_retrieval_strategy_interface;
36 /**
37  * Event vault class.
38  *
39  * This class will handle interacting with the database layer to retrieve
40  * the records. This is required to house the complex logic required for
41  * pagination because it's not a one-to-one mapping between database records
42  * and users.
43  *
44  * This is a repository. It's called a vault to reduce confusion because
45  * Moodle has already taken the name repository. Vault is cooler anyway.
46  *
47  * @copyright 2017 Ryan Wyllie <ryan@moodle.com>
48  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
49  */
50 class event_vault implements event_vault_interface {
52     /**
53      * @var event_factory_interface $factory Factory for creating events.
54      */
55     protected $factory;
57     /**
58      * @var raw_event_retrieval_strategy_interface $retrievalstrategy Strategy for getting events from the DB.
59      */
60     protected $retrievalstrategy;
62     /**
63      * Create an event vault.
64      *
65      * @param event_factory_interface $factory An event factory
66      * @param raw_event_retrieval_strategy_interface $retrievalstrategy
67      */
68     public function __construct(
69         event_factory_interface $factory,
70         raw_event_retrieval_strategy_interface $retrievalstrategy
71     ) {
72         $this->factory = $factory;
73         $this->retrievalstrategy = $retrievalstrategy;
74     }
76     public function get_event_by_id($id) {
77         global $DB;
79         if ($record = $DB->get_record('event', ['id' => $id])) {
80             return $this->transform_from_database_record($record);
81         } else {
82             return false;
83         }
84     }
86     public function get_events(
87         $timestartfrom = null,
88         $timestartto = null,
89         $timesortfrom = null,
90         $timesortto = null,
91         event_interface $timestartafterevent = null,
92         event_interface $timesortafterevent = null,
93         $limitnum = 20,
94         $type = null,
95         array $usersfilter = null,
96         array $groupsfilter = null,
97         array $coursesfilter = null,
98         array $categoriesfilter = null,
99         $withduration = true,
100         $ignorehidden = true,
101         callable $filter = null
102     ) {
103         if ($limitnum < 1 || $limitnum > 200) {
104             throw new limit_invalid_parameter_exception("Limit must be between 1 and 200 (inclusive)");
105         }
107         $fromquery = function($field, $timefrom, $lastseenmethod, $afterevent, $withduration) {
108             if (!$timefrom) {
109                 return false;
110             }
112             return $this->timefield_pagination_from(
113                 $field,
114                 $timefrom,
115                 $afterevent ? $afterevent->get_times()->{$lastseenmethod}()->getTimestamp() : null,
116                 $afterevent ? $afterevent->get_id() : null,
117                 $withduration
118             );
119         };
121         $toquery = function($field, $timeto, $lastseenmethod, $afterevent) {
122             if (!$timeto) {
123                 return false;
124             }
126             return $this->timefield_pagination_to(
127                 $field,
128                 $timeto,
129                 $afterevent ? $afterevent->get_times()->{$lastseenmethod}()->getTimestamp() : null,
130                 $afterevent ? $afterevent->get_id() : null
131             );
132         };
134         $timesortfromquery = $fromquery('timesort', $timesortfrom, 'get_sort_time', $timesortafterevent, $withduration);
135         $timesorttoquery = $toquery('timesort', $timesortto, 'get_sort_time', $timesortafterevent);
136         $timestartfromquery = $fromquery('timestart', $timestartfrom, 'get_start_time', $timestartafterevent, $withduration);
137         $timestarttoquery = $toquery('timestart', $timestartto, 'get_start_time', $timestartafterevent);
139         if (($timesortto && !$timesorttoquery) || ($timestartto && !$timestarttoquery)) {
140             return [];
141         }
143         $params = array_merge(
144             $type ? ['type' => $type] : [],
145             $timesortfromquery ? $timesortfromquery['params'] : [],
146             $timesorttoquery ? $timesorttoquery['params'] : [],
147             $timestartfromquery ? $timestartfromquery['params'] : [],
148             $timestarttoquery ? $timestarttoquery['params'] : []
149         );
151         $where = array_merge(
152             $type ? ['type = :type'] : [],
153             $timesortfromquery ? $timesortfromquery['where'] : [],
154             $timesorttoquery ? $timesorttoquery['where'] : [],
155             $timestartfromquery ? $timestartfromquery['where'] : [],
156             $timestarttoquery ? $timestarttoquery['where'] : []
157         );
159         $offset = 0;
160         $events = [];
162         while ($records = array_values($this->retrievalstrategy->get_raw_events(
163             $usersfilter,
164             $groupsfilter,
165             $coursesfilter,
166             $categoriesfilter,
167             $where,
168             $params,
169             "COALESCE(e.timesort, e.timestart) ASC, e.id ASC",
170             $offset,
171             $limitnum,
172             $ignorehidden
173         ))) {
174             foreach ($records as $record) {
175                 if ($event = $this->transform_from_database_record($record)) {
176                     $filtertest = $filter ? $filter($event) : true;
178                     if ($event && $filtertest) {
179                         $events[] = $event;
180                     }
182                     if (count($events) == $limitnum) {
183                         // We've got all of the events so break both loops.
184                         break 2;
185                     }
186                 }
187             }
189             $offset += $limitnum;
190         }
192         return $events;
193     }
195     public function get_action_events_by_timesort(
196         \stdClass $user,
197         $timesortfrom = null,
198         $timesortto = null,
199         event_interface $afterevent = null,
200         $limitnum = 20
201     ) {
202         $courseids = array_map(function($course) {
203             return $course->id;
204         }, enrol_get_all_users_courses($user->id));
206         $groupids = array_reduce($courseids, function($carry, $courseid) use ($user) {
207             $groupings = groups_get_user_groups($courseid, $user->id);
208             // Grouping 0 is all groups.
209             return array_merge($carry, $groupings[0]);
210         }, []);
212         return $this->get_events(
213             null,
214             null,
215             $timesortfrom,
216             $timesortto,
217             null,
218             $afterevent,
219             $limitnum,
220             CALENDAR_EVENT_TYPE_ACTION,
221             [$user->id],
222             $groupids ? $groupids : null,
223             $courseids ? $courseids : null,
224             null, // All categories.
225             true,
226             true,
227             function ($event) {
228                 return $event instanceof action_event_interface;
229             }
230         );
231     }
233     public function get_action_events_by_course(
234         \stdClass $user,
235         \stdClass $course,
236         $timesortfrom = null,
237         $timesortto = null,
238         event_interface $afterevent = null,
239         $limitnum = 20
240     ) {
241         $groupings = groups_get_user_groups($course->id, $user->id);
242         return array_values(
243             $this->get_events(
244                 null,
245                 null,
246                 $timesortfrom,
247                 $timesortto,
248                 null,
249                 $afterevent,
250                 $limitnum,
251                 CALENDAR_EVENT_TYPE_ACTION,
252                 [$user->id],
253                 $groupings[0] ? $groupings[0] : null,
254                 [$course->id],
255                 [],
256                 true,
257                 true,
258                 function ($event) use ($course) {
259                     return $event instanceof action_event_interface && $event->get_course()->get('id') == $course->id;
260                 }
261             )
262         );
263     }
265     /**
266      * Generates SQL subquery and parameters for 'from' pagination.
267      *
268      * @param string    $field
269      * @param int       $timefrom
270      * @param int|null  $lastseentime
271      * @param int|null  $lastseenid
272      * @param bool      $withduration
273      * @return array
274      */
275     protected function timefield_pagination_from(
276         $field,
277         $timefrom,
278         $lastseentime = null,
279         $lastseenid = null,
280         $withduration = true
281     ) {
282         $where = '';
283         $params = [];
285         if ($lastseentime && $lastseentime >= $timefrom) {
286             $where = '((timesort = :timefrom1 AND e.id > :timefromid) OR timesort > :timefrom2)';
287             if ($field === 'timestart') {
288                 $where = '((timestart = :timefrom1 AND e.id > :timefromid) OR timestart > :timefrom2' .
289                        ($withduration ? ' OR timestart + timeduration > :timefrom3' : '') . ')';
290             }
291             $params['timefromid'] = $lastseenid;
292             $params['timefrom1'] = $lastseentime;
293             $params['timefrom2'] = $lastseentime;
294             $params['timefrom3'] = $lastseentime;
295         } else {
296             $where = 'timesort >= :timefrom';
297             if ($field === 'timestart') {
298                 $where = '(timestart >= :timefrom' .
299                        ($withduration ? ' OR timestart + timeduration > :timefrom2' : '') . ')';
300             }
302             $params['timefrom'] = $timefrom;
303             $params['timefrom2'] = $timefrom;
304         }
306         return ['where' => [$where], 'params' => $params];
307     }
309     /**
310      * Generates SQL subquery and parameters for 'to' pagination.
311      *
312      * @param string   $field
313      * @param int      $timeto
314      * @param int|null $lastseentime
315      * @param int|null $lastseenid
316      * @return array|bool
317      */
318     protected function timefield_pagination_to(
319         $field,
320         $timeto,
321         $lastseentime = null,
322         $lastseenid = null
323     ) {
324         $where = [];
325         $params = [];
327         if ($lastseentime && $lastseentime > $timeto) {
328             // The last seen event from this set is after the time sort range which
329             // means all events in this range have been seen, so we can just return
330             // early here.
331             return false;
332         } else if ($lastseentime && $lastseentime == $timeto) {
333             $where[] = '((timesort = :timeto1 AND e.id > :timetoid) OR timesort < :timeto2)';
334             if ($field === 'timestart') {
335                 $where[] = '((timestart = :timeto1 AND e.id > :timetoid) OR timestart < :timeto2)';
336             }
337             $params['timetoid'] = $lastseenid;
338             $params['timeto1'] = $timeto;
339             $params['timeto2'] = $timeto;
340         } else {
341             $where[] = ($field === 'timestart' ? 'timestart' : 'timesort') . ' <= :timeto';
342             $params['timeto'] = $timeto;
343         }
345         return ['where' => $where, 'params' => $params];
346     }
348     /**
349      * Create an event from a database record.
350      *
351      * @param \stdClass $record The database record
352      * @return event_interface|null
353      */
354     protected function transform_from_database_record(\stdClass $record) {
355         return $this->factory->create_instance($record);
356     }
358     /**
359      * Fetches records from DB.
360      *
361      * @param int    $userid
362      * @param string $whereconditions
363      * @param array  $whereparams
364      * @param string $ordersql
365      * @param int    $offset
366      * @param int    $limitnum
367      * @return array
368      */
369     protected function get_from_db(
370         $userid,
371         $whereconditions,
372         $whereparams,
373         $ordersql,
374         $offset,
375         $limitnum
376     ) {
377         return array_values(
378             $this->retrievalstrategy->get_raw_events(
379                 [$userid],
380                 null,
381                 null,
382                 null,
383                 $whereconditions,
384                 $whereparams,
385                 $ordersql,
386                 $offset,
387                 $limitnum
388             )
389         );
390     }