Merge branch 'MDL-36494-invalid-update-debugging' of git://github.com/mudrd8mz/moodle
[moodle.git] / lib / statslib.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  * @package    core
20  * @subpackage stats
21  * @copyright  1999 onwards Martin Dougiamas  {@link http://moodle.com}
22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
25 defined('MOODLE_INTERNAL') || die();
27 /** THESE CONSTANTS ARE USED FOR THE REPORTING PAGE. */
29 define('STATS_REPORT_LOGINS',1); // double impose logins and unique logins on a line graph. site course only.
30 define('STATS_REPORT_READS',2); // double impose student reads and teacher reads on a line graph.
31 define('STATS_REPORT_WRITES',3); // double impose student writes and teacher writes on a line graph.
32 define('STATS_REPORT_ACTIVITY',4); // 2+3 added up, teacher vs student.
33 define('STATS_REPORT_ACTIVITYBYROLE',5); // all activity, reads vs writes, selected by role.
35 // user level stats reports.
36 define('STATS_REPORT_USER_ACTIVITY',7);
37 define('STATS_REPORT_USER_ALLACTIVITY',8);
38 define('STATS_REPORT_USER_LOGINS',9);
39 define('STATS_REPORT_USER_VIEW',10);  // this is the report you see on the user profile.
41 // admin only ranking stats reports
42 define('STATS_REPORT_ACTIVE_COURSES',11);
43 define('STATS_REPORT_ACTIVE_COURSES_WEIGHTED',12);
44 define('STATS_REPORT_PARTICIPATORY_COURSES',13);
45 define('STATS_REPORT_PARTICIPATORY_COURSES_RW',14);
47 // start after 0 = show dailies.
48 define('STATS_TIME_LASTWEEK',1);
49 define('STATS_TIME_LAST2WEEKS',2);
50 define('STATS_TIME_LAST3WEEKS',3);
51 define('STATS_TIME_LAST4WEEKS',4);
53 // start after 10 = show weeklies
54 define('STATS_TIME_LAST2MONTHS',12);
56 define('STATS_TIME_LAST3MONTHS',13);
57 define('STATS_TIME_LAST4MONTHS',14);
58 define('STATS_TIME_LAST5MONTHS',15);
59 define('STATS_TIME_LAST6MONTHS',16);
61 // start after 20 = show monthlies
62 define('STATS_TIME_LAST7MONTHS',27);
63 define('STATS_TIME_LAST8MONTHS',28);
64 define('STATS_TIME_LAST9MONTHS',29);
65 define('STATS_TIME_LAST10MONTHS',30);
66 define('STATS_TIME_LAST11MONTHS',31);
67 define('STATS_TIME_LASTYEAR',32);
69 // different modes for what reports to offer
70 define('STATS_MODE_GENERAL',1);
71 define('STATS_MODE_DETAILED',2);
72 define('STATS_MODE_RANKED',3); // admins only - ranks courses
74 // Output string when nodebug is on
75 define('STATS_PLACEHOLDER_OUTPUT', '.');
77 /**
78  * Print daily cron progress
79  * @param string $ident
80  */
81 function stats_progress($ident) {
82     static $start = 0;
83     static $init  = 0;
85     if ($ident == 'init') {
86         $init = $start = microtime(true);
87         return;
88     }
90     $elapsed = round(microtime(true) - $start);
91     $start   = microtime(true);
93     if (debugging('', DEBUG_ALL)) {
94         mtrace("$ident:$elapsed ", '');
95     } else {
96         mtrace(STATS_PLACEHOLDER_OUTPUT, '');
97     }
98 }
100 /**
101  * Execute individual daily statistics queries
102  *
103  * @param string $sql The query to run
104  * @return boolean success
105  */
106 function stats_run_query($sql, $parameters = array()) {
107     global $DB;
109     try {
110         $DB->execute($sql, $parameters);
111     } catch (dml_exception $e) {
113        if (debugging('', DEBUG_ALL)) {
114            mtrace($e->getMessage());
115        }
116        return false;
117     }
118     return true;
121 /**
122  * Execute daily statistics gathering
123  *
124  * @param int $maxdays maximum number of days to be processed
125  * @return boolean success
126  */
127 function stats_cron_daily($maxdays=1) {
128     global $CFG, $DB;
130     $now = time();
132     $fpcontext = context_course::instance(SITEID, MUST_EXIST);
134     // read last execution date from db
135     if (!$timestart = get_config(NULL, 'statslastdaily')) {
136         $timestart = stats_get_base_daily(stats_get_start_from('daily'));
137         set_config('statslastdaily', $timestart);
138     }
140     // calculate scheduled time
141     $scheduledtime = stats_get_base_daily() + $CFG->statsruntimestarthour*60*60 + $CFG->statsruntimestartminute*60;
143     // Note: This will work fine for sites running cron each 4 hours or less (hopefully, 99.99% of sites). MDL-16709
144     // check to make sure we're due to run, at least 20 hours after last run
145     if (isset($CFG->statslastexecution) && ((time() - 20*60*60) < $CFG->statslastexecution)) {
146         mtrace("...preventing stats to run, last execution was less than 20 hours ago.");
147         return false;
148     // also check that we are a max of 4 hours after scheduled time, stats won't run after that
149     } else if (time() > $scheduledtime + 4*60*60) {
150         mtrace("...preventing stats to run, more than 4 hours since scheduled time.");
151         return false;
152     } else {
153         set_config('statslastexecution', time()); /// Grab this execution as last one
154     }
156     $nextmidnight = stats_get_next_day_start($timestart);
158     // are there any days that need to be processed?
159     if ($now < $nextmidnight) {
160         return true; // everything ok and up-to-date
161     }
164     $timeout = empty($CFG->statsmaxruntime) ? 60*60*24 : $CFG->statsmaxruntime;
166     if (!set_cron_lock('statsrunning', $now + $timeout)) {
167         return false;
168     }
170     // first delete entries that should not be there yet
171     $DB->delete_records_select('stats_daily',      "timeend > $timestart");
172     $DB->delete_records_select('stats_user_daily', "timeend > $timestart");
174     // Read in a few things we'll use later
175     $viewactions = stats_get_action_names('view');
176     $postactions = stats_get_action_names('post');
178     $guest           = (int)$CFG->siteguest;
179     $guestrole       = (int)$CFG->guestroleid;
180     $defaultfproleid = (int)$CFG->defaultfrontpageroleid;
182     mtrace("Running daily statistics gathering, starting at $timestart:");
184     $days  = 0;
185     $total = 0;
186     $failed  = false; // failed stats flag
187     $timeout = false;
189     if (!stats_temp_table_create()) {
190         $days = 1;
191         $failed = true;
192     }
193     mtrace('Temporary tables created');
195     if(!stats_temp_table_setup()) {
196         $days = 1;
197         $failed = true;
198     }
199     mtrace('Enrolments calculated');
201     $totalactiveusers = $DB->count_records('user', array('deleted' => '0'));
203     while (!$failed && ($now > $nextmidnight)) {
204         if ($days >= $maxdays) {
205             $timeout = true;
206             break;
207         }
209         $days++;
210         @set_time_limit($timeout - 200);
212         if ($days > 1) {
213             // move the lock
214             set_cron_lock('statsrunning', time() + $timeout, true);
215         }
217         $daystart = time();
219         stats_progress('init');
221         if (!stats_temp_table_fill($timestart, $nextmidnight)) {
222             $failed = true;
223             break;
224         }
226         // Find out if any logs available for this day
227         $sql = "SELECT 'x' FROM {temp_log1} l";
228         $logspresent = $DB->get_records_sql($sql, null, 0, 1);
230         if ($logspresent) {
231             // Insert blank record to force Query 10 to generate additional row when no logs for
232             // the site with userid 0 exist.  Added for backwards compatibility.
233             $DB->insert_record('temp_log1', array('userid' => 0, 'course' => SITEID, 'action' => ''));
234         }
236         // Calculate the number of active users today
237         $sql = 'SELECT COUNT(DISTINCT u.id)
238                   FROM {user} u
239                   JOIN {temp_log1} l ON l.userid = u.id
240                  WHERE u.deleted = 0';
241         $dailyactiveusers = $DB->count_records_sql($sql);
243         stats_progress('0');
245         // Process login info first
246         // Note: PostgreSQL doesn't like aliases in HAVING clauses
247         $sql = "INSERT INTO {temp_stats_user_daily}
248                             (stattype, timeend, courseid, userid, statsreads)
250                 SELECT 'logins', $nextmidnight AS timeend, ".SITEID." AS courseid,
251                         userid, COUNT(id) AS statsreads
252                   FROM {temp_log1} l
253                  WHERE action = 'login'
254               GROUP BY timeend, courseid, userid
255                 HAVING COUNT(id) > 0";
257         if ($logspresent && !stats_run_query($sql)) {
258             $failed = true;
259             break;
260         }
262         stats_progress('1');
264         $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
266                 SELECT 'logins' AS stattype, $nextmidnight AS timeend, ".SITEID." AS courseid, 0,
267                        COALESCE(SUM(statsreads), 0) as stat1, COUNT('x') as stat2
268                   FROM {temp_stats_user_daily}
269                  WHERE stattype = 'logins' AND timeend = $nextmidnight";
271         if ($logspresent && !stats_run_query($sql)) {
272             $failed = true;
273             break;
274         }
275         stats_progress('2');
278         // Enrolments and active enrolled users
279         //
280         // Unfortunately, we do not know how many users were registered
281         // at given times in history :-(
282         // - stat1: enrolled users
283         // - stat2: enrolled users active in this period
284         // - SITEID is special case here, because it's all about default enrolment
285         //   in that case, we'll count non-deleted users.
286         //
288         $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
290                 SELECT 'enrolments' as stattype, $nextmidnight as timeend, courseid, roleid,
291                         COUNT(DISTINCT userid) as stat1, 0 as stat2
292                   FROM {temp_enroled}
293               GROUP BY courseid, roleid";
295         if (!stats_run_query($sql)) {
296             $failed = true;
297             break;
298         }
299         stats_progress('3');
301         // Set stat2 to the number distinct users with role assignments in the course that were active
302         // using table alias in UPDATE does not work in pg < 8.2
303         $sql = "UPDATE {temp_stats_daily}
304                    SET stat2 = (
306                     SELECT COUNT(DISTINCT userid)
307                       FROM {temp_enroled} te
308                      WHERE roleid = {temp_stats_daily}.roleid
309                        AND courseid = {temp_stats_daily}.courseid
310                        AND EXISTS (
312                         SELECT 'x'
313                           FROM {temp_log1} l
314                          WHERE l.course = {temp_stats_daily}.courseid
315                            AND l.userid = te.userid
316                                   )
317                                )
318                  WHERE {temp_stats_daily}.stattype = 'enrolments'
319                    AND {temp_stats_daily}.timeend = $nextmidnight
320                    AND {temp_stats_daily}.courseid IN (
322                     SELECT DISTINCT course FROM {temp_log2})";
324         if ($logspresent && !stats_run_query($sql, array('courselevel'=>CONTEXT_COURSE))) {
325             $failed = true;
326             break;
327         }
328         stats_progress('4');
330         // Now get course total enrolments (roleid==0) - except frontpage
331         $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
333                 SELECT 'enrolments', $nextmidnight AS timeend, te.courseid AS courseid, 0 AS roleid,
334                        COUNT(DISTINCT userid) AS stat1, 0 AS stat2
335                   FROM {temp_enroled} te
336               GROUP BY courseid
337                 HAVING COUNT(DISTINCT userid) > 0";
339         if ($logspresent && !stats_run_query($sql)) {
340             $failed = true;
341             break;
342         }
343         stats_progress('5');
345         // Set stat 2 to the number of enrolled users who were active in the course
346         $sql = "UPDATE {temp_stats_daily}
347                    SET stat2 = (
349                     SELECT COUNT(DISTINCT te.userid)
350                       FROM {temp_enroled} te
351                      WHERE te.courseid = {temp_stats_daily}.courseid
352                        AND EXISTS (
354                         SELECT 'x'
355                           FROM {temp_log1} l
356                          WHERE l.course = {temp_stats_daily}.courseid
357                            AND l.userid = te.userid
358                                   )
359                                )
361                  WHERE {temp_stats_daily}.stattype = 'enrolments'
362                    AND {temp_stats_daily}.timeend = $nextmidnight
363                    AND {temp_stats_daily}.roleid = 0
364                    AND {temp_stats_daily}.courseid IN (
366                     SELECT l.course
367                       FROM {temp_log2} l
368                      WHERE l.course <> ".SITEID.")";
370         if ($logspresent && !stats_run_query($sql, array())) {
371             $failed = true;
372             break;
373         }
374         stats_progress('6');
376         // Frontpage(==site) enrolments total
377         $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
379                 SELECT 'enrolments', $nextmidnight, ".SITEID.", 0, $totalactiveusers AS stat1,
380                        $dailyactiveusers AS stat2" .
381                 $DB->sql_null_from_clause();
383         if ($logspresent && !stats_run_query($sql)) {
384             $failed = true;
385             break;
386         }
387         stats_progress('7');
389         // Default frontpage role enrolments are all site users (not deleted)
390         if ($defaultfproleid) {
391             // first remove default frontpage role counts if created by previous query
392             $sql = "DELETE
393                       FROM {temp_stats_daily}
394                      WHERE stattype = 'enrolments'
395                        AND courseid = ".SITEID."
396                        AND roleid = $defaultfproleid
397                        AND timeend = $nextmidnight";
399             if ($logspresent && !stats_run_query($sql)) {
400                 $failed = true;
401                 break;
402             }
403             stats_progress('8');
405             $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
407                     SELECT 'enrolments', $nextmidnight, ".SITEID.", $defaultfproleid,
408                            $totalactiveusers AS stat1, $dailyactiveusers AS stat2" .
409                     $DB->sql_null_from_clause();;
411             if ($logspresent && !stats_run_query($sql)) {
412                 $failed = true;
413                 break;
414             }
415             stats_progress('9');
417         } else {
418             stats_progress('x');
419             stats_progress('x');
420         }
423         /// individual user stats (including not-logged-in) in each course, this is slow - reuse this data if possible
424         list($viewactionssql, $params1) = $DB->get_in_or_equal($viewactions, SQL_PARAMS_NAMED, 'view');
425         list($postactionssql, $params2) = $DB->get_in_or_equal($postactions, SQL_PARAMS_NAMED, 'post');
426         $sql = "INSERT INTO {temp_stats_user_daily} (stattype, timeend, courseid, userid, statsreads, statswrites)
428                 SELECT 'activity' AS stattype, $nextmidnight AS timeend, course AS courseid, userid,
429                        SUM(CASE WHEN action $viewactionssql THEN 1 ELSE 0 END) AS statsreads,
430                        SUM(CASE WHEN action $postactionssql THEN 1 ELSE 0 END) AS statswrites
431                   FROM {temp_log1} l
432               GROUP BY userid, courseid";
434         if ($logspresent && !stats_run_query($sql, array_merge($params1, $params2))) {
435             $failed = true;
436             break;
437         }
438         stats_progress('10');
441         /// How many view/post actions in each course total
442         $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
444                 SELECT 'activity' AS stattype, $nextmidnight AS timeend, c.id AS courseid, 0,
445                        SUM(CASE WHEN l.action $viewactionssql THEN 1 ELSE 0 END) AS stat1,
446                        SUM(CASE WHEN l.action $postactionssql THEN 1 ELSE 0 END) AS stat2
447                   FROM {course} c, {temp_log1} l
448                  WHERE l.course = c.id
449               GROUP BY courseid";
451         if ($logspresent && !stats_run_query($sql, array_merge($params1, $params2))) {
452             $failed = true;
453             break;
454         }
455         stats_progress('11');
458         /// how many view actions for each course+role - excluding guests and frontpage
460         $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
462                 SELECT 'activity', $nextmidnight AS timeend, courseid, roleid, SUM(statsreads), SUM(statswrites)
463                   FROM (
465                     SELECT pl.courseid, pl.roleid, sud.statsreads, sud.statswrites
466                       FROM {temp_stats_user_daily} sud, (
468                         SELECT DISTINCT te.userid, te.roleid, te.courseid
469                           FROM {temp_enroled} te
470                          WHERE te.roleid <> $guestrole
471                            AND te.userid <> $guest
472                                                         ) pl
474                      WHERE sud.userid = pl.userid
475                        AND sud.courseid = pl.courseid
476                        AND sud.timeend = $nextmidnight
477                        AND sud.stattype='activity'
478                        ) inline_view
480               GROUP BY timeend, courseid, roleid
481                 HAVING SUM(statsreads) > 0 OR SUM(statswrites) > 0";
483         if ($logspresent && !stats_run_query($sql, array('courselevel'=>CONTEXT_COURSE))) {
484             $failed = true;
485             break;
486         }
487         stats_progress('12');
489         /// how many view actions from guests only in each course - excluding frontpage
490         /// normal users may enter course with temporary guest access too
492         $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
494                 SELECT 'activity', $nextmidnight AS timeend, courseid, $guestrole AS roleid,
495                        SUM(statsreads), SUM(statswrites)
496                   FROM (
498                     SELECT sud.courseid, sud.statsreads, sud.statswrites
499                       FROM {temp_stats_user_daily} sud
500                      WHERE sud.timeend = $nextmidnight
501                        AND sud.courseid <> ".SITEID."
502                        AND sud.stattype='activity'
503                        AND (sud.userid = $guest OR sud.userid NOT IN (
505                         SELECT userid
506                           FROM {temp_enroled} te
507                          WHERE te.courseid = sud.courseid
508                                                                      ))
509                        ) inline_view
511               GROUP BY timeend, courseid, roleid
512                 HAVING SUM(statsreads) > 0 OR SUM(statswrites) > 0";
514         if ($logspresent && !stats_run_query($sql, array())) {
515             $failed = true;
516             break;
517         }
518         stats_progress('13');
521         /// How many view actions for each role on frontpage - excluding guests, not-logged-in and default frontpage role
522         $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
524                 SELECT 'activity', $nextmidnight AS timeend, courseid, roleid,
525                        SUM(statsreads), SUM(statswrites)
526                   FROM (
527                     SELECT pl.courseid, pl.roleid, sud.statsreads, sud.statswrites
528                       FROM {temp_stats_user_daily} sud, (
530                         SELECT DISTINCT ra.userid, ra.roleid, c.instanceid AS courseid
531                           FROM {role_assignments} ra
532                           JOIN {context} c ON c.id = ra.contextid
533                          WHERE ra.contextid = :fpcontext
534                            AND ra.roleid <> $defaultfproleid
535                            AND ra.roleid <> $guestrole
536                            AND ra.userid <> $guest
537                                                    ) pl
538                      WHERE sud.userid = pl.userid
539                        AND sud.courseid = pl.courseid
540                        AND sud.timeend = $nextmidnight
541                        AND sud.stattype='activity'
542                        ) inline_view
544               GROUP BY timeend, courseid, roleid
545                 HAVING SUM(statsreads) > 0 OR SUM(statswrites) > 0";
547         if ($logspresent && !stats_run_query($sql, array('fpcontext'=>$fpcontext->id))) {
548             $failed = true;
549             break;
550         }
551         stats_progress('14');
554         // How many view actions for default frontpage role on frontpage only
555         $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
557                 SELECT 'activity', timeend, courseid, $defaultfproleid AS roleid,
558                        SUM(statsreads), SUM(statswrites)
559                   FROM (
560                     SELECT sud.timeend AS timeend, sud.courseid, sud.statsreads, sud.statswrites
561                       FROM {temp_stats_user_daily} sud
562                      WHERE sud.timeend = :nextm
563                        AND sud.courseid = :siteid
564                        AND sud.stattype='activity'
565                        AND sud.userid <> $guest
566                        AND sud.userid <> 0
567                        AND sud.userid NOT IN (
569                         SELECT ra.userid
570                           FROM {role_assignments} ra
571                          WHERE ra.roleid <> $guestrole
572                            AND ra.roleid <> $defaultfproleid
573                            AND ra.contextid = :fpcontext)
574                        ) inline_view
576               GROUP BY timeend, courseid, roleid
577                 HAVING SUM(statsreads) > 0 OR SUM(statswrites) > 0";
579         if ($logspresent && !stats_run_query($sql, array('fpcontext'=>$fpcontext->id, 'siteid'=>SITEID, 'nextm'=>$nextmidnight))) {
580             $failed = true;
581             break;
582         }
583         stats_progress('15');
585         // How many view actions for guests or not-logged-in on frontpage
586         $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
588                 SELECT 'activity', $nextmidnight AS timeend, ".SITEID." AS courseid, $guestrole AS roleid,
589                        SUM(statsreads), SUM(statswrites)
590                   FROM (
592                     SELECT sud.statsreads, sud.statswrites
593                       FROM {temp_stats_user_daily} sud
594                      WHERE (sud.userid = $guest OR sud.userid = 0)
595                        AND sud.timeend = $nextmidnight
596                        AND sud.courseid = ".SITEID."
597                        AND sud.stattype='activity'
598                         ) inline_view
600               GROUP BY timeend, courseid, roleid
601                 HAVING SUM(statsreads) > 0 OR SUM(statswrites) > 0";
603         if ($logspresent && !stats_run_query($sql)) {
604             $failed = true;
605             break;
606         }
607         stats_progress('16');
609         stats_temp_table_clean();
611         stats_progress('out');
613         // remember processed days
614         set_config('statslastdaily', $nextmidnight);
615         $elapsed = time()-$daystart;
616         mtrace("  finished until $nextmidnight: ".userdate($nextmidnight)." (in $elapsed s)");
617         $total += $elapsed;
619         $timestart    = $nextmidnight;
620         $nextmidnight = stats_get_next_day_start($nextmidnight);
621     }
623     stats_temp_table_drop();
625     set_cron_lock('statsrunning', null);
627     if ($failed) {
628         $days--;
629         mtrace("...error occurred, completed $days days of statistics in {$total} s.");
630         return false;
632     } else if ($timeout) {
633         mtrace("...stopping early, reached maximum number of $maxdays days ({$total} s) - will continue next time.");
634         return false;
636     } else {
637         mtrace("...completed $days days of statistics in {$total} s.");
638         return true;
639     }
643 /**
644  * Execute weekly statistics gathering
645  * @return boolean success
646  */
647 function stats_cron_weekly() {
648     global $CFG, $DB;
650     $now = time();
652     // read last execution date from db
653     if (!$timestart = get_config(NULL, 'statslastweekly')) {
654         $timestart = stats_get_base_daily(stats_get_start_from('weekly'));
655         set_config('statslastweekly', $timestart);
656     }
658     $nextstartweek = stats_get_next_week_start($timestart);
660     // are there any weeks that need to be processed?
661     if ($now < $nextstartweek) {
662         return true; // everything ok and up-to-date
663     }
665     $timeout = empty($CFG->statsmaxruntime) ? 60*60*24 : $CFG->statsmaxruntime;
667     if (!set_cron_lock('statsrunning', $now + $timeout)) {
668         return false;
669     }
671     // fisrt delete entries that should not be there yet
672     $DB->delete_records_select('stats_weekly',      "timeend > $timestart");
673     $DB->delete_records_select('stats_user_weekly', "timeend > $timestart");
675     mtrace("Running weekly statistics gathering, starting at $timestart:");
677     $weeks = 0;
678     while ($now > $nextstartweek) {
679         @set_time_limit($timeout - 200);
680         $weeks++;
682         if ($weeks > 1) {
683             // move the lock
684             set_cron_lock('statsrunning', time() + $timeout, true);
685         }
687         $logtimesql  = "l.time >= $timestart AND l.time < $nextstartweek";
688         $stattimesql = "timeend > $timestart AND timeend <= $nextstartweek";
690         $weekstart = time();
691         stats_progress('init');
693     /// process login info first
694         $sql = "INSERT INTO {stats_user_weekly} (stattype, timeend, courseid, userid, statsreads)
696                 SELECT 'logins', timeend, courseid, userid, COUNT(statsreads)
697                   FROM (
698                            SELECT $nextstartweek AS timeend, ".SITEID." as courseid, l.userid, l.id AS statsreads
699                              FROM {log} l
700                             WHERE action = 'login' AND $logtimesql
701                        ) inline_view
702               GROUP BY timeend, courseid, userid
703                 HAVING COUNT(statsreads) > 0";
705         $DB->execute($sql);
707         stats_progress('1');
709         $sql = "INSERT INTO {stats_weekly} (stattype, timeend, courseid, roleid, stat1, stat2)
711                 SELECT 'logins' AS stattype, $nextstartweek AS timeend, ".SITEID." as courseid, 0,
712                        COALESCE((SELECT SUM(statsreads)
713                                    FROM {stats_user_weekly} s1
714                                   WHERE s1.stattype = 'logins' AND timeend = $nextstartweek), 0) AS nstat1,
715                        (SELECT COUNT('x')
716                           FROM {stats_user_weekly} s2
717                          WHERE s2.stattype = 'logins' AND timeend = $nextstartweek) AS nstat2" .
718                 $DB->sql_null_from_clause();
720         $DB->execute($sql);
722         stats_progress('2');
724     /// now enrolments averages
725         $sql = "INSERT INTO {stats_weekly} (stattype, timeend, courseid, roleid, stat1, stat2)
727                 SELECT 'enrolments', ntimeend, courseid, roleid, " . $DB->sql_ceil('AVG(stat1)') . ", " . $DB->sql_ceil('AVG(stat2)') . "
728                   FROM (
729                            SELECT $nextstartweek AS ntimeend, courseid, roleid, stat1, stat2
730                              FROM {stats_daily} sd
731                             WHERE stattype = 'enrolments' AND $stattimesql
732                        ) inline_view
733               GROUP BY ntimeend, courseid, roleid";
735         $DB->execute($sql);
737         stats_progress('3');
739     /// activity read/write averages
740         $sql = "INSERT INTO {stats_weekly} (stattype, timeend, courseid, roleid, stat1, stat2)
742                 SELECT 'activity', ntimeend, courseid, roleid, SUM(stat1), SUM(stat2)
743                   FROM (
744                            SELECT $nextstartweek AS ntimeend, courseid, roleid, stat1, stat2
745                              FROM {stats_daily}
746                             WHERE stattype = 'activity' AND $stattimesql
747                        ) inline_view
748               GROUP BY ntimeend, courseid, roleid";
750         $DB->execute($sql);
752         stats_progress('4');
754     /// user read/write averages
755         $sql = "INSERT INTO {stats_user_weekly} (stattype, timeend, courseid, userid, statsreads, statswrites)
757                 SELECT 'activity', ntimeend, courseid, userid, SUM(statsreads), SUM(statswrites)
758                   FROM (
759                            SELECT $nextstartweek AS ntimeend, courseid, userid, statsreads, statswrites
760                              FROM {stats_user_daily}
761                             WHERE stattype = 'activity' AND $stattimesql
762                        ) inline_view
763               GROUP BY ntimeend, courseid, userid";
765         $DB->execute($sql);
767         stats_progress('5');
769         set_config('statslastweekly', $nextstartweek);
770         $elapsed = time()-$weekstart;
771         mtrace(" finished until $nextstartweek: ".userdate($nextstartweek) ." (in $elapsed s)");
773         $timestart     = $nextstartweek;
774         $nextstartweek = stats_get_next_week_start($nextstartweek);
775     }
777     set_cron_lock('statsrunning', null);
778     mtrace("...completed $weeks weeks of statistics.");
779     return true;
782 /**
783  * Execute monthly statistics gathering
784  * @return boolean success
785  */
786 function stats_cron_monthly() {
787     global $CFG, $DB;
789     $now = time();
791     // read last execution date from db
792     if (!$timestart = get_config(NULL, 'statslastmonthly')) {
793         $timestart = stats_get_base_monthly(stats_get_start_from('monthly'));
794         set_config('statslastmonthly', $timestart);
795     }
797     $nextstartmonth = stats_get_next_month_start($timestart);
799     // are there any months that need to be processed?
800     if ($now < $nextstartmonth) {
801         return true; // everything ok and up-to-date
802     }
804     $timeout = empty($CFG->statsmaxruntime) ? 60*60*24 : $CFG->statsmaxruntime;
806     if (!set_cron_lock('statsrunning', $now + $timeout)) {
807         return false;
808     }
810     // fisr delete entries that should not be there yet
811     $DB->delete_records_select('stats_monthly', "timeend > $timestart");
812     $DB->delete_records_select('stats_user_monthly', "timeend > $timestart");
814     $startmonth = stats_get_base_monthly($now);
817     mtrace("Running monthly statistics gathering, starting at $timestart:");
819     $months = 0;
820     while ($now > $nextstartmonth) {
821         @set_time_limit($timeout - 200);
822         $months++;
824         if ($months > 1) {
825             // move the lock
826             set_cron_lock('statsrunning', time() + $timeout, true);
827         }
829         $logtimesql  = "l.time >= $timestart AND l.time < $nextstartmonth";
830         $stattimesql = "timeend > $timestart AND timeend <= $nextstartmonth";
832         $monthstart = time();
833         stats_progress('init');
835     /// process login info first
836         $sql = "INSERT INTO {stats_user_monthly} (stattype, timeend, courseid, userid, statsreads)
838                 SELECT 'logins', timeend, courseid, userid, COUNT(statsreads)
839                   FROM (
840                            SELECT $nextstartmonth AS timeend, ".SITEID." as courseid, l.userid, l.id AS statsreads
841                              FROM {log} l
842                             WHERE action = 'login' AND $logtimesql
843                        ) inline_view
844               GROUP BY timeend, courseid, userid";
846         $DB->execute($sql);
848         stats_progress('1');
850         $sql = "INSERT INTO {stats_monthly} (stattype, timeend, courseid, roleid, stat1, stat2)
852                 SELECT 'logins' AS stattype, $nextstartmonth AS timeend, ".SITEID." as courseid, 0,
853                        COALESCE((SELECT SUM(statsreads)
854                                    FROM {stats_user_monthly} s1
855                                   WHERE s1.stattype = 'logins' AND timeend = $nextstartmonth), 0) AS nstat1,
856                        (SELECT COUNT('x')
857                           FROM {stats_user_monthly} s2
858                          WHERE s2.stattype = 'logins' AND timeend = $nextstartmonth) AS nstat2" .
859                 $DB->sql_null_from_clause();
861         $DB->execute($sql);
863         stats_progress('2');
865     /// now enrolments averages
866         $sql = "INSERT INTO {stats_monthly} (stattype, timeend, courseid, roleid, stat1, stat2)
868                 SELECT 'enrolments', ntimeend, courseid, roleid, " . $DB->sql_ceil('AVG(stat1)') . ", " . $DB->sql_ceil('AVG(stat2)') . "
869                   FROM (
870                            SELECT $nextstartmonth AS ntimeend, courseid, roleid, stat1, stat2
871                              FROM {stats_daily} sd
872                             WHERE stattype = 'enrolments' AND $stattimesql
873                        ) inline_view
874               GROUP BY ntimeend, courseid, roleid";
876         $DB->execute($sql);
878         stats_progress('3');
880     /// activity read/write averages
881         $sql = "INSERT INTO {stats_monthly} (stattype, timeend, courseid, roleid, stat1, stat2)
883                 SELECT 'activity', ntimeend, courseid, roleid, SUM(stat1), SUM(stat2)
884                   FROM (
885                            SELECT $nextstartmonth AS ntimeend, courseid, roleid, stat1, stat2
886                              FROM {stats_daily}
887                             WHERE stattype = 'activity' AND $stattimesql
888                        ) inline_view
889               GROUP BY ntimeend, courseid, roleid";
891         $DB->execute($sql);
893         stats_progress('4');
895     /// user read/write averages
896         $sql = "INSERT INTO {stats_user_monthly} (stattype, timeend, courseid, userid, statsreads, statswrites)
898                 SELECT 'activity', ntimeend, courseid, userid, SUM(statsreads), SUM(statswrites)
899                   FROM (
900                            SELECT $nextstartmonth AS ntimeend, courseid, userid, statsreads, statswrites
901                              FROM {stats_user_daily}
902                             WHERE stattype = 'activity' AND $stattimesql
903                        ) inline_view
904               GROUP BY ntimeend, courseid, userid";
906         $DB->execute($sql);
908         stats_progress('5');
910         set_config('statslastmonthly', $nextstartmonth);
911         $elapsed = time() - $monthstart;
912         mtrace(" finished until $nextstartmonth: ".userdate($nextstartmonth) ." (in $elapsed s)");
914         $timestart      = $nextstartmonth;
915         $nextstartmonth = stats_get_next_month_start($nextstartmonth);
916     }
918     set_cron_lock('statsrunning', null);
919     mtrace("...completed $months months of statistics.");
920     return true;
923 /**
924  * Return starting date of stats processing
925  * @param string $str name of table - daily, weekly or monthly
926  * @return int timestamp
927  */
928 function stats_get_start_from($str) {
929     global $CFG, $DB;
931     // are there any data in stats table? Should not be...
932     if ($timeend = $DB->get_field_sql('SELECT MAX(timeend) FROM {stats_'.$str.'}')) {
933         return $timeend;
934     }
935     // decide what to do based on our config setting (either all or none or a timestamp)
936     switch ($CFG->statsfirstrun) {
937         case 'all':
938             if ($firstlog = $DB->get_field_sql('SELECT MIN(time) FROM {log}')) {
939                 return $firstlog;
940             }
941         default:
942             if (is_numeric($CFG->statsfirstrun)) {
943                 return time() - $CFG->statsfirstrun;
944             }
945             // not a number? use next instead
946         case 'none':
947             return strtotime('-3 day', time());
948     }
951 /**
952  * Start of day
953  * @param int $time timestamp
954  * @return start of day
955  */
956 function stats_get_base_daily($time=0) {
957     global $CFG;
959     if (empty($time)) {
960         $time = time();
961     }
962     if ($CFG->timezone == 99) {
963         $time = strtotime(date('d-M-Y', $time));
964         return $time;
965     } else {
966         $offset = get_timezone_offset($CFG->timezone);
967         $gtime = $time + $offset;
968         $gtime = intval($gtime / (60*60*24)) * 60*60*24;
969         return $gtime - $offset;
970     }
973 /**
974  * Start of week
975  * @param int $time timestamp
976  * @return start of week
977  */
978 function stats_get_base_weekly($time=0) {
979     global $CFG;
981     $time = stats_get_base_daily($time);
982     $startday = $CFG->calendar_startwday;
983     if ($CFG->timezone == 99) {
984         $thisday = date('w', $time);
985     } else {
986         $offset = get_timezone_offset($CFG->timezone);
987         $gtime = $time + $offset;
988         $thisday = gmdate('w', $gtime);
989     }
990     if ($thisday > $startday) {
991         $time = $time - (($thisday - $startday) * 60*60*24);
992     } else if ($thisday < $startday) {
993         $time = $time - ((7 + $thisday - $startday) * 60*60*24);
994     }
995     return $time;
998 /**
999  * Start of month
1000  * @param int $time timestamp
1001  * @return start of month
1002  */
1003 function stats_get_base_monthly($time=0) {
1004     global $CFG;
1006     if (empty($time)) {
1007         $time = time();
1008     }
1009     if ($CFG->timezone == 99) {
1010         return strtotime(date('1-M-Y', $time));
1012     } else {
1013         $time = stats_get_base_daily($time);
1014         $offset = get_timezone_offset($CFG->timezone);
1015         $gtime = $time + $offset;
1016         $day = gmdate('d', $gtime);
1017         if ($day == 1) {
1018             return $time;
1019         }
1020         return $gtime - (($day-1) * 60*60*24);
1021     }
1024 /**
1025  * Start of next day
1026  * @param int $time timestamp
1027  * @return start of next day
1028  */
1029 function stats_get_next_day_start($time) {
1030     $next = stats_get_base_daily($time);
1031     $next = $next + 60*60*26;
1032     $next = stats_get_base_daily($next);
1033     if ($next <= $time) {
1034         //DST trouble - prevent infinite loops
1035         $next = $next + 60*60*24;
1036     }
1037     return $next;
1040 /**
1041  * Start of next week
1042  * @param int $time timestamp
1043  * @return start of next week
1044  */
1045 function stats_get_next_week_start($time) {
1046     $next = stats_get_base_weekly($time);
1047     $next = $next + 60*60*24*9;
1048     $next = stats_get_base_weekly($next);
1049     if ($next <= $time) {
1050         //DST trouble - prevent infinite loops
1051         $next = $next + 60*60*24*7;
1052     }
1053     return $next;
1056 /**
1057  * Start of next month
1058  * @param int $time timestamp
1059  * @return start of next month
1060  */
1061 function stats_get_next_month_start($time) {
1062     $next = stats_get_base_monthly($time);
1063     $next = $next + 60*60*24*33;
1064     $next = stats_get_base_monthly($next);
1065     if ($next <= $time) {
1066         //DST trouble - prevent infinite loops
1067         $next = $next + 60*60*24*31;
1068     }
1069     return $next;
1072 /**
1073  * Remove old stats data
1074  */
1075 function stats_clean_old() {
1076     global $DB;
1077     mtrace("Running stats cleanup tasks...");
1078     $deletebefore =  stats_get_base_monthly();
1080     // delete dailies older than 3 months (to be safe)
1081     $deletebefore = strtotime('-3 months', $deletebefore);
1082     $DB->delete_records_select('stats_daily',      "timeend < $deletebefore");
1083     $DB->delete_records_select('stats_user_daily', "timeend < $deletebefore");
1085     // delete weeklies older than 9  months (to be safe)
1086     $deletebefore = strtotime('-6 months', $deletebefore);
1087     $DB->delete_records_select('stats_weekly',      "timeend < $deletebefore");
1088     $DB->delete_records_select('stats_user_weekly', "timeend < $deletebefore");
1090     // don't delete monthlies
1092     mtrace("...stats cleanup finished");
1095 function stats_get_parameters($time,$report,$courseid,$mode,$roleid=0) {
1096     global $CFG, $DB;
1098     $param = new stdClass();
1099     $param->params = array();
1101     if ($time < 10) { // dailies
1102         // number of days to go back = 7* time
1103         $param->table = 'daily';
1104         $param->timeafter = strtotime("-".($time*7)." days",stats_get_base_daily());
1105     } elseif ($time < 20) { // weeklies
1106         // number of weeks to go back = time - 10 * 4 (weeks) + base week
1107         $param->table = 'weekly';
1108         $param->timeafter = strtotime("-".(($time - 10)*4)." weeks",stats_get_base_weekly());
1109     } else { // monthlies.
1110         // number of months to go back = time - 20 * months + base month
1111         $param->table = 'monthly';
1112         $param->timeafter = strtotime("-".($time - 20)." months",stats_get_base_monthly());
1113     }
1115     $param->extras = '';
1117     switch ($report) {
1118     // ******************** STATS_MODE_GENERAL ******************** //
1119     case STATS_REPORT_LOGINS:
1120         $param->fields = 'timeend,sum(stat1) as line1,sum(stat2) as line2';
1121         $param->fieldscomplete = true;
1122         $param->stattype = 'logins';
1123         $param->line1 = get_string('statslogins');
1124         $param->line2 = get_string('statsuniquelogins');
1125         if ($courseid == SITEID) {
1126             $param->extras = 'GROUP BY timeend';
1127         }
1128         break;
1130     case STATS_REPORT_READS:
1131         $param->fields = $DB->sql_concat('timeend','roleid').' AS uniqueid, timeend, roleid, stat1 as line1';
1132         $param->fieldscomplete = true; // set this to true to avoid anything adding stuff to the list and breaking complex queries.
1133         $param->aggregategroupby = 'roleid';
1134         $param->stattype = 'activity';
1135         $param->crosstab = true;
1136         $param->extras = 'GROUP BY timeend,roleid,stat1';
1137         if ($courseid == SITEID) {
1138             $param->fields = $DB->sql_concat('timeend','roleid').' AS uniqueid, timeend, roleid, sum(stat1) as line1';
1139             $param->extras = 'GROUP BY timeend,roleid';
1140         }
1141         break;
1143     case STATS_REPORT_WRITES:
1144         $param->fields = $DB->sql_concat('timeend','roleid').' AS uniqueid, timeend, roleid, stat2 as line1';
1145         $param->fieldscomplete = true; // set this to true to avoid anything adding stuff to the list and breaking complex queries.
1146         $param->aggregategroupby = 'roleid';
1147         $param->stattype = 'activity';
1148         $param->crosstab = true;
1149         $param->extras = 'GROUP BY timeend,roleid,stat2';
1150         if ($courseid == SITEID) {
1151             $param->fields = $DB->sql_concat('timeend','roleid').' AS uniqueid, timeend, roleid, sum(stat2) as line1';
1152             $param->extras = 'GROUP BY timeend,roleid';
1153         }
1154         break;
1156     case STATS_REPORT_ACTIVITY:
1157         $param->fields = $DB->sql_concat('timeend','roleid').' AS uniqueid, timeend, roleid, sum(stat1+stat2) as line1';
1158         $param->fieldscomplete = true; // set this to true to avoid anything adding stuff to the list and breaking complex queries.
1159         $param->aggregategroupby = 'roleid';
1160         $param->stattype = 'activity';
1161         $param->crosstab = true;
1162         $param->extras = 'GROUP BY timeend,roleid';
1163         if ($courseid == SITEID) {
1164             $param->extras = 'GROUP BY timeend,roleid';
1165         }
1166         break;
1168     case STATS_REPORT_ACTIVITYBYROLE;
1169         $param->fields = 'stat1 AS line1, stat2 AS line2';
1170         $param->stattype = 'activity';
1171         $rolename = $DB->get_field('role','name', array('id'=>$roleid));
1172         $param->line1 = $rolename . get_string('statsreads');
1173         $param->line2 = $rolename . get_string('statswrites');
1174         if ($courseid == SITEID) {
1175             $param->extras = 'GROUP BY timeend';
1176         }
1177         break;
1179     // ******************** STATS_MODE_DETAILED ******************** //
1180     case STATS_REPORT_USER_ACTIVITY:
1181         $param->fields = 'statsreads as line1, statswrites as line2';
1182         $param->line1 = get_string('statsuserreads');
1183         $param->line2 = get_string('statsuserwrites');
1184         $param->stattype = 'activity';
1185         break;
1187     case STATS_REPORT_USER_ALLACTIVITY:
1188         $param->fields = 'statsreads+statswrites as line1';
1189         $param->line1 = get_string('statsuseractivity');
1190         $param->stattype = 'activity';
1191         break;
1193     case STATS_REPORT_USER_LOGINS:
1194         $param->fields = 'statsreads as line1';
1195         $param->line1 = get_string('statsuserlogins');
1196         $param->stattype = 'logins';
1197         break;
1199     case STATS_REPORT_USER_VIEW:
1200         $param->fields = 'statsreads as line1, statswrites as line2, statsreads+statswrites as line3';
1201         $param->line1 = get_string('statsuserreads');
1202         $param->line2 = get_string('statsuserwrites');
1203         $param->line3 = get_string('statsuseractivity');
1204         $param->stattype = 'activity';
1205         break;
1207     // ******************** STATS_MODE_RANKED ******************** //
1208     case STATS_REPORT_ACTIVE_COURSES:
1209         $param->fields = 'sum(stat1+stat2) AS line1';
1210         $param->stattype = 'activity';
1211         $param->orderby = 'line1 DESC';
1212         $param->line1 = get_string('activity');
1213         $param->graphline = 'line1';
1214         break;
1216     case STATS_REPORT_ACTIVE_COURSES_WEIGHTED:
1217         $threshold = 0;
1218         if (!empty($CFG->statsuserthreshold) && is_numeric($CFG->statsuserthreshold)) {
1219             $threshold = $CFG->statsuserthreshold;
1220         }
1221         $param->fields = '';
1222         $param->sql = 'SELECT activity.courseid, activity.all_activity AS line1, enrolments.highest_enrolments AS line2,
1223                         activity.all_activity / enrolments.highest_enrolments as line3
1224                        FROM (
1225                             SELECT courseid, sum(stat1+stat2) AS all_activity
1226                               FROM {stats_'.$param->table.'}
1227                              WHERE stattype=\'activity\' AND timeend >= '.(int)$param->timeafter.' AND roleid = 0 GROUP BY courseid
1228                        ) activity
1229                        INNER JOIN
1230                             (
1231                             SELECT courseid, max(stat1) AS highest_enrolments
1232                               FROM {stats_'.$param->table.'}
1233                              WHERE stattype=\'enrolments\' AND timeend >= '.(int)$param->timeafter.' AND stat1 > '.(int)$threshold.'
1234                           GROUP BY courseid
1235                       ) enrolments
1236                       ON (activity.courseid = enrolments.courseid)
1237                       ORDER BY line3 DESC';
1238         $param->line1 = get_string('activity');
1239         $param->line2 = get_string('users');
1240         $param->line3 = get_string('activityweighted');
1241         $param->graphline = 'line3';
1242         break;
1244     case STATS_REPORT_PARTICIPATORY_COURSES:
1245         $threshold = 0;
1246         if (!empty($CFG->statsuserthreshold) && is_numeric($CFG->statsuserthreshold)) {
1247             $threshold = $CFG->statsuserthreshold;
1248         }
1249         $param->fields = '';
1250         $param->sql = 'SELECT courseid, ' . $DB->sql_ceil('avg(all_enrolments)') . ' as line1, ' .
1251                          $DB->sql_ceil('avg(active_enrolments)') . ' as line2, avg(proportion_active) AS line3
1252                        FROM (
1253                            SELECT courseid, timeend, stat2 as active_enrolments,
1254                                   stat1 as all_enrolments, '.$DB->sql_cast_char2real('stat2').'/'.$DB->sql_cast_char2real('stat1').' AS proportion_active
1255                              FROM {stats_'.$param->table.'}
1256                             WHERE stattype=\'enrolments\' AND roleid = 0 AND stat1 > '.(int)$threshold.'
1257                        ) aq
1258                        WHERE timeend >= '.(int)$param->timeafter.'
1259                        GROUP BY courseid
1260                        ORDER BY line3 DESC';
1262         $param->line1 = get_string('users');
1263         $param->line2 = get_string('activeusers');
1264         $param->line3 = get_string('participationratio');
1265         $param->graphline = 'line3';
1266         break;
1268     case STATS_REPORT_PARTICIPATORY_COURSES_RW:
1269         $param->fields = '';
1270         $param->sql =  'SELECT courseid, sum(views) AS line1, sum(posts) AS line2,
1271                            avg(proportion_active) AS line3
1272                          FROM (
1273                            SELECT courseid, timeend, stat1 as views, stat2 AS posts,
1274                                   '.$DB->sql_cast_char2real('stat2').'/'.$DB->sql_cast_char2real('stat1').' as proportion_active
1275                              FROM {stats_'.$param->table.'}
1276                             WHERE stattype=\'activity\' AND roleid = 0 AND stat1 > 0
1277                        ) aq
1278                        WHERE timeend >= '.(int)$param->timeafter.'
1279                        GROUP BY courseid
1280                        ORDER BY line3 DESC';
1281         $param->line1 = get_string('views');
1282         $param->line2 = get_string('posts');
1283         $param->line3 = get_string('participationratio');
1284         $param->graphline = 'line3';
1285         break;
1286     }
1288     /*
1289     if ($courseid == SITEID && $mode != STATS_MODE_RANKED) { // just aggregate all courses.
1290         $param->fields = preg_replace('/(?:sum)([a-zA-Z0-9+_]*)\W+as\W+([a-zA-Z0-9_]*)/i','sum($1) as $2',$param->fields);
1291         $param->extras = ' GROUP BY timeend'.((!empty($param->aggregategroupby)) ? ','.$param->aggregategroupby : '');
1292     }
1293     */
1294     //TODO must add the SITEID reports to the rest of the reports.
1295     return $param;
1298 function stats_get_view_actions() {
1299     return array('view','view all','history');
1302 function stats_get_post_actions() {
1303     return array('add','delete','edit','add mod','delete mod','edit section'.'enrol','loginas','new','unenrol','update','update mod');
1306 function stats_get_action_names($str) {
1307     global $CFG, $DB;
1309     $mods = $DB->get_records('modules');
1310     $function = 'stats_get_'.$str.'_actions';
1311     $actions = $function();
1312     foreach ($mods as $mod) {
1313         $file = $CFG->dirroot.'/mod/'.$mod->name.'/lib.php';
1314         if (!is_readable($file)) {
1315             continue;
1316         }
1317         require_once($file);
1318         $function = $mod->name.'_get_'.$str.'_actions';
1319         if (function_exists($function)) {
1320             $mod_actions = $function();
1321             if (is_array($mod_actions)) {
1322                 $actions = array_merge($actions, $mod_actions);
1323             }
1324         }
1325     }
1327     // The array_values() forces a stack-like array
1328     // so we can later loop over safely...
1329     $actions =  array_values(array_unique($actions));
1330     $c = count($actions);
1331     for ($n=0;$n<$c;$n++) {
1332         $actions[$n] = $actions[$n];
1333     }
1334     return $actions;
1337 function stats_get_time_options($now,$lastweekend,$lastmonthend,$earliestday,$earliestweek,$earliestmonth) {
1339     $now = stats_get_base_daily(time());
1340     // it's really important that it's TIMEEND in the table. ie, tuesday 00:00:00 is monday night.
1341     // so we need to take a day off here (essentially add a day to $now
1342     $now += 60*60*24;
1344     $timeoptions = array();
1346     if ($now - (60*60*24*7) >= $earliestday) {
1347         $timeoptions[STATS_TIME_LASTWEEK] = get_string('numweeks','moodle',1);
1348     }
1349     if ($now - (60*60*24*14) >= $earliestday) {
1350         $timeoptions[STATS_TIME_LAST2WEEKS] = get_string('numweeks','moodle',2);
1351     }
1352     if ($now - (60*60*24*21) >= $earliestday) {
1353         $timeoptions[STATS_TIME_LAST3WEEKS] = get_string('numweeks','moodle',3);
1354     }
1355     if ($now - (60*60*24*28) >= $earliestday) {
1356         $timeoptions[STATS_TIME_LAST4WEEKS] = get_string('numweeks','moodle',4);// show dailies up to (including) here.
1357     }
1358     if ($lastweekend - (60*60*24*56) >= $earliestweek) {
1359         $timeoptions[STATS_TIME_LAST2MONTHS] = get_string('nummonths','moodle',2);
1360     }
1361     if ($lastweekend - (60*60*24*84) >= $earliestweek) {
1362         $timeoptions[STATS_TIME_LAST3MONTHS] = get_string('nummonths','moodle',3);
1363     }
1364     if ($lastweekend - (60*60*24*112) >= $earliestweek) {
1365         $timeoptions[STATS_TIME_LAST4MONTHS] = get_string('nummonths','moodle',4);
1366     }
1367     if ($lastweekend - (60*60*24*140) >= $earliestweek) {
1368         $timeoptions[STATS_TIME_LAST5MONTHS] = get_string('nummonths','moodle',5);
1369     }
1370     if ($lastweekend - (60*60*24*168) >= $earliestweek) {
1371         $timeoptions[STATS_TIME_LAST6MONTHS] = get_string('nummonths','moodle',6); // show weeklies up to (including) here
1372     }
1373     if (strtotime('-7 months',$lastmonthend) >= $earliestmonth) {
1374         $timeoptions[STATS_TIME_LAST7MONTHS] = get_string('nummonths','moodle',7);
1375     }
1376     if (strtotime('-8 months',$lastmonthend) >= $earliestmonth) {
1377         $timeoptions[STATS_TIME_LAST8MONTHS] = get_string('nummonths','moodle',8);
1378     }
1379     if (strtotime('-9 months',$lastmonthend) >= $earliestmonth) {
1380         $timeoptions[STATS_TIME_LAST9MONTHS] = get_string('nummonths','moodle',9);
1381     }
1382     if (strtotime('-10 months',$lastmonthend) >= $earliestmonth) {
1383         $timeoptions[STATS_TIME_LAST10MONTHS] = get_string('nummonths','moodle',10);
1384     }
1385     if (strtotime('-11 months',$lastmonthend) >= $earliestmonth) {
1386         $timeoptions[STATS_TIME_LAST11MONTHS] = get_string('nummonths','moodle',11);
1387     }
1388     if (strtotime('-1 year',$lastmonthend) >= $earliestmonth) {
1389         $timeoptions[STATS_TIME_LASTYEAR] = get_string('lastyear');
1390     }
1392     $years = (int)date('y', $now) - (int)date('y', $earliestmonth);
1393     if ($years > 1) {
1394         for($i = 2; $i <= $years; $i++) {
1395             $timeoptions[$i*12+20] = get_string('numyears', 'moodle', $i);
1396         }
1397     }
1399     return $timeoptions;
1402 function stats_get_report_options($courseid,$mode) {
1403     global $CFG, $DB;
1405     $reportoptions = array();
1407     switch ($mode) {
1408     case STATS_MODE_GENERAL:
1409         $reportoptions[STATS_REPORT_ACTIVITY] = get_string('statsreport'.STATS_REPORT_ACTIVITY);
1410         if ($courseid != SITEID && $context = context_course::instance($courseid)) {
1411             $sql = 'SELECT r.id, r.name FROM {role} r JOIN {stats_daily} s ON s.roleid = r.id WHERE s.courseid = :courseid GROUP BY r.id, r.name';
1412             if ($roles = $DB->get_records_sql($sql, array('courseid' => $courseid))) {
1413                 foreach ($roles as $role) {
1414                     $reportoptions[STATS_REPORT_ACTIVITYBYROLE.$role->id] = get_string('statsreport'.STATS_REPORT_ACTIVITYBYROLE). ' '.$role->name;
1415                 }
1416             }
1417         }
1418         $reportoptions[STATS_REPORT_READS] = get_string('statsreport'.STATS_REPORT_READS);
1419         $reportoptions[STATS_REPORT_WRITES] = get_string('statsreport'.STATS_REPORT_WRITES);
1420         if ($courseid == SITEID) {
1421             $reportoptions[STATS_REPORT_LOGINS] = get_string('statsreport'.STATS_REPORT_LOGINS);
1422         }
1424         break;
1425     case STATS_MODE_DETAILED:
1426         $reportoptions[STATS_REPORT_USER_ACTIVITY] = get_string('statsreport'.STATS_REPORT_USER_ACTIVITY);
1427         $reportoptions[STATS_REPORT_USER_ALLACTIVITY] = get_string('statsreport'.STATS_REPORT_USER_ALLACTIVITY);
1428         if (has_capability('report/stats:view', context_system::instance())) {
1429             $site = get_site();
1430             $reportoptions[STATS_REPORT_USER_LOGINS] = get_string('statsreport'.STATS_REPORT_USER_LOGINS);
1431         }
1432         break;
1433     case STATS_MODE_RANKED:
1434         if (has_capability('report/stats:view', context_system::instance())) {
1435             $reportoptions[STATS_REPORT_ACTIVE_COURSES] = get_string('statsreport'.STATS_REPORT_ACTIVE_COURSES);
1436             $reportoptions[STATS_REPORT_ACTIVE_COURSES_WEIGHTED] = get_string('statsreport'.STATS_REPORT_ACTIVE_COURSES_WEIGHTED);
1437             $reportoptions[STATS_REPORT_PARTICIPATORY_COURSES] = get_string('statsreport'.STATS_REPORT_PARTICIPATORY_COURSES);
1438             $reportoptions[STATS_REPORT_PARTICIPATORY_COURSES_RW] = get_string('statsreport'.STATS_REPORT_PARTICIPATORY_COURSES_RW);
1439         }
1440         break;
1441     }
1443     return $reportoptions;
1446 function stats_fix_zeros($stats,$timeafter,$timestr,$line2=true,$line3=false) {
1448     if (empty($stats)) {
1449         return;
1450     }
1452     $timestr = str_replace('user_','',$timestr); // just in case.
1453     $fun = 'stats_get_base_'.$timestr;
1455     $now = $fun();
1457     $times = array();
1458     // add something to timeafter since it is our absolute base
1459     $actualtimes = array();
1460     foreach ($stats as $statid=>$s) {
1461         //normalize the times in stats - those might have been created in different timezone, DST etc.
1462         $s->timeend = $fun($s->timeend + 60*60*5);
1463         $stats[$statid] = $s;
1465         $actualtimes[] = $s->timeend;
1466     }
1468     $timeafter = array_pop(array_values($actualtimes));
1470     while ($timeafter < $now) {
1471         $times[] = $timeafter;
1472         if ($timestr == 'daily') {
1473             $timeafter = stats_get_next_day_start($timeafter);
1474         } else if ($timestr == 'weekly') {
1475             $timeafter = stats_get_next_week_start($timeafter);
1476         } else if ($timestr == 'monthly') {
1477             $timeafter = stats_get_next_month_start($timeafter);
1478         } else {
1479             return $stats; // this will put us in a never ending loop.
1480         }
1481     }
1483     foreach ($times as $count => $time) {
1484         if (!in_array($time,$actualtimes) && $count != count($times) -1) {
1485             $newobj = new StdClass;
1486             $newobj->timeend = $time;
1487             $newobj->id = 0;
1488             $newobj->roleid = 0;
1489             $newobj->line1 = 0;
1490             if (!empty($line2)) {
1491                 $newobj->line2 = 0;
1492             }
1493             if (!empty($line3)) {
1494                 $newobj->line3 = 0;
1495             }
1496             $newobj->zerofixed = true;
1497             $stats[] = $newobj;
1498         }
1499     }
1501     usort($stats,"stats_compare_times");
1502     return $stats;
1506 // helper function to sort arrays by $obj->timeend
1507 function stats_compare_times($a,$b) {
1508    if ($a->timeend == $b->timeend) {
1509        return 0;
1510    }
1511    return ($a->timeend > $b->timeend) ? -1 : 1;
1514 function stats_check_uptodate($courseid=0) {
1515     global $CFG, $DB;
1517     if (empty($courseid)) {
1518         $courseid = SITEID;
1519     }
1521     $latestday = stats_get_start_from('daily');
1523     if ((time() - 60*60*24*2) < $latestday) { // we're ok
1524         return NULL;
1525     }
1527     $a = new stdClass();
1528     $a->daysdone = $DB->get_field_sql("SELECT COUNT(DISTINCT(timeend)) FROM {stats_daily}");
1530     // how many days between the last day and now?
1531     $a->dayspending = ceil((stats_get_base_daily() - $latestday)/(60*60*24));
1533     if ($a->dayspending == 0 && $a->daysdone != 0) {
1534         return NULL; // we've only just started...
1535     }
1537     //return error as string
1538     return get_string('statscatchupmode','error',$a);
1541 /**
1542  * Create temporary tables to speed up log generation
1543  */
1544 function stats_temp_table_create() {
1545     global $CFG, $DB;
1547     $dbman = $DB->get_manager(); // We are going to use database_manager services
1549     stats_temp_table_drop();
1551     $xmlfile  = $CFG->dirroot . '/lib/db/install.xml';
1552     $tempfile = $CFG->dirroot . '/lib/db/temp_stats_log_template.xml';
1553     $tables   = array();
1555     // Allows for the additional xml files to be used (if necessary)
1556     $files    = array(
1557         $xmlfile  => array(
1558             'stats_daily'           => array('temp_stats_daily'),
1559             'stats_user_daily'      => array('temp_stats_user_daily'),
1560             'temp_enroled_template' => array('temp_enroled'),
1561             'temp_log_template'     => array('temp_log1', 'temp_log2'),
1562         ),
1563     );
1565     foreach ($files as $file => $contents) {
1567         $xmldb_file = new xmldb_file($file);
1568         if (!$xmldb_file->fileExists()) {
1569             throw new ddl_exception('ddlxmlfileerror', null, 'File does not exist');
1570         }
1571         $loaded = $xmldb_file->loadXMLStructure();
1572         if (!$loaded || !$xmldb_file->isLoaded()) {
1573             throw new ddl_exception('ddlxmlfileerror', null, 'not loaded??');
1574         }
1575         $xmldb_structure = $xmldb_file->getStructure();
1577         foreach ($contents as $template => $names) {
1578             $table = $xmldb_structure->getTable($template);
1580             if (is_null($table)) {
1581                 throw new ddl_exception('ddlunknowntable', null, 'The table '. $name .' is not defined in the file '. $xmlfile);
1582             }
1583             $table->setNext(null);\r
1584             $table->setPrevious(null);
1586             foreach ($names as $name) {
1587                 $named = clone $table;
1588                 $named->setName($name);
1589                 $tables[$name] = $named;
1590             }
1591         }
1592     }
1594     try {
1596         foreach ($tables as $table) {
1597             $dbman->create_temp_table($table);
1598         }
1600     } catch (Exception $e) {
1601         mtrace('Temporary table creation failed: '. $e->getMessage());
1602         return false;
1603     }
1605     return true;
1608 /**
1609  * Deletes summary logs table for stats calculation
1610  */
1611 function stats_temp_table_drop() {
1612     global $DB;
1614     $dbman = $DB->get_manager();
1616     $tables = array('temp_log1', 'temp_log2', 'temp_stats_daily', 'temp_stats_user_daily', 'temp_enroled');
1618     foreach ($tables as $name) {
1620         if ($dbman->table_exists($name)) {
1621             $table = new xmldb_table($name);
1623             try {
1624                 $dbman->drop_table($table);
1625             } catch (Exception $e) {
1626                 mtrace("Error occured while dropping temporary tables!");
1627             }
1628         }
1629     }
1632 /**
1633  * Fills the temporary stats tables with new data
1634  *
1635  * This function is meant to be called once at the start of stats generation
1636  *
1637  * @param timestart timestamp of the start time of logs view
1638  * @param timeend timestamp of the end time of logs view
1639  * @returns boolen success (true) or failure(false)
1640  */
1641 function stats_temp_table_setup() {
1642     global $DB;
1644     $sql = "INSERT INTO {temp_enroled} (userid, courseid, roleid)
1646                SELECT ue.userid, e.courseid, ra.roleid
1647                 FROM {role_assignments} ra
1648                 JOIN {context} c ON (c.id = ra.contextid AND c.contextlevel = :courselevel)
1649                 JOIN {enrol} e ON e.courseid = c.instanceid
1650                 JOIN {user_enrolments} ue ON (ue.enrolid = e.id AND ue.userid = ra.userid)";
1652     return stats_run_query($sql, array('courselevel' => CONTEXT_COURSE));
1655 /**
1656  * Fills the temporary stats tables with new data
1657  *
1658  * This function is meant to be called to get a new day of data
1659  *
1660  * @param timestart timestamp of the start time of logs view
1661  * @param timeend timestamp of the end time of logs view
1662  * @returns boolen success (true) or failure(false)
1663  */
1664 function stats_temp_table_fill($timestart, $timeend) {
1665     global $DB;
1667     $sql = 'INSERT INTO {temp_log1} (userid, course, action)
1669             SELECT userid, course, action FROM {log}
1670              WHERE time >= ? AND time < ?';
1672     $DB->execute($sql, array($timestart, $timeend));
1674     $sql = 'INSERT INTO {temp_log2} (userid, course, action)
1676             SELECT userid, course, action FROM {temp_log1}';
1678     $DB->execute($sql);
1680     return true;
1684 /**
1685  * Deletes summary logs table for stats calculation
1686  *
1687  * @returns boolen success (true) or failure(false)
1688  */
1689 function stats_temp_table_clean() {
1690     global $DB;
1692     $sql = array();
1694     $sql['up1'] = 'INSERT INTO {stats_daily} (courseid, roleid, stattype, timeend, stat1, stat2)
1696                    SELECT courseid, roleid, stattype, timeend, stat1, stat2 FROM {temp_stats_daily}';
1698     $sql['up2'] = 'INSERT INTO {stats_user_daily}
1699                                (courseid, userid, roleid, timeend, statsreads, statswrites, stattype)
1701                    SELECT courseid, userid, roleid, timeend, statsreads, statswrites, stattype
1702                      FROM {temp_stats_user_daily}';
1704     foreach ($sql as $id => $query) {
1705         if (! stats_run_query($query)) {
1706             mtrace("Error during table cleanup!");
1707             return false;
1708         }
1709     }
1711     $tables = array('temp_log1', 'temp_log2', 'temp_stats_daily', 'temp_stats_user_daily');
1713     foreach ($tables as $name) {
1714         $DB->delete_records($name);
1715     }
1717     return true;