lib/statslib.php

   1 <?php
   2
   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/>.
  17
  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  */
  24
  25 defined('MOODLE_INTERNAL') || die();
  26
  27 /** THESE CONSTANTS ARE USED FOR THE REPORTING PAGE. */
  28
  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.
  34
  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.
  40
  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);
  46
  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);
  52
  53 // start after 10 = show weeklies
  54 define('STATS_TIME_LAST2MONTHS',12);
  55
  56 define('STATS_TIME_LAST3MONTHS',13);
  57 define('STATS_TIME_LAST4MONTHS',14);
  58 define('STATS_TIME_LAST5MONTHS',15);
  59 define('STATS_TIME_LAST6MONTHS',16);
  60
  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);
  68
  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
  73
  74 // Output string when nodebug is on
  75 define('STATS_PLACEHOLDER_OUTPUT', '.');
  76
  77 /**
  78  * Print daily cron progress
  79  * @param string $ident
  80  */
  81 function stats_progress($ident) {
  82     static $start = 0;
  83     static $init  = 0;
  84
  85     if ($ident == 'init') {
  86         $init = $start = microtime(true);
  87         return;
  88     }
  89
  90     $elapsed = round(microtime(true) - $start);
  91     $start   = microtime(true);
  92
  93     if (debugging('', DEBUG_ALL)) {
  94         mtrace("$ident:$elapsed ", '');
  95     } else {
  96         mtrace(STATS_PLACEHOLDER_OUTPUT, '');
  97     }
  98 }
  99
 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;
 108
 109     try {
 110         $DB->execute($sql, $parameters);
 111     } catch (dml_exception $e) {
 112
 113        if (debugging('', DEBUG_ALL)) {
 114            mtrace($e->getMessage());
 115        }
 116        return false;
 117     }
 118     return true;
 119 }
 120
 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;
 129     require_once($CFG->libdir.'/adminlib.php');
 130
 131     $now = time();
 132
 133     $fpcontext = context_course::instance(SITEID, MUST_EXIST);
 134
 135     // read last execution date from db
 136     if (!$timestart = get_config(NULL, 'statslastdaily')) {
 137         $timestart = stats_get_base_daily(stats_get_start_from('daily'));
 138         set_config('statslastdaily', $timestart);
 139     }
 140
 141     $nextmidnight = stats_get_next_day_start($timestart);
 142
 143     // are there any days that need to be processed?
 144     if ($now < $nextmidnight) {
 145         return true; // everything ok and up-to-date
 146     }
 147
 148     $timeout = empty($CFG->statsmaxruntime) ? 60*60*24 : $CFG->statsmaxruntime;
 149
 150     if (!set_cron_lock('statsrunning', $now + $timeout)) {
 151         return false;
 152     }
 153
 154     // first delete entries that should not be there yet
 155     $DB->delete_records_select('stats_daily',      "timeend > $timestart");
 156     $DB->delete_records_select('stats_user_daily', "timeend > $timestart");
 157
 158     // Read in a few things we'll use later
 159     $viewactions = stats_get_action_names('view');
 160     $postactions = stats_get_action_names('post');
 161
 162     $guest           = (int)$CFG->siteguest;
 163     $guestrole       = (int)$CFG->guestroleid;
 164     $defaultfproleid = (int)$CFG->defaultfrontpageroleid;
 165
 166     mtrace("Running daily statistics gathering, starting at $timestart:");
 167     cron_trace_time_and_memory();
 168
 169     $days  = 0;
 170     $total = 0;
 171     $failed  = false; // failed stats flag
 172     $timeout = false;
 173
 174     if (!stats_temp_table_create()) {
 175         $days = 1;
 176         $failed = true;
 177     }
 178     mtrace('Temporary tables created');
 179
 180     if(!stats_temp_table_setup()) {
 181         $days = 1;
 182         $failed = true;
 183     }
 184     mtrace('Enrolments calculated');
 185
 186     $totalactiveusers = $DB->count_records('user', array('deleted' => '0'));
 187
 188     while (!$failed && ($now > $nextmidnight)) {
 189         if ($days >= $maxdays) {
 190             $timeout = true;
 191             break;
 192         }
 193
 194         $days++;
 195         core_php_time_limit::raise($timeout - 200);
 196
 197         if ($days > 1) {
 198             // move the lock
 199             set_cron_lock('statsrunning', time() + $timeout, true);
 200         }
 201
 202         $daystart = time();
 203
 204         stats_progress('init');
 205
 206         if (!stats_temp_table_fill($timestart, $nextmidnight)) {
 207             $failed = true;
 208             break;
 209         }
 210
 211         // Find out if any logs available for this day
 212         $sql = "SELECT 'x' FROM {temp_log1} l";
 213         $logspresent = $DB->get_records_sql($sql, null, 0, 1);
 214
 215         if ($logspresent) {
 216             // Insert blank record to force Query 10 to generate additional row when no logs for
 217             // the site with userid 0 exist.  Added for backwards compatibility.
 218             $DB->insert_record('temp_log1', array('userid' => 0, 'course' => SITEID, 'action' => ''));
 219         }
 220
 221         // Calculate the number of active users today
 222         $sql = 'SELECT COUNT(DISTINCT u.id)
 223                   FROM {user} u
 224                   JOIN {temp_log1} l ON l.userid = u.id
 225                  WHERE u.deleted = 0';
 226         $dailyactiveusers = $DB->count_records_sql($sql);
 227
 228         stats_progress('0');
 229
 230         // Process login info first
 231         // Note: PostgreSQL doesn't like aliases in HAVING clauses
 232         $sql = "INSERT INTO {temp_stats_user_daily}
 233                             (stattype, timeend, courseid, userid, statsreads)
 234
 235                 SELECT 'logins', $nextmidnight AS timeend, ".SITEID." AS courseid,
 236                         userid, COUNT(id) AS statsreads
 237                   FROM {temp_log1} l
 238                  WHERE action = 'login'
 239               GROUP BY userid
 240                 HAVING COUNT(id) > 0";
 241
 242         if ($logspresent && !stats_run_query($sql)) {
 243             $failed = true;
 244             break;
 245         }
 246         $DB->update_temp_table_stats();
 247
 248         stats_progress('1');
 249
 250         $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
 251
 252                 SELECT 'logins' AS stattype, $nextmidnight AS timeend, ".SITEID." AS courseid, 0,
 253                        COALESCE(SUM(statsreads), 0) as stat1, COUNT('x') as stat2
 254                   FROM {temp_stats_user_daily}
 255                  WHERE stattype = 'logins' AND timeend = $nextmidnight";
 256
 257         if ($logspresent && !stats_run_query($sql)) {
 258             $failed = true;
 259             break;
 260         }
 261         stats_progress('2');
 262
 263
 264         // Enrolments and active enrolled users
 265         //
 266         // Unfortunately, we do not know how many users were registered
 267         // at given times in history :-(
 268         // - stat1: enrolled users
 269         // - stat2: enrolled users active in this period
 270         // - SITEID is special case here, because it's all about default enrolment
 271         //   in that case, we'll count non-deleted users.
 272         //
 273
 274         $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
 275
 276                 SELECT 'enrolments' as stattype, $nextmidnight as timeend, courseid, roleid,
 277                         COUNT(DISTINCT userid) as stat1, 0 as stat2
 278                   FROM {temp_enroled}
 279               GROUP BY courseid, roleid";
 280
 281         if (!stats_run_query($sql)) {
 282             $failed = true;
 283             break;
 284         }
 285         stats_progress('3');
 286
 287         // Set stat2 to the number distinct users with role assignments in the course that were active
 288         // using table alias in UPDATE does not work in pg < 8.2
 289         $sql = "UPDATE {temp_stats_daily}
 290                    SET stat2 = (
 291
 292                     SELECT COUNT(DISTINCT userid)
 293                       FROM {temp_enroled} te
 294                      WHERE roleid = {temp_stats_daily}.roleid
 295                        AND courseid = {temp_stats_daily}.courseid
 296                        AND EXISTS (
 297
 298                         SELECT 'x'
 299                           FROM {temp_log1} l
 300                          WHERE l.course = {temp_stats_daily}.courseid
 301                            AND l.userid = te.userid
 302                                   )
 303                                )
 304                  WHERE {temp_stats_daily}.stattype = 'enrolments'
 305                    AND {temp_stats_daily}.timeend = $nextmidnight
 306                    AND {temp_stats_daily}.courseid IN (
 307
 308                     SELECT DISTINCT course FROM {temp_log2})";
 309
 310         if ($logspresent && !stats_run_query($sql, array('courselevel'=>CONTEXT_COURSE))) {
 311             $failed = true;
 312             break;
 313         }
 314         stats_progress('4');
 315
 316         // Now get course total enrolments (roleid==0) - except frontpage
 317         $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
 318
 319                 SELECT 'enrolments', $nextmidnight AS timeend, te.courseid AS courseid, 0 AS roleid,
 320                        COUNT(DISTINCT userid) AS stat1, 0 AS stat2
 321                   FROM {temp_enroled} te
 322               GROUP BY courseid
 323                 HAVING COUNT(DISTINCT userid) > 0";
 324
 325         if ($logspresent && !stats_run_query($sql)) {
 326             $failed = true;
 327             break;
 328         }
 329         stats_progress('5');
 330
 331         // Set stat 2 to the number of enrolled users who were active in the course
 332         $sql = "UPDATE {temp_stats_daily}
 333                    SET stat2 = (
 334
 335                     SELECT COUNT(DISTINCT te.userid)
 336                       FROM {temp_enroled} te
 337                      WHERE te.courseid = {temp_stats_daily}.courseid
 338                        AND EXISTS (
 339
 340                         SELECT 'x'
 341                           FROM {temp_log1} l
 342                          WHERE l.course = {temp_stats_daily}.courseid
 343                            AND l.userid = te.userid
 344                                   )
 345                                )
 346
 347                  WHERE {temp_stats_daily}.stattype = 'enrolments'
 348                    AND {temp_stats_daily}.timeend = $nextmidnight
 349                    AND {temp_stats_daily}.roleid = 0
 350                    AND {temp_stats_daily}.courseid IN (
 351
 352                     SELECT l.course
 353                       FROM {temp_log2} l
 354                      WHERE l.course <> ".SITEID.")";
 355
 356         if ($logspresent && !stats_run_query($sql, array())) {
 357             $failed = true;
 358             break;
 359         }
 360         stats_progress('6');
 361
 362         // Frontpage(==site) enrolments total
 363         $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
 364
 365                 SELECT 'enrolments', $nextmidnight, ".SITEID.", 0, $totalactiveusers AS stat1,
 366                        $dailyactiveusers AS stat2" .
 367                 $DB->sql_null_from_clause();
 368
 369         if ($logspresent && !stats_run_query($sql)) {
 370             $failed = true;
 371             break;
 372         }
 373         // The steps up until this point, all add to {temp_stats_daily} and don't use new tables.
 374         // There is no point updating statistics as they won't be used until the DELETE below.
 375         $DB->update_temp_table_stats();
 376
 377         stats_progress('7');
 378
 379         // Default frontpage role enrolments are all site users (not deleted)
 380         if ($defaultfproleid) {
 381             // first remove default frontpage role counts if created by previous query
 382             $sql = "DELETE
 383                       FROM {temp_stats_daily}
 384                      WHERE stattype = 'enrolments'
 385                        AND courseid = ".SITEID."
 386                        AND roleid = $defaultfproleid
 387                        AND timeend = $nextmidnight";
 388
 389             if ($logspresent && !stats_run_query($sql)) {
 390                 $failed = true;
 391                 break;
 392             }
 393             stats_progress('8');
 394
 395             $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
 396
 397                     SELECT 'enrolments', $nextmidnight, ".SITEID.", $defaultfproleid,
 398                            $totalactiveusers AS stat1, $dailyactiveusers AS stat2" .
 399                     $DB->sql_null_from_clause();
 400
 401             if ($logspresent && !stats_run_query($sql)) {
 402                 $failed = true;
 403                 break;
 404             }
 405             stats_progress('9');
 406
 407         } else {
 408             stats_progress('x');
 409             stats_progress('x');
 410         }
 411
 412
 413         /// individual user stats (including not-logged-in) in each course, this is slow - reuse this data if possible
 414         list($viewactionssql, $params1) = $DB->get_in_or_equal($viewactions, SQL_PARAMS_NAMED, 'view');
 415         list($postactionssql, $params2) = $DB->get_in_or_equal($postactions, SQL_PARAMS_NAMED, 'post');
 416         $sql = "INSERT INTO {temp_stats_user_daily} (stattype, timeend, courseid, userid, statsreads, statswrites)
 417
 418                 SELECT 'activity' AS stattype, $nextmidnight AS timeend, course AS courseid, userid,
 419                        SUM(CASE WHEN action $viewactionssql THEN 1 ELSE 0 END) AS statsreads,
 420                        SUM(CASE WHEN action $postactionssql THEN 1 ELSE 0 END) AS statswrites
 421                   FROM {temp_log1} l
 422               GROUP BY userid, course";
 423
 424         if ($logspresent && !stats_run_query($sql, array_merge($params1, $params2))) {
 425             $failed = true;
 426             break;
 427         }
 428         stats_progress('10');
 429
 430
 431         /// How many view/post actions in each course total
 432         $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
 433
 434                 SELECT 'activity' AS stattype, $nextmidnight AS timeend, c.id AS courseid, 0,
 435                        SUM(CASE WHEN l.action $viewactionssql THEN 1 ELSE 0 END) AS stat1,
 436                        SUM(CASE WHEN l.action $postactionssql THEN 1 ELSE 0 END) AS stat2
 437                   FROM {course} c, {temp_log1} l
 438                  WHERE l.course = c.id
 439               GROUP BY c.id";
 440
 441         if ($logspresent && !stats_run_query($sql, array_merge($params1, $params2))) {
 442             $failed = true;
 443             break;
 444         }
 445         stats_progress('11');
 446
 447
 448         /// how many view actions for each course+role - excluding guests and frontpage
 449
 450         $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
 451
 452                 SELECT 'activity', $nextmidnight AS timeend, courseid, roleid, SUM(statsreads), SUM(statswrites)
 453                   FROM (
 454
 455                     SELECT pl.courseid, pl.roleid, sud.statsreads, sud.statswrites
 456                       FROM {temp_stats_user_daily} sud, (
 457
 458                         SELECT DISTINCT te.userid, te.roleid, te.courseid
 459                           FROM {temp_enroled} te
 460                          WHERE te.roleid <> $guestrole
 461                            AND te.userid <> $guest
 462                                                         ) pl
 463
 464                      WHERE sud.userid = pl.userid
 465                        AND sud.courseid = pl.courseid
 466                        AND sud.timeend = $nextmidnight
 467                        AND sud.stattype='activity'
 468                        ) inline_view
 469
 470               GROUP BY courseid, roleid
 471                 HAVING SUM(statsreads) > 0 OR SUM(statswrites) > 0";
 472
 473         if ($logspresent && !stats_run_query($sql, array('courselevel'=>CONTEXT_COURSE))) {
 474             $failed = true;
 475             break;
 476         }
 477         stats_progress('12');
 478
 479         /// how many view actions from guests only in each course - excluding frontpage
 480         /// normal users may enter course with temporary guest access too
 481
 482         $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
 483
 484                 SELECT 'activity', $nextmidnight AS timeend, courseid, $guestrole AS roleid,
 485                        SUM(statsreads), SUM(statswrites)
 486                   FROM (
 487
 488                     SELECT sud.courseid, sud.statsreads, sud.statswrites
 489                       FROM {temp_stats_user_daily} sud
 490                      WHERE sud.timeend = $nextmidnight
 491                        AND sud.courseid <> ".SITEID."
 492                        AND sud.stattype='activity'
 493                        AND (sud.userid = $guest OR sud.userid NOT IN (
 494
 495                         SELECT userid
 496                           FROM {temp_enroled} te
 497                          WHERE te.courseid = sud.courseid
 498                                                                      ))
 499                        ) inline_view
 500
 501               GROUP BY courseid
 502                 HAVING SUM(statsreads) > 0 OR SUM(statswrites) > 0";
 503
 504         if ($logspresent && !stats_run_query($sql, array())) {
 505             $failed = true;
 506             break;
 507         }
 508         stats_progress('13');
 509
 510
 511         /// How many view actions for each role on frontpage - excluding guests, not-logged-in and default frontpage role
 512         $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
 513
 514                 SELECT 'activity', $nextmidnight AS timeend, courseid, roleid,
 515                        SUM(statsreads), SUM(statswrites)
 516                   FROM (
 517                     SELECT pl.courseid, pl.roleid, sud.statsreads, sud.statswrites
 518                       FROM {temp_stats_user_daily} sud, (
 519
 520                         SELECT DISTINCT ra.userid, ra.roleid, c.instanceid AS courseid
 521                           FROM {role_assignments} ra
 522                           JOIN {context} c ON c.id = ra.contextid
 523                          WHERE ra.contextid = :fpcontext
 524                            AND ra.roleid <> $defaultfproleid
 525                            AND ra.roleid <> $guestrole
 526                            AND ra.userid <> $guest
 527                                                    ) pl
 528                      WHERE sud.userid = pl.userid
 529                        AND sud.courseid = pl.courseid
 530                        AND sud.timeend = $nextmidnight
 531                        AND sud.stattype='activity'
 532                        ) inline_view
 533
 534               GROUP BY courseid, roleid
 535                 HAVING SUM(statsreads) > 0 OR SUM(statswrites) > 0";
 536
 537         if ($logspresent && !stats_run_query($sql, array('fpcontext'=>$fpcontext->id))) {
 538             $failed = true;
 539             break;
 540         }
 541         stats_progress('14');
 542
 543
 544         // How many view actions for default frontpage role on frontpage only
 545         $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
 546
 547                 SELECT 'activity', timeend, courseid, $defaultfproleid AS roleid,
 548                        SUM(statsreads), SUM(statswrites)
 549                   FROM (
 550                     SELECT sud.timeend AS timeend, sud.courseid, sud.statsreads, sud.statswrites
 551                       FROM {temp_stats_user_daily} sud
 552                      WHERE sud.timeend = :nextm
 553                        AND sud.courseid = :siteid
 554                        AND sud.stattype='activity'
 555                        AND sud.userid <> $guest
 556                        AND sud.userid <> 0
 557                        AND sud.userid NOT IN (
 558
 559                         SELECT ra.userid
 560                           FROM {role_assignments} ra
 561                          WHERE ra.roleid <> $guestrole
 562                            AND ra.roleid <> $defaultfproleid
 563                            AND ra.contextid = :fpcontext)
 564                        ) inline_view
 565
 566               GROUP BY timeend, courseid
 567                 HAVING SUM(statsreads) > 0 OR SUM(statswrites) > 0";
 568
 569         if ($logspresent && !stats_run_query($sql, array('fpcontext'=>$fpcontext->id, 'siteid'=>SITEID, 'nextm'=>$nextmidnight))) {
 570             $failed = true;
 571             break;
 572         }
 573         $DB->update_temp_table_stats();
 574         stats_progress('15');
 575
 576         // How many view actions for guests or not-logged-in on frontpage
 577         $sql = "INSERT INTO {temp_stats_daily} (stattype, timeend, courseid, roleid, stat1, stat2)
 578
 579                 SELECT stattype, timeend, courseid, $guestrole AS roleid,
 580                        SUM(statsreads) AS stat1, SUM(statswrites) AS stat2
 581                   FROM (
 582                     SELECT sud.stattype, sud.timeend, sud.courseid,
 583                            sud.statsreads, sud.statswrites
 584                       FROM {temp_stats_user_daily} sud
 585                      WHERE (sud.userid = $guest OR sud.userid = 0)
 586                        AND sud.timeend = $nextmidnight
 587                        AND sud.courseid = ".SITEID."
 588                        AND sud.stattype='activity'
 589                        ) inline_view
 590                  GROUP BY stattype, timeend, courseid
 591                  HAVING SUM(statsreads) > 0 OR SUM(statswrites) > 0";
 592
 593         if ($logspresent && !stats_run_query($sql)) {
 594             $failed = true;
 595             break;
 596         }
 597         stats_progress('16');
 598
 599         stats_temp_table_clean();
 600
 601         stats_progress('out');
 602
 603         // remember processed days
 604         set_config('statslastdaily', $nextmidnight);
 605         $elapsed = time()-$daystart;
 606         mtrace("  finished until $nextmidnight: ".userdate($nextmidnight)." (in $elapsed s)");
 607         $total += $elapsed;
 608
 609         $timestart    = $nextmidnight;
 610         $nextmidnight = stats_get_next_day_start($nextmidnight);
 611     }
 612
 613     stats_temp_table_drop();
 614
 615     set_cron_lock('statsrunning', null);
 616
 617     if ($failed) {
 618         $days--;
 619         mtrace("...error occurred, completed $days days of statistics in {$total} s.");
 620         return false;
 621
 622     } else if ($timeout) {
 623         mtrace("...stopping early, reached maximum number of $maxdays days ({$total} s) - will continue next time.");
 624         return false;
 625
 626     } else {
 627         mtrace("...completed $days days of statistics in {$total} s.");
 628         return true;
 629     }
 630 }
 631
 632
 633 /**
 634  * Execute weekly statistics gathering
 635  * @return boolean success
 636  */
 637 function stats_cron_weekly() {
 638     global $CFG, $DB;
 639     require_once($CFG->libdir.'/adminlib.php');
 640
 641     $now = time();
 642
 643     // read last execution date from db
 644     if (!$timestart = get_config(NULL, 'statslastweekly')) {
 645         $timestart = stats_get_base_daily(stats_get_start_from('weekly'));
 646         set_config('statslastweekly', $timestart);
 647     }
 648
 649     $nextstartweek = stats_get_next_week_start($timestart);
 650
 651     // are there any weeks that need to be processed?
 652     if ($now < $nextstartweek) {
 653         return true; // everything ok and up-to-date
 654     }
 655
 656     $timeout = empty($CFG->statsmaxruntime) ? 60*60*24 : $CFG->statsmaxruntime;
 657
 658     if (!set_cron_lock('statsrunning', $now + $timeout)) {
 659         return false;
 660     }
 661
 662     // fisrt delete entries that should not be there yet
 663     $DB->delete_records_select('stats_weekly',      "timeend > $timestart");
 664     $DB->delete_records_select('stats_user_weekly', "timeend > $timestart");
 665
 666     mtrace("Running weekly statistics gathering, starting at $timestart:");
 667     cron_trace_time_and_memory();
 668
 669     $weeks = 0;
 670     while ($now > $nextstartweek) {
 671         core_php_time_limit::raise($timeout - 200);
 672         $weeks++;
 673
 674         if ($weeks > 1) {
 675             // move the lock
 676             set_cron_lock('statsrunning', time() + $timeout, true);
 677         }
 678
 679         $stattimesql = "timeend > $timestart AND timeend <= $nextstartweek";
 680
 681         $weekstart = time();
 682         stats_progress('init');
 683
 684     /// process login info first
 685         $sql = "INSERT INTO {stats_user_weekly} (stattype, timeend, courseid, userid, statsreads)
 686
 687                 SELECT 'logins', timeend, courseid, userid, SUM(statsreads)
 688                   FROM (
 689                            SELECT $nextstartweek AS timeend, courseid, userid, statsreads
 690                              FROM {stats_user_daily} sd
 691                             WHERE stattype = 'logins' AND $stattimesql
 692                        ) inline_view
 693               GROUP BY timeend, courseid, userid
 694                 HAVING SUM(statsreads) > 0";
 695
 696         $DB->execute($sql);
 697
 698         stats_progress('1');
 699
 700         $sql = "INSERT INTO {stats_weekly} (stattype, timeend, courseid, roleid, stat1, stat2)
 701
 702                 SELECT 'logins' AS stattype, $nextstartweek AS timeend, ".SITEID." as courseid, 0,
 703                        COALESCE((SELECT SUM(statsreads)
 704                                    FROM {stats_user_weekly} s1
 705                                   WHERE s1.stattype = 'logins' AND timeend = $nextstartweek), 0) AS nstat1,
 706                        (SELECT COUNT('x')
 707                           FROM {stats_user_weekly} s2
 708                          WHERE s2.stattype = 'logins' AND timeend = $nextstartweek) AS nstat2" .
 709                 $DB->sql_null_from_clause();
 710
 711         $DB->execute($sql);
 712
 713         stats_progress('2');
 714
 715     /// now enrolments averages
 716         $sql = "INSERT INTO {stats_weekly} (stattype, timeend, courseid, roleid, stat1, stat2)
 717
 718                 SELECT 'enrolments', ntimeend, courseid, roleid, " . $DB->sql_ceil('AVG(stat1)') . ", " . $DB->sql_ceil('AVG(stat2)') . "
 719                   FROM (
 720                            SELECT $nextstartweek AS ntimeend, courseid, roleid, stat1, stat2
 721                              FROM {stats_daily} sd
 722                             WHERE stattype = 'enrolments' AND $stattimesql
 723                        ) inline_view
 724               GROUP BY ntimeend, courseid, roleid";
 725
 726         $DB->execute($sql);
 727
 728         stats_progress('3');
 729
 730     /// activity read/write averages
 731         $sql = "INSERT INTO {stats_weekly} (stattype, timeend, courseid, roleid, stat1, stat2)
 732
 733                 SELECT 'activity', ntimeend, courseid, roleid, SUM(stat1), SUM(stat2)
 734                   FROM (
 735                            SELECT $nextstartweek AS ntimeend, courseid, roleid, stat1, stat2
 736                              FROM {stats_daily}
 737                             WHERE stattype = 'activity' AND $stattimesql
 738                        ) inline_view
 739               GROUP BY ntimeend, courseid, roleid";
 740
 741         $DB->execute($sql);
 742
 743         stats_progress('4');
 744
 745     /// user read/write averages
 746         $sql = "INSERT INTO {stats_user_weekly} (stattype, timeend, courseid, userid, statsreads, statswrites)
 747
 748                 SELECT 'activity', ntimeend, courseid, userid, SUM(statsreads), SUM(statswrites)
 749                   FROM (
 750                            SELECT $nextstartweek AS ntimeend, courseid, userid, statsreads, statswrites
 751                              FROM {stats_user_daily}
 752                             WHERE stattype = 'activity' AND $stattimesql
 753                        ) inline_view
 754               GROUP BY ntimeend, courseid, userid";
 755
 756         $DB->execute($sql);
 757
 758         stats_progress('5');
 759
 760         set_config('statslastweekly', $nextstartweek);
 761         $elapsed = time()-$weekstart;
 762         mtrace(" finished until $nextstartweek: ".userdate($nextstartweek) ." (in $elapsed s)");
 763
 764         $timestart     = $nextstartweek;
 765         $nextstartweek = stats_get_next_week_start($nextstartweek);
 766     }
 767
 768     set_cron_lock('statsrunning', null);
 769     mtrace("...completed $weeks weeks of statistics.");
 770     return true;
 771 }
 772
 773 /**
 774  * Execute monthly statistics gathering
 775  * @return boolean success
 776  */
 777 function stats_cron_monthly() {
 778     global $CFG, $DB;
 779     require_once($CFG->libdir.'/adminlib.php');
 780
 781     $now = time();
 782
 783     // read last execution date from db
 784     if (!$timestart = get_config(NULL, 'statslastmonthly')) {
 785         $timestart = stats_get_base_monthly(stats_get_start_from('monthly'));
 786         set_config('statslastmonthly', $timestart);
 787     }
 788
 789     $nextstartmonth = stats_get_next_month_start($timestart);
 790
 791     // are there any months that need to be processed?
 792     if ($now < $nextstartmonth) {
 793         return true; // everything ok and up-to-date
 794     }
 795
 796     $timeout = empty($CFG->statsmaxruntime) ? 60*60*24 : $CFG->statsmaxruntime;
 797
 798     if (!set_cron_lock('statsrunning', $now + $timeout)) {
 799         return false;
 800     }
 801
 802     // fisr delete entries that should not be there yet
 803     $DB->delete_records_select('stats_monthly', "timeend > $timestart");
 804     $DB->delete_records_select('stats_user_monthly', "timeend > $timestart");
 805
 806     $startmonth = stats_get_base_monthly($now);
 807
 808
 809     mtrace("Running monthly statistics gathering, starting at $timestart:");
 810     cron_trace_time_and_memory();
 811
 812     $months = 0;
 813     while ($now > $nextstartmonth) {
 814         core_php_time_limit::raise($timeout - 200);
 815         $months++;
 816
 817         if ($months > 1) {
 818             // move the lock
 819             set_cron_lock('statsrunning', time() + $timeout, true);
 820         }
 821
 822         $stattimesql = "timeend > $timestart AND timeend <= $nextstartmonth";
 823
 824         $monthstart = time();
 825         stats_progress('init');
 826
 827     /// process login info first
 828         $sql = "INSERT INTO {stats_user_monthly} (stattype, timeend, courseid, userid, statsreads)
 829
 830                 SELECT 'logins', timeend, courseid, userid, SUM(statsreads)
 831                   FROM (
 832                            SELECT $nextstartmonth AS timeend, courseid, userid, statsreads
 833                              FROM {stats_user_daily} sd
 834                             WHERE stattype = 'logins' AND $stattimesql
 835                        ) inline_view
 836               GROUP BY timeend, courseid, userid
 837                 HAVING SUM(statsreads) > 0";
 838
 839         $DB->execute($sql);
 840
 841         stats_progress('1');
 842
 843         $sql = "INSERT INTO {stats_monthly} (stattype, timeend, courseid, roleid, stat1, stat2)
 844
 845                 SELECT 'logins' AS stattype, $nextstartmonth AS timeend, ".SITEID." as courseid, 0,
 846                        COALESCE((SELECT SUM(statsreads)
 847                                    FROM {stats_user_monthly} s1
 848                                   WHERE s1.stattype = 'logins' AND timeend = $nextstartmonth), 0) AS nstat1,
 849                        (SELECT COUNT('x')
 850                           FROM {stats_user_monthly} s2
 851                          WHERE s2.stattype = 'logins' AND timeend = $nextstartmonth) AS nstat2" .
 852                 $DB->sql_null_from_clause();
 853
 854         $DB->execute($sql);
 855
 856         stats_progress('2');
 857
 858     /// now enrolments averages
 859         $sql = "INSERT INTO {stats_monthly} (stattype, timeend, courseid, roleid, stat1, stat2)
 860
 861                 SELECT 'enrolments', ntimeend, courseid, roleid, " . $DB->sql_ceil('AVG(stat1)') . ", " . $DB->sql_ceil('AVG(stat2)') . "
 862                   FROM (
 863                            SELECT $nextstartmonth AS ntimeend, courseid, roleid, stat1, stat2
 864                              FROM {stats_daily} sd
 865                             WHERE stattype = 'enrolments' AND $stattimesql
 866                        ) inline_view
 867               GROUP BY ntimeend, courseid, roleid";
 868
 869         $DB->execute($sql);
 870
 871         stats_progress('3');
 872
 873     /// activity read/write averages
 874         $sql = "INSERT INTO {stats_monthly} (stattype, timeend, courseid, roleid, stat1, stat2)
 875
 876                 SELECT 'activity', ntimeend, courseid, roleid, SUM(stat1), SUM(stat2)
 877                   FROM (
 878                            SELECT $nextstartmonth AS ntimeend, courseid, roleid, stat1, stat2
 879                              FROM {stats_daily}
 880                             WHERE stattype = 'activity' AND $stattimesql
 881                        ) inline_view
 882               GROUP BY ntimeend, courseid, roleid";
 883
 884         $DB->execute($sql);
 885
 886         stats_progress('4');
 887
 888     /// user read/write averages
 889         $sql = "INSERT INTO {stats_user_monthly} (stattype, timeend, courseid, userid, statsreads, statswrites)
 890
 891                 SELECT 'activity', ntimeend, courseid, userid, SUM(statsreads), SUM(statswrites)
 892                   FROM (
 893                            SELECT $nextstartmonth AS ntimeend, courseid, userid, statsreads, statswrites
 894                              FROM {stats_user_daily}
 895                             WHERE stattype = 'activity' AND $stattimesql
 896                        ) inline_view
 897               GROUP BY ntimeend, courseid, userid";
 898
 899         $DB->execute($sql);
 900
 901         stats_progress('5');
 902
 903         set_config('statslastmonthly', $nextstartmonth);
 904         $elapsed = time() - $monthstart;
 905         mtrace(" finished until $nextstartmonth: ".userdate($nextstartmonth) ." (in $elapsed s)");
 906
 907         $timestart      = $nextstartmonth;
 908         $nextstartmonth = stats_get_next_month_start($nextstartmonth);
 909     }
 910
 911     set_cron_lock('statsrunning', null);
 912     mtrace("...completed $months months of statistics.");
 913     return true;
 914 }
 915
 916 /**
 917  * Return starting date of stats processing
 918  * @param string $str name of table - daily, weekly or monthly
 919  * @return int timestamp
 920  */
 921 function stats_get_start_from($str) {
 922     global $CFG, $DB;
 923
 924     // are there any data in stats table? Should not be...
 925     if ($timeend = $DB->get_field_sql('SELECT MAX(timeend) FROM {stats_'.$str.'}')) {
 926         return $timeend;
 927     }
 928     // decide what to do based on our config setting (either all or none or a timestamp)
 929     switch ($CFG->statsfirstrun) {
 930         case 'all':
 931             $manager = get_log_manager();
 932             $stores = $manager->get_readers();
 933             $firstlog = false;
 934             foreach ($stores as $store) {
 935                 if ($store instanceof \core\log\sql_internal_table_reader) {
 936                     $logtable = $store->get_internal_log_table_name();
 937                     if (!$logtable) {
 938                         continue;
 939                     }
 940                     $first = $DB->get_field_sql("SELECT MIN(timecreated) FROM {{$logtable}}");
 941                     if ($first and (!$firstlog or $firstlog > $first)) {
 942                         $firstlog = $first;
 943                     }
 944                 }
 945             }
 946
 947             $first = $DB->get_field_sql('SELECT MIN(time) FROM {log}');
 948             if ($first and (!$firstlog or $firstlog > $first)) {
 949                 $firstlog = $first;
 950             }
 951
 952             if ($firstlog) {
 953                 return $firstlog;
 954             }
 955
 956         default:
 957             if (is_numeric($CFG->statsfirstrun)) {
 958                 return time() - $CFG->statsfirstrun;
 959             }
 960             // not a number? use next instead
 961         case 'none':
 962             return strtotime('-3 day', time());
 963     }
 964 }
 965
 966 /**
 967  * Start of day
 968  * @param int $time timestamp
 969  * @return int start of day
 970  */
 971 function stats_get_base_daily($time=0) {
 972     if (empty($time)) {
 973         $time = time();
 974     }
 975
 976     core_date::set_default_server_timezone();
 977     $time = strtotime(date('d-M-Y', $time));
 978
 979     return $time;
 980 }
 981
 982 /**
 983  * Start of week
 984  * @param int $time timestamp
 985  * @return int start of week
 986  */
 987 function stats_get_base_weekly($time=0) {
 988     global $CFG;
 989
 990     $time = stats_get_base_daily($time);
 991     $startday = $CFG->calendar_startwday;
 992
 993     core_date::set_default_server_timezone();
 994     $thisday = date('w', $time);
 995
 996     if ($thisday > $startday) {
 997         $time = $time - (($thisday - $startday) * 60*60*24);
 998     } else if ($thisday < $startday) {
 999         $time = $time - ((7 + $thisday - $startday) * 60*60*24);
1000     }
1001     return $time;
1002 }
1003
1004 /**
1005  * Start of month
1006  * @param int $time timestamp
1007  * @return int start of month
1008  */
1009 function stats_get_base_monthly($time=0) {
1010     if (empty($time)) {
1011         $time = time();
1012     }
1013
1014     core_date::set_default_server_timezone();
1015     $return = strtotime(date('1-M-Y', $time));
1016
1017     return $return;
1018 }
1019
1020 /**
1021  * Start of next day
1022  * @param int $time timestamp
1023  * @return start of next day
1024  */
1025 function stats_get_next_day_start($time) {
1026     $next = stats_get_base_daily($time);
1027     $nextdate = new DateTime();
1028     $nextdate->setTimestamp($next);
1029     $nextdate->add(new DateInterval('P1D'));
1030     return $nextdate->getTimestamp();
1031 }
1032
1033 /**
1034  * Start of next week
1035  * @param int $time timestamp
1036  * @return start of next week
1037  */
1038 function stats_get_next_week_start($time) {
1039     $next = stats_get_base_weekly($time);
1040     $nextdate = new DateTime();
1041     $nextdate->setTimestamp($next);
1042     $nextdate->add(new DateInterval('P1W'));
1043     return $nextdate->getTimestamp();
1044 }
1045
1046 /**
1047  * Start of next month
1048  * @param int $time timestamp
1049  * @return start of next month
1050  */
1051 function stats_get_next_month_start($time) {
1052     $next = stats_get_base_monthly($time);
1053     $nextdate = new DateTime();
1054     $nextdate->setTimestamp($next);
1055     $nextdate->add(new DateInterval('P1M'));
1056     return $nextdate->getTimestamp();
1057 }
1058
1059 /**
1060  * Remove old stats data
1061  */
1062 function stats_clean_old() {
1063     global $DB;
1064     mtrace("Running stats cleanup tasks...");
1065     cron_trace_time_and_memory();
1066     $deletebefore =  stats_get_base_monthly();
1067
1068     // delete dailies older than 3 months (to be safe)
1069     $deletebefore = strtotime('-3 months', $deletebefore);
1070     $DB->delete_records_select('stats_daily',      "timeend < $deletebefore");
1071     $DB->delete_records_select('stats_user_daily', "timeend < $deletebefore");
1072
1073     // delete weeklies older than 9  months (to be safe)
1074     $deletebefore = strtotime('-6 months', $deletebefore);
1075     $DB->delete_records_select('stats_weekly',      "timeend < $deletebefore");
1076     $DB->delete_records_select('stats_user_weekly', "timeend < $deletebefore");
1077
1078     // don't delete monthlies
1079
1080     mtrace("...stats cleanup finished");
1081 }
1082
1083 function stats_get_parameters($time,$report,$courseid,$mode,$roleid=0) {
1084     global $CFG, $DB;
1085
1086     $param = new stdClass();
1087     $param->params = array();
1088
1089     if ($time < 10) { // dailies
1090         // number of days to go back = 7* time
1091         $param->table = 'daily';
1092         $param->timeafter = strtotime("-".($time*7)." days",stats_get_base_daily());
1093     } elseif ($time < 20) { // weeklies
1094         // number of weeks to go back = time - 10 * 4 (weeks) + base week
1095         $param->table = 'weekly';
1096         $param->timeafter = strtotime("-".(($time - 10)*4)." weeks",stats_get_base_weekly());
1097     } else { // monthlies.
1098         // number of months to go back = time - 20 * months + base month
1099         $param->table = 'monthly';
1100         $param->timeafter = strtotime("-".($time - 20)." months",stats_get_base_monthly());
1101     }
1102
1103     $param->extras = '';
1104
1105     switch ($report) {
1106     // ******************** STATS_MODE_GENERAL ******************** //
1107     case STATS_REPORT_LOGINS:
1108         $param->fields = 'timeend,sum(stat1) as line1,sum(stat2) as line2';
1109         $param->fieldscomplete = true;
1110         $param->stattype = 'logins';
1111         $param->line1 = get_string('statslogins');
1112         $param->line2 = get_string('statsuniquelogins');
1113         if ($courseid == SITEID) {
1114             $param->extras = 'GROUP BY timeend';
1115         }
1116         break;
1117
1118     case STATS_REPORT_READS:
1119         $param->fields = $DB->sql_concat('timeend','roleid').' AS uniqueid, timeend, roleid, stat1 as line1';
1120         $param->fieldscomplete = true; // set this to true to avoid anything adding stuff to the list and breaking complex queries.
1121         $param->aggregategroupby = 'roleid';
1122         $param->stattype = 'activity';
1123         $param->crosstab = true;
1124         $param->extras = 'GROUP BY timeend,roleid,stat1';
1125         if ($courseid == SITEID) {
1126             $param->fields = $DB->sql_concat('timeend','roleid').' AS uniqueid, timeend, roleid, sum(stat1) as line1';
1127             $param->extras = 'GROUP BY timeend,roleid';
1128         }
1129         break;
1130
1131     case STATS_REPORT_WRITES:
1132         $param->fields = $DB->sql_concat('timeend','roleid').' AS uniqueid, timeend, roleid, stat2 as line1';
1133         $param->fieldscomplete = true; // set this to true to avoid anything adding stuff to the list and breaking complex queries.
1134         $param->aggregategroupby = 'roleid';
1135         $param->stattype = 'activity';
1136         $param->crosstab = true;
1137         $param->extras = 'GROUP BY timeend,roleid,stat2';
1138         if ($courseid == SITEID) {
1139             $param->fields = $DB->sql_concat('timeend','roleid').' AS uniqueid, timeend, roleid, sum(stat2) as line1';
1140             $param->extras = 'GROUP BY timeend,roleid';
1141         }
1142         break;
1143
1144     case STATS_REPORT_ACTIVITY:
1145         $param->fields = $DB->sql_concat('timeend','roleid').' AS uniqueid, timeend, roleid, sum(stat1+stat2) as line1';
1146         $param->fieldscomplete = true; // set this to true to avoid anything adding stuff to the list and breaking complex queries.
1147         $param->aggregategroupby = 'roleid';
1148         $param->stattype = 'activity';
1149         $param->crosstab = true;
1150         $param->extras = 'GROUP BY timeend,roleid';
1151         if ($courseid == SITEID) {
1152             $param->extras = 'GROUP BY timeend,roleid';
1153         }
1154         break;
1155
1156     case STATS_REPORT_ACTIVITYBYROLE;
1157         $param->fields = 'stat1 AS line1, stat2 AS line2';
1158         $param->stattype = 'activity';
1159         $rolename = $DB->get_field('role','name', array('id'=>$roleid));
1160         $param->line1 = $rolename . get_string('statsreads');
1161         $param->line2 = $rolename . get_string('statswrites');
1162         if ($courseid == SITEID) {
1163             $param->extras = 'GROUP BY timeend';
1164         }
1165         break;
1166
1167     // ******************** STATS_MODE_DETAILED ******************** //
1168     case STATS_REPORT_USER_ACTIVITY:
1169         $param->fields = 'statsreads as line1, statswrites as line2';
1170         $param->line1 = get_string('statsuserreads');
1171         $param->line2 = get_string('statsuserwrites');
1172         $param->stattype = 'activity';
1173         break;
1174
1175     case STATS_REPORT_USER_ALLACTIVITY:
1176         $param->fields = 'statsreads+statswrites as line1';
1177         $param->line1 = get_string('statsuseractivity');
1178         $param->stattype = 'activity';
1179         break;
1180
1181     case STATS_REPORT_USER_LOGINS:
1182         $param->fields = 'statsreads as line1';
1183         $param->line1 = get_string('statsuserlogins');
1184         $param->stattype = 'logins';
1185         break;
1186
1187     case STATS_REPORT_USER_VIEW:
1188         $param->fields = 'statsreads as line1, statswrites as line2, statsreads+statswrites as line3';
1189         $param->line1 = get_string('statsuserreads');
1190         $param->line2 = get_string('statsuserwrites');
1191         $param->line3 = get_string('statsuseractivity');
1192         $param->stattype = 'activity';
1193         break;
1194
1195     // ******************** STATS_MODE_RANKED ******************** //
1196     case STATS_REPORT_ACTIVE_COURSES:
1197         $param->fields = 'sum(stat1+stat2) AS line1';
1198         $param->stattype = 'activity';
1199         $param->orderby = 'line1 DESC';
1200         $param->line1 = get_string('useractivity');
1201         $param->graphline = 'line1';
1202         break;
1203
1204     case STATS_REPORT_ACTIVE_COURSES_WEIGHTED:
1205         $threshold = 0;
1206         if (!empty($CFG->statsuserthreshold) && is_numeric($CFG->statsuserthreshold)) {
1207             $threshold = $CFG->statsuserthreshold;
1208         }
1209         $param->fields = '';
1210         $param->sql = 'SELECT activity.courseid, activity.all_activity AS line1, enrolments.highest_enrolments AS line2,
1211                         activity.all_activity / enrolments.highest_enrolments as line3
1212                        FROM (
1213                             SELECT courseid, sum(stat1+stat2) AS all_activity
1214                               FROM {stats_'.$param->table.'}
1215                              WHERE stattype=\'activity\' AND timeend >= '.(int)$param->timeafter.' AND roleid = 0 GROUP BY courseid
1216                        ) activity
1217                        INNER JOIN
1218                             (
1219                             SELECT courseid, max(stat1) AS highest_enrolments
1220                               FROM {stats_'.$param->table.'}
1221                              WHERE stattype=\'enrolments\' AND timeend >= '.(int)$param->timeafter.' AND stat1 > '.(int)$threshold.'
1222                           GROUP BY courseid
1223                       ) enrolments
1224                       ON (activity.courseid = enrolments.courseid)
1225                       ORDER BY line3 DESC';
1226         $param->line1 = get_string('useractivity');
1227         $param->line2 = get_string('users');
1228         $param->line3 = get_string('activityweighted');
1229         $param->graphline = 'line3';
1230         break;
1231
1232     case STATS_REPORT_PARTICIPATORY_COURSES:
1233         $threshold = 0;
1234         if (!empty($CFG->statsuserthreshold) && is_numeric($CFG->statsuserthreshold)) {
1235             $threshold = $CFG->statsuserthreshold;
1236         }
1237         $param->fields = '';
1238         $param->sql = 'SELECT courseid, ' . $DB->sql_ceil('avg(all_enrolments)') . ' as line1, ' .
1239                          $DB->sql_ceil('avg(active_enrolments)') . ' as line2, avg(proportion_active) AS line3
1240                        FROM (
1241                            SELECT courseid, timeend, stat2 as active_enrolments,
1242                                   stat1 as all_enrolments, '.$DB->sql_cast_char2real('stat2').'/'.$DB->sql_cast_char2real('stat1').' AS proportion_active
1243                              FROM {stats_'.$param->table.'}
1244                             WHERE stattype=\'enrolments\' AND roleid = 0 AND stat1 > '.(int)$threshold.'
1245                        ) aq
1246                        WHERE timeend >= '.(int)$param->timeafter.'
1247                        GROUP BY courseid
1248                        ORDER BY line3 DESC';
1249
1250         $param->line1 = get_string('users');
1251         $param->line2 = get_string('activeusers');
1252         $param->line3 = get_string('participationratio');
1253         $param->graphline = 'line3';
1254         break;
1255
1256     case STATS_REPORT_PARTICIPATORY_COURSES_RW:
1257         $param->fields = '';
1258         $param->sql =  'SELECT courseid, sum(views) AS line1, sum(posts) AS line2,
1259                            avg(proportion_active) AS line3
1260                          FROM (
1261                            SELECT courseid, timeend, stat1 as views, stat2 AS posts,
1262                                   '.$DB->sql_cast_char2real('stat2').'/'.$DB->sql_cast_char2real('stat1').' as proportion_active
1263                              FROM {stats_'.$param->table.'}
1264                             WHERE stattype=\'activity\' AND roleid = 0 AND stat1 > 0
1265                        ) aq
1266                        WHERE timeend >= '.(int)$param->timeafter.'
1267                        GROUP BY courseid
1268                        ORDER BY line3 DESC';
1269         $param->line1 = get_string('views');
1270         $param->line2 = get_string('posts');
1271         $param->line3 = get_string('participationratio');
1272         $param->graphline = 'line3';
1273         break;
1274     }
1275
1276     /*
1277     if ($courseid == SITEID && $mode != STATS_MODE_RANKED) { // just aggregate all courses.
1278         $param->fields = preg_replace('/(?:sum)([a-zA-Z0-9+_]*)\W+as\W+([a-zA-Z0-9_]*)/i','sum($1) as $2',$param->fields);
1279         $param->extras = ' GROUP BY timeend'.((!empty($param->aggregategroupby)) ? ','.$param->aggregategroupby : '');
1280     }
1281     */
1282     //TODO must add the SITEID reports to the rest of the reports.
1283     return $param;
1284 }
1285
1286 function stats_get_view_actions() {
1287     return array('view','view all','history');
1288 }
1289
1290 function stats_get_post_actions() {
1291     return array('add','delete','edit','add mod','delete mod','edit section'.'enrol','loginas','new','unenrol','update','update mod');
1292 }
1293
1294 function stats_get_action_names($str) {
1295     global $CFG, $DB;
1296
1297     $mods = $DB->get_records('modules');
1298     $function = 'stats_get_'.$str.'_actions';
1299     $actions = $function();
1300     foreach ($mods as $mod) {
1301         $file = $CFG->dirroot.'/mod/'.$mod->name.'/lib.php';
1302         if (!is_readable($file)) {
1303             continue;
1304         }
1305         require_once($file);
1306         $function = $mod->name.'_get_'.$str.'_actions';
1307         if (function_exists($function)) {
1308             $mod_actions = $function();
1309             if (is_array($mod_actions)) {
1310                 $actions = array_merge($actions, $mod_actions);
1311             }
1312         }
1313     }
1314
1315     // The array_values() forces a stack-like array
1316     // so we can later loop over safely...
1317     $actions =  array_values(array_unique($actions));
1318     $c = count($actions);
1319     for ($n=0;$n<$c;$n++) {
1320         $actions[$n] = $actions[$n];
1321     }
1322     return $actions;
1323 }
1324
1325 function stats_get_time_options($now,$lastweekend,$lastmonthend,$earliestday,$earliestweek,$earliestmonth) {
1326
1327     $now = stats_get_base_daily(time());
1328     // it's really important that it's TIMEEND in the table. ie, tuesday 00:00:00 is monday night.
1329     // so we need to take a day off here (essentially add a day to $now
1330     $now += 60*60*24;
1331
1332     $timeoptions = array();
1333
1334     if ($now - (60*60*24*7) >= $earliestday) {
1335         $timeoptions[STATS_TIME_LASTWEEK] = get_string('numweeks','moodle',1);
1336     }
1337     if ($now - (60*60*24*14) >= $earliestday) {
1338         $timeoptions[STATS_TIME_LAST2WEEKS] = get_string('numweeks','moodle',2);
1339     }
1340     if ($now - (60*60*24*21) >= $earliestday) {
1341         $timeoptions[STATS_TIME_LAST3WEEKS] = get_string('numweeks','moodle',3);
1342     }
1343     if ($now - (60*60*24*28) >= $earliestday) {
1344         $timeoptions[STATS_TIME_LAST4WEEKS] = get_string('numweeks','moodle',4);// show dailies up to (including) here.
1345     }
1346     if ($lastweekend - (60*60*24*56) >= $earliestweek) {
1347         $timeoptions[STATS_TIME_LAST2MONTHS] = get_string('nummonths','moodle',2);
1348     }
1349     if ($lastweekend - (60*60*24*84) >= $earliestweek) {
1350         $timeoptions[STATS_TIME_LAST3MONTHS] = get_string('nummonths','moodle',3);
1351     }
1352     if ($lastweekend - (60*60*24*112) >= $earliestweek) {
1353         $timeoptions[STATS_TIME_LAST4MONTHS] = get_string('nummonths','moodle',4);
1354     }
1355     if ($lastweekend - (60*60*24*140) >= $earliestweek) {
1356         $timeoptions[STATS_TIME_LAST5MONTHS] = get_string('nummonths','moodle',5);
1357     }
1358     if ($lastweekend - (60*60*24*168) >= $earliestweek) {
1359         $timeoptions[STATS_TIME_LAST6MONTHS] = get_string('nummonths','moodle',6); // show weeklies up to (including) here
1360     }
1361     if (strtotime('-7 months',$lastmonthend) >= $earliestmonth) {
1362         $timeoptions[STATS_TIME_LAST7MONTHS] = get_string('nummonths','moodle',7);
1363     }
1364     if (strtotime('-8 months',$lastmonthend) >= $earliestmonth) {
1365         $timeoptions[STATS_TIME_LAST8MONTHS] = get_string('nummonths','moodle',8);
1366     }
1367     if (strtotime('-9 months',$lastmonthend) >= $earliestmonth) {
1368         $timeoptions[STATS_TIME_LAST9MONTHS] = get_string('nummonths','moodle',9);
1369     }
1370     if (strtotime('-10 months',$lastmonthend) >= $earliestmonth) {
1371         $timeoptions[STATS_TIME_LAST10MONTHS] = get_string('nummonths','moodle',10);
1372     }
1373     if (strtotime('-11 months',$lastmonthend) >= $earliestmonth) {
1374         $timeoptions[STATS_TIME_LAST11MONTHS] = get_string('nummonths','moodle',11);
1375     }
1376     if (strtotime('-1 year',$lastmonthend) >= $earliestmonth) {
1377         $timeoptions[STATS_TIME_LASTYEAR] = get_string('lastyear');
1378     }
1379
1380     $years = (int)date('y', $now) - (int)date('y', $earliestmonth);
1381     if ($years > 1) {
1382         for($i = 2; $i <= $years; $i++) {
1383             $timeoptions[$i*12+20] = get_string('numyears', 'moodle', $i);
1384         }
1385     }
1386
1387     return $timeoptions;
1388 }
1389
1390 function stats_get_report_options($courseid,$mode) {
1391     global $CFG, $DB;
1392
1393     $reportoptions = array();
1394
1395     switch ($mode) {
1396     case STATS_MODE_GENERAL:
1397         $reportoptions[STATS_REPORT_ACTIVITY] = get_string('statsreport'.STATS_REPORT_ACTIVITY);
1398         if ($courseid != SITEID && $context = context_course::instance($courseid)) {
1399             $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';
1400             if ($roles = $DB->get_records_sql($sql, array('courseid' => $courseid))) {
1401                 foreach ($roles as $role) {
1402                     $reportoptions[STATS_REPORT_ACTIVITYBYROLE.$role->id] = get_string('statsreport'.STATS_REPORT_ACTIVITYBYROLE). ' '.$role->name;
1403                 }
1404             }
1405         }
1406         $reportoptions[STATS_REPORT_READS] = get_string('statsreport'.STATS_REPORT_READS);
1407         $reportoptions[STATS_REPORT_WRITES] = get_string('statsreport'.STATS_REPORT_WRITES);
1408         if ($courseid == SITEID) {
1409             $reportoptions[STATS_REPORT_LOGINS] = get_string('statsreport'.STATS_REPORT_LOGINS);
1410         }
1411
1412         break;
1413     case STATS_MODE_DETAILED:
1414         $reportoptions[STATS_REPORT_USER_ACTIVITY] = get_string('statsreport'.STATS_REPORT_USER_ACTIVITY);
1415         $reportoptions[STATS_REPORT_USER_ALLACTIVITY] = get_string('statsreport'.STATS_REPORT_USER_ALLACTIVITY);
1416         if (has_capability('report/stats:view', context_system::instance())) {
1417             $site = get_site();
1418             $reportoptions[STATS_REPORT_USER_LOGINS] = get_string('statsreport'.STATS_REPORT_USER_LOGINS);
1419         }
1420         break;
1421     case STATS_MODE_RANKED:
1422         if (has_capability('report/stats:view', context_system::instance())) {
1423             $reportoptions[STATS_REPORT_ACTIVE_COURSES] = get_string('statsreport'.STATS_REPORT_ACTIVE_COURSES);
1424             $reportoptions[STATS_REPORT_ACTIVE_COURSES_WEIGHTED] = get_string('statsreport'.STATS_REPORT_ACTIVE_COURSES_WEIGHTED);
1425             $reportoptions[STATS_REPORT_PARTICIPATORY_COURSES] = get_string('statsreport'.STATS_REPORT_PARTICIPATORY_COURSES);
1426             $reportoptions[STATS_REPORT_PARTICIPATORY_COURSES_RW] = get_string('statsreport'.STATS_REPORT_PARTICIPATORY_COURSES_RW);
1427         }
1428         break;
1429     }
1430
1431     return $reportoptions;
1432 }
1433
1434 /**
1435  * Fix missing entries in the statistics.
1436  *
1437  * This creates a dummy stat when nothing happened during a day/week/month.
1438  *
1439  * @param array $stats array of statistics.
1440  * @param int $timeafter unused.
1441  * @param string $timestr type of statistics to generate (dayly, weekly, monthly).
1442  * @param boolean $line2
1443  * @param boolean $line3
1444  * @return array of fixed statistics.
1445  */
1446 function stats_fix_zeros($stats,$timeafter,$timestr,$line2=true,$line3=false) {
1447
1448     if (empty($stats)) {
1449         return;
1450     }
1451
1452     $timestr = str_replace('user_','',$timestr); // just in case.
1453
1454     // Gets the current user base time.
1455     $fun = 'stats_get_base_'.$timestr;
1456     $now = $fun();
1457
1458     // Extract the ending time of the statistics.
1459     $actualtimes = array();
1460     $actualtimeshour = null;
1461     foreach ($stats as $statid => $s) {
1462         // Normalise the month date to the 1st if for any reason it's set to later. But we ignore
1463         // anything above or equal to 29 because sometimes we get the end of the month. Also, we will
1464         // set the hours of the result to all of them, that way we prevent DST differences.
1465         if ($timestr == 'monthly') {
1466             $day = date('d', $s->timeend);
1467             if (date('d', $s->timeend) > 1 && date('d', $s->timeend) < 29) {
1468                 $day = 1;
1469             }
1470             if (is_null($actualtimeshour)) {
1471                 $actualtimeshour = date('H', $s->timeend);
1472             }
1473             $s->timeend = mktime($actualtimeshour, 0, 0, date('m', $s->timeend), $day, date('Y', $s->timeend));
1474         }
1475         $stats[$statid] = $s;
1476         $actualtimes[] = $s->timeend;
1477     }
1478
1479     $actualtimesvalues = array_values($actualtimes);
1480     $timeafter = array_pop($actualtimesvalues);
1481
1482     // Generate a base timestamp for each possible month/week/day.
1483     $times = array();
1484     while ($timeafter < $now) {
1485         $times[] = $timeafter;
1486         if ($timestr == 'daily') {
1487             $timeafter = stats_get_next_day_start($timeafter);
1488         } else if ($timestr == 'weekly') {
1489             $timeafter = stats_get_next_week_start($timeafter);
1490         } else if ($timestr == 'monthly') {
1491             // We can't just simply +1 month because the 31st Jan + 1 month = 2nd of March.
1492             $year = date('Y', $timeafter);
1493             $month = date('m', $timeafter);
1494             $day = date('d', $timeafter);
1495             $dayofnextmonth = $day;
1496             if ($day >= 29) {
1497                 $daysinmonth = date('n', mktime(0, 0, 0, $month+1, 1, $year));
1498                 if ($day > $daysinmonth) {
1499                     $dayofnextmonth = $daysinmonth;
1500                 }
1501             }
1502             $timeafter = mktime($actualtimeshour, 0, 0, $month+1, $dayofnextmonth, $year);
1503         } else {
1504             // This will put us in a never ending loop.
1505             return $stats;
1506         }
1507     }
1508
1509     // Add the base timestamp to the statistics if not present.
1510     foreach ($times as $count => $time) {
1511         if (!in_array($time,$actualtimes) && $count != count($times) -1) {
1512             $newobj = new StdClass;
1513             $newobj->timeend = $time;
1514             $newobj->id = 0;
1515             $newobj->roleid = 0;
1516             $newobj->line1 = 0;
1517             if (!empty($line2)) {
1518                 $newobj->line2 = 0;
1519             }
1520             if (!empty($line3)) {
1521                 $newobj->line3 = 0;
1522             }
1523             $newobj->zerofixed = true;
1524             $stats[] = $newobj;
1525         }
1526     }
1527
1528     usort($stats,"stats_compare_times");
1529     return $stats;
1530 }
1531
1532 // helper function to sort arrays by $obj->timeend
1533 function stats_compare_times($a,$b) {
1534    if ($a->timeend == $b->timeend) {
1535        return 0;
1536    }
1537    return ($a->timeend > $b->timeend) ? -1 : 1;
1538 }
1539
1540 function stats_check_uptodate($courseid=0) {
1541     global $CFG, $DB;
1542
1543     if (empty($courseid)) {
1544         $courseid = SITEID;
1545     }
1546
1547     $latestday = stats_get_start_from('daily');
1548
1549     if ((time() - 60*60*24*2) < $latestday) { // we're ok
1550         return NULL;
1551     }
1552
1553     $a = new stdClass();
1554     $a->daysdone = $DB->get_field_sql("SELECT COUNT(DISTINCT(timeend)) FROM {stats_daily}");
1555
1556     // how many days between the last day and now?
1557     $a->dayspending = ceil((stats_get_base_daily() - $latestday)/(60*60*24));
1558
1559     if ($a->dayspending == 0 && $a->daysdone != 0) {
1560         return NULL; // we've only just started...
1561     }
1562
1563     //return error as string
1564     return get_string('statscatchupmode','error',$a);
1565 }
1566
1567 /**
1568  * Create temporary tables to speed up log generation
1569  */
1570 function stats_temp_table_create() {
1571     global $CFG, $DB;
1572
1573     $dbman = $DB->get_manager(); // We are going to use database_manager services
1574
1575     stats_temp_table_drop();
1576
1577     $tables = array();
1578
1579     /// Define tables user to be created
1580     $table = new xmldb_table('temp_stats_daily');
1581     $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
1582     $table->add_field('courseid', XMLDB_TYPE_INTEGER, 10, null, XMLDB_NOTNULL, null, '0');
1583     $table->add_field('timeend', XMLDB_TYPE_INTEGER, 10, null, XMLDB_NOTNULL, null, '0');
1584     $table->add_field('roleid', XMLDB_TYPE_INTEGER, 10, null, XMLDB_NOTNULL, null, '0');
1585     $table->add_field('stattype', XMLDB_TYPE_CHAR, 20, null, XMLDB_NOTNULL, null, 'activity');
1586     $table->add_field('stat1', XMLDB_TYPE_INTEGER, 10, null, XMLDB_NOTNULL, null, '0');
1587     $table->add_field('stat2', XMLDB_TYPE_INTEGER, 10, null, XMLDB_NOTNULL, null, '0');
1588     $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
1589     $table->add_index('courseid', XMLDB_INDEX_NOTUNIQUE, array('courseid'));
1590     $table->add_index('timeend', XMLDB_INDEX_NOTUNIQUE, array('timeend'));
1591     $table->add_index('roleid', XMLDB_INDEX_NOTUNIQUE, array('roleid'));
1592     $tables['temp_stats_daily'] = $table;
1593
1594     $table = new xmldb_table('temp_stats_user_daily');
1595     $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
1596     $table->add_field('courseid', XMLDB_TYPE_INTEGER, 10, null, XMLDB_NOTNULL, null, '0');
1597     $table->add_field('userid', XMLDB_TYPE_INTEGER, 10, null, XMLDB_NOTNULL, null, '0');
1598     $table->add_field('roleid', XMLDB_TYPE_INTEGER, 10, null, XMLDB_NOTNULL, null, '0');
1599     $table->add_field('timeend', XMLDB_TYPE_INTEGER, 10, null, XMLDB_NOTNULL, null, '0');
1600     $table->add_field('statsreads', XMLDB_TYPE_INTEGER, 10, null, XMLDB_NOTNULL, null, '0');
1601     $table->add_field('statswrites', XMLDB_TYPE_INTEGER, 10, null, XMLDB_NOTNULL, null, '0');
1602     $table->add_field('stattype', XMLDB_TYPE_CHAR, 30, null, XMLDB_NOTNULL, null, null);
1603     $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
1604     $table->add_index('courseid', XMLDB_INDEX_NOTUNIQUE, array('courseid'));
1605     $table->add_index('userid', XMLDB_INDEX_NOTUNIQUE, array('userid'));
1606     $table->add_index('timeend', XMLDB_INDEX_NOTUNIQUE, array('timeend'));
1607     $table->add_index('roleid', XMLDB_INDEX_NOTUNIQUE, array('roleid'));
1608     $tables['temp_stats_user_daily'] = $table;
1609
1610     $table = new xmldb_table('temp_enroled');
1611     $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
1612     $table->add_field('userid', XMLDB_TYPE_INTEGER, 10, null, XMLDB_NOTNULL, null, '0');
1613     $table->add_field('courseid', XMLDB_TYPE_INTEGER, 10, null, XMLDB_NOTNULL, null, '0');
1614     $table->add_field('roleid', XMLDB_TYPE_INTEGER, 10, null, XMLDB_NOTNULL, null, null);
1615     $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
1616     $table->add_index('userid', XMLDB_INDEX_NOTUNIQUE, array('userid'));
1617     $table->add_index('courseid', XMLDB_INDEX_NOTUNIQUE, array('courseid'));
1618     $table->add_index('roleid', XMLDB_INDEX_NOTUNIQUE, array('roleid'));
1619     $tables['temp_enroled'] = $table;
1620
1621
1622     $table = new xmldb_table('temp_log1');
1623     $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
1624     $table->add_field('userid', XMLDB_TYPE_INTEGER, 10, null, XMLDB_NOTNULL, null, '0');
1625     $table->add_field('course', XMLDB_TYPE_INTEGER, 10, null, XMLDB_NOTNULL, null, '0');
1626     $table->add_field('action', XMLDB_TYPE_CHAR, 40, null, XMLDB_NOTNULL, null, null);
1627     $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
1628     $table->add_index('action', XMLDB_INDEX_NOTUNIQUE, array('action'));
1629     $table->add_index('course', XMLDB_INDEX_NOTUNIQUE, array('course'));
1630     $table->add_index('user', XMLDB_INDEX_NOTUNIQUE, array('userid'));
1631     $table->add_index('usercourseaction', XMLDB_INDEX_NOTUNIQUE, array('userid','course','action'));
1632     $tables['temp_log1'] = $table;
1633
1634     /// temp_log2 is exactly the same as temp_log1.
1635     $tables['temp_log2'] = clone $tables['temp_log1'];
1636     $tables['temp_log2']->setName('temp_log2');
1637
1638     try {
1639
1640         foreach ($tables as $table) {
1641             $dbman->create_temp_table($table);
1642         }
1643
1644     } catch (Exception $e) {
1645         mtrace('Temporary table creation failed: '. $e->getMessage());
1646         return false;
1647     }
1648
1649     return true;
1650 }
1651
1652 /**
1653  * Deletes summary logs table for stats calculation
1654  */
1655 function stats_temp_table_drop() {
1656     global $DB;
1657
1658     $dbman = $DB->get_manager();
1659
1660     $tables = array('temp_log1', 'temp_log2', 'temp_stats_daily', 'temp_stats_user_daily', 'temp_enroled');
1661
1662     foreach ($tables as $name) {
1663
1664         if ($dbman->table_exists($name)) {
1665             $table = new xmldb_table($name);
1666
1667             try {
1668                 $dbman->drop_table($table);
1669             } catch (Exception $e) {
1670                 mtrace("Error occured while dropping temporary tables!");
1671             }
1672         }
1673     }
1674 }
1675
1676 /**
1677  * Fills the temporary stats tables with new data
1678  *
1679  * This function is meant to be called once at the start of stats generation
1680  *
1681  * @param int timestart timestamp of the start time of logs view
1682  * @param int timeend timestamp of the end time of logs view
1683  * @return bool success (true) or failure(false)
1684  */
1685 function stats_temp_table_setup() {
1686     global $DB;
1687
1688     $sql = "INSERT INTO {temp_enroled} (userid, courseid, roleid)
1689
1690                SELECT ue.userid, e.courseid, ra.roleid
1691                 FROM {role_assignments} ra
1692                 JOIN {context} c ON (c.id = ra.contextid AND c.contextlevel = :courselevel)
1693                 JOIN {enrol} e ON e.courseid = c.instanceid
1694                 JOIN {user_enrolments} ue ON (ue.enrolid = e.id AND ue.userid = ra.userid)";
1695
1696     return stats_run_query($sql, array('courselevel' => CONTEXT_COURSE));
1697 }
1698
1699 /**
1700  * Fills the temporary stats tables with new data
1701  *
1702  * This function is meant to be called to get a new day of data
1703  *
1704  * @param int timestamp of the start time of logs view
1705  * @param int timestamp of the end time of logs view
1706  * @return bool success (true) or failure(false)
1707  */
1708 function stats_temp_table_fill($timestart, $timeend) {
1709     global $DB;
1710
1711     // First decide from where we want the data.
1712
1713     $params = array('timestart' => $timestart,
1714                     'timeend' => $timeend,
1715                     'participating' => \core\event\base::LEVEL_PARTICIPATING,
1716                     'teaching' => \core\event\base::LEVEL_TEACHING,
1717                     'loginevent1' => '\core\event\user_loggedin',
1718                     'loginevent2' => '\core\event\user_loggedin',
1719     );
1720
1721     $filled = false;
1722     $manager = get_log_manager();
1723     $stores = $manager->get_readers();
1724     foreach ($stores as $store) {
1725         if ($store instanceof \core\log\sql_internal_table_reader) {
1726             $logtable = $store->get_internal_log_table_name();
1727             if (!$logtable) {
1728                 continue;
1729             }
1730
1731             $sql = "SELECT COUNT('x')
1732                       FROM {{$logtable}}
1733                      WHERE timecreated >= :timestart AND timecreated < :timeend";
1734
1735             if (!$DB->get_field_sql($sql, $params)) {
1736                 continue;
1737             }
1738
1739             // Let's fake the old records using new log data.
1740             // We want only data relevant to educational process
1741             // done by real users.
1742
1743             $sql = "INSERT INTO {temp_log1} (userid, course, action)
1744
1745             SELECT userid,
1746                    CASE
1747                       WHEN courseid IS NULL THEN ".SITEID."
1748                       WHEN courseid = 0 THEN ".SITEID."
1749                       ELSE courseid
1750                    END,
1751                    CASE
1752                        WHEN eventname = :loginevent1 THEN 'login'
1753                        WHEN crud = 'r' THEN 'view'
1754                        ELSE 'update'
1755                    END
1756               FROM {{$logtable}}
1757              WHERE timecreated >= :timestart AND timecreated < :timeend
1758                    AND (origin = 'web' OR origin = 'ws')
1759                    AND (edulevel = :participating OR edulevel = :teaching OR eventname = :loginevent2)";
1760
1761             $DB->execute($sql, $params);
1762             $filled = true;
1763         }
1764     }
1765
1766     if (!$filled) {
1767         // Fallback to legacy data.
1768         $sql = "INSERT INTO {temp_log1} (userid, course, action)
1769
1770             SELECT userid, course, action
1771               FROM {log}
1772              WHERE time >= :timestart AND time < :timeend";
1773
1774         $DB->execute($sql, $params);
1775     }
1776
1777     $sql = 'INSERT INTO {temp_log2} (userid, course, action)
1778
1779             SELECT userid, course, action FROM {temp_log1}';
1780
1781     $DB->execute($sql);
1782
1783     // We have just loaded all the temp tables, collect statistics for that.
1784     $DB->update_temp_table_stats();
1785
1786     return true;
1787 }
1788
1789
1790 /**
1791  * Deletes summary logs table for stats calculation
1792  *
1793  * @return bool success (true) or failure(false)
1794  */
1795 function stats_temp_table_clean() {
1796     global $DB;
1797
1798     $sql = array();
1799
1800     $sql['up1'] = 'INSERT INTO {stats_daily} (courseid, roleid, stattype, timeend, stat1, stat2)
1801
1802                    SELECT courseid, roleid, stattype, timeend, stat1, stat2 FROM {temp_stats_daily}';
1803
1804     $sql['up2'] = 'INSERT INTO {stats_user_daily}
1805                                (courseid, userid, roleid, timeend, statsreads, statswrites, stattype)
1806
1807                    SELECT courseid, userid, roleid, timeend, statsreads, statswrites, stattype
1808                      FROM {temp_stats_user_daily}';
1809
1810     foreach ($sql as $id => $query) {
1811         if (! stats_run_query($query)) {
1812             mtrace("Error during table cleanup!");
1813             return false;
1814         }
1815     }
1816
1817     $tables = array('temp_log1', 'temp_log2', 'temp_stats_daily', 'temp_stats_user_daily');
1818
1819     foreach ($tables as $name) {
1820         $DB->delete_records($name);
1821     }
1822
1823     return true;
1824 }