first commit

analytics/classes/local/analyser/base.php

@@ -0,0 +1,525 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Analysers base class.
+ *
+ * @package   core_analytics
+ * @copyright 2016 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\analyser;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Analysers base class.
+ *
+ * @package   core_analytics
+ * @copyright 2016 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+abstract class base {
+
+    /**
+     * @var int
+     */
+    protected $modelid;
+
+    /**
+     * The model target.
+     *
+     * @var \core_analytics\local\target\base
+     */
+    protected $target;
+
+    /**
+     * The model indicators.
+     *
+     * @var \core_analytics\local\indicator\base[]
+     */
+    protected $indicators;
+
+    /**
+     * Time splitting methods to use.
+     *
+     * Multiple time splitting methods during evaluation and 1 single
+     * time splitting method once the model is enabled.
+     *
+     * @var \core_analytics\local\time_splitting\base[]
+     */
+    protected $timesplittings;
+
+    /**
+     * Execution options.
+     *
+     * @var array
+     */
+    protected $options;
+
+    /**
+     * Simple log array.
+     *
+     * @var string[]
+     */
+    protected $log;
+
+    /**
+     * Constructor method.
+     *
+     * @param int $modelid
+     * @param \core_analytics\local\target\base $target
+     * @param \core_analytics\local\indicator\base[] $indicators
+     * @param \core_analytics\local\time_splitting\base[] $timesplittings
+     * @param array $options
+     * @return void
+     */
+    public function __construct($modelid, \core_analytics\local\target\base $target, $indicators, $timesplittings, $options) {
+        $this->modelid = $modelid;
+        $this->target = $target;
+        $this->indicators = $indicators;
+        $this->timesplittings = $timesplittings;
+
+        if (empty($options['evaluation'])) {
+            $options['evaluation'] = false;
+        }
+        $this->options = $options;
+
+        // Checks if the analyser satisfies the indicators requirements.
+        $this->check_indicators_requirements();
+
+        $this->log = array();
+    }
+
+    /**
+     * @deprecated since Moodle 3.7
+     */
+    public function get_analysables() {
+        throw new \coding_exception('get_analysables() method has been removed and cannot be used any more.');
+    }
+
+    /**
+     * Returns the list of analysable elements available on the site.
+     *
+     * A relatively complex SQL query should be set so that we take into account which analysable elements
+     * have already been processed and the order in which they have been processed. Helper methods are available
+     * to ease to implementation of get_analysables_iterator: get_iterator_sql and order_sql.
+     *
+     * @param string|null $action 'prediction', 'training' or null if no specific action needed.
+     * @param \context[] $contexts Only analysables that depend on the provided contexts. All analysables in the system if empty.
+     * @return \Iterator
+     */
+    abstract public function get_analysables_iterator(?string $action = null, array $contexts = []);
+
+    /**
+     * This function returns this analysable list of samples.
+     *
+     * @param \core_analytics\analysable $analysable
+     * @return array array[0] = int[] (sampleids) and array[1] = array (samplesdata)
+     */
+    abstract public function get_all_samples(\core_analytics\analysable $analysable);
+
+    /**
+     * This function returns the samples data from a list of sample ids.
+     *
+     * @param int[] $sampleids
+     * @return array array[0] = int[] (sampleids) and array[1] = array (samplesdata)
+     */
+    abstract public function get_samples($sampleids);
+
+    /**
+     * Returns the analysable of a sample.
+     *
+     * @param int $sampleid
+     * @return \core_analytics\analysable
+     */
+    abstract public function get_sample_analysable($sampleid);
+
+    /**
+     * Returns the sample's origin in moodle database.
+     *
+     * @return string
+     */
+    abstract public function get_samples_origin();
+
+    /**
+     * Returns the context of a sample.
+     *
+     * moodle/analytics:listinsights will be required at this level to access the sample predictions.
+     *
+     * @param int $sampleid
+     * @return \context
+     */
+    abstract public function sample_access_context($sampleid);
+
+    /**
+     * Describes a sample with a description summary and a \renderable (an image for example)
+     *
+     * @param int $sampleid
+     * @param int $contextid
+     * @param array $sampledata
+     * @return array array(string, \renderable)
+     */
+    abstract public function sample_description($sampleid, $contextid, $sampledata);
+
+    /**
+     * Model id getter.
+     * @return int
+     */
+    public function get_modelid(): int {
+        return $this->modelid;
+    }
+
+    /**
+     * Options getter.
+     * @return array
+     */
+    public function get_options(): array {
+        return $this->options;
+    }
+
+    /**
+     * Returns the analysed target.
+     *
+     * @return \core_analytics\local\target\base
+     */
+    public function get_target(): \core_analytics\local\target\base {
+        return $this->target;
+    }
+
+    /**
+     * Getter for time splittings.
+     *
+     * @return \core_analytics\local\time_splitting\base
+     */
+    public function get_timesplittings(): array {
+        return $this->timesplittings;
+    }
+
+    /**
+     * Getter for indicators.
+     *
+     * @return \core_analytics\local\indicator\base
+     */
+    public function get_indicators(): array {
+        return $this->indicators;
+    }
+
+    /**
+     * Instantiate the indicators.
+     *
+     * @return \core_analytics\local\indicator\base[]
+     */
+    public function instantiate_indicators() {
+        foreach ($this->indicators as $key => $indicator) {
+            $this->indicators[$key] = call_user_func(array($indicator, 'instance'));
+        }
+
+        // Free memory ASAP.
+        gc_collect_cycles();
+        gc_mem_caches();
+
+        return $this->indicators;
+    }
+
+    /**
+     * Samples data this analyser provides.
+     *
+     * @return string[]
+     */
+    protected function provided_sample_data() {
+        return array($this->get_samples_origin());
+    }
+
+    /**
+     * Returns labelled data (training and evaluation).
+     *
+     * @param \context[] $contexts Restrict the analysis to these contexts. No context restrictions if null.
+     * @return \stored_file[]
+     */
+    public function get_labelled_data(array $contexts = []) {
+        // Delegates all processing to the analysis.
+        $result = new \core_analytics\local\analysis\result_file($this->get_modelid(), true, $this->get_options());
+        $analysis = new \core_analytics\analysis($this, true, $result);
+        $analysis->run($contexts);
+        return $result->get();
+    }
+
+    /**
+     * Returns unlabelled data (prediction).
+     *
+     * @param \context[] $contexts Restrict the analysis to these contexts. No context restrictions if null.
+     * @return \stored_file[]
+     */
+    public function get_unlabelled_data(array $contexts = []) {
+        // Delegates all processing to the analysis.
+        $result = new \core_analytics\local\analysis\result_file($this->get_modelid(), false, $this->get_options());
+        $analysis = new \core_analytics\analysis($this, false, $result);
+        $analysis->run($contexts);
+        return $result->get();
+    }
+
+    /**
+     * Returns indicator calculations as an array.
+     *
+     * @param \context[] $contexts Restrict the analysis to these contexts. No context restrictions if null.
+     * @return array
+     */
+    public function get_static_data(array $contexts = []) {
+        // Delegates all processing to the analysis.
+        $result = new \core_analytics\local\analysis\result_array($this->get_modelid(), false, $this->get_options());
+        $analysis = new \core_analytics\analysis($this, false, $result);
+        $analysis->run($contexts);
+        return $result->get();
+    }
+
+    /**
+     * Checks if the analyser satisfies all the model indicators requirements.
+     *
+     * @throws \core_analytics\requirements_exception
+     * @return void
+     */
+    protected function check_indicators_requirements() {
+
+        foreach ($this->indicators as $indicator) {
+            $missingrequired = $this->check_indicator_requirements($indicator);
+            if ($missingrequired !== true) {
+                throw new \core_analytics\requirements_exception(get_class($indicator) . ' indicator requires ' .
+                    json_encode($missingrequired) . ' sample data which is not provided by ' . get_class($this));
+            }
+        }
+    }
+
+    /**
+     * Checks that this analyser satisfies the provided indicator requirements.
+     *
+     * @param \core_analytics\local\indicator\base $indicator
+     * @return true|string[] True if all good, missing requirements list otherwise
+     */
+    public function check_indicator_requirements(\core_analytics\local\indicator\base $indicator) {
+
+        $providedsampledata = $this->provided_sample_data();
+
+        $requiredsampledata = $indicator::required_sample_data();
+        if (empty($requiredsampledata)) {
+            // The indicator does not need any sample data.
+            return true;
+        }
+        $missingrequired = array_diff($requiredsampledata, $providedsampledata);
+
+        if (empty($missingrequired)) {
+            return true;
+        }
+
+        return $missingrequired;
+    }
+
+    /**
+     * Adds a register to the analysis log.
+     *
+     * @param string $string
+     * @return void
+     */
+    public function add_log($string) {
+        $this->log[] = $string;
+    }
+
+    /**
+     * Returns the analysis logs.
+     *
+     * @return string[]
+     */
+    public function get_logs() {
+        return $this->log;
+    }
+
+    /**
+     * Whether the plugin needs user data clearing or not.
+     *
+     * This is related to privacy. Override this method if your analyser samples have any relation
+     * to the 'user' database entity. We need to clean the site from all user-related data if a user
+     * request their data to be deleted from the system. A static::provided_sample_data returning 'user'
+     * is an indicator that you should be returning true.
+     *
+     * @return bool
+     */
+    public function processes_user_data() {
+        return false;
+    }
+
+    /**
+     * SQL JOIN from a sample to users table.
+     *
+     * This function should be defined if static::processes_user_data returns true and it is related to analytics API
+     * privacy API implementation. It allows the analytics API to identify data associated to users that needs to be
+     * deleted or exported.
+     *
+     * This function receives the alias of a table with a 'sampleid' field and it should return a SQL join
+     * with static::get_samples_origin and with 'user' table. Note that:
+     * - The function caller expects the returned 'user' table to be aliased as 'u' (defacto standard in moodle).
+     * - You can join with other tables if your samples origin table does not contain a 'userid' field (if that would be
+     *   a requirement this solution would be automated for you) you can't though use the following
+     *   aliases: 'ap', 'apa', 'aic' and 'am'.
+     *
+     * Some examples:
+     *
+     * static::get_samples_origin() === 'user':
+     *   JOIN {user} u ON {$sampletablealias}.sampleid = u.id
+     *
+     * static::get_samples_origin() === 'role_assignments':
+     *   JOIN {role_assignments} ra ON {$sampletablealias}.sampleid = ra.userid JOIN {user} u ON u.id = ra.userid
+     *
+     * static::get_samples_origin() === 'user_enrolments':
+     *   JOIN {user_enrolments} ue ON {$sampletablealias}.sampleid = ue.userid JOIN {user} u ON u.id = ue.userid
+     *
+     * @throws \coding_exception
+     * @param string $sampletablealias The alias of the table with a sampleid field that will join with this SQL string
+     * @return string
+     */
+    public function join_sample_user($sampletablealias) {
+        throw new \coding_exception('This method should be implemented if static::processes_user_data returns true.');
+    }
+
+    /**
+     * Do this analyser's analysables have 1 single sample each?
+     *
+     * Overwrite and return true if your analysables only have
+     * one sample. The insights generated by models using this
+     * analyser will then include the suggested actions in the
+     * notification.
+     *
+     * @return bool
+     */
+    public static function one_sample_per_analysable() {
+        return false;
+    }
+
+    /**
+     * Returns an array of context levels that can be used to restrict the contexts used during analysis.
+     *
+     * The contexts provided to self::get_analysables_iterator will match these contextlevels.
+     *
+     * @return array Array of context levels or an empty array if context restriction is not supported.
+     */
+    public static function context_restriction_support(): array {
+        return [];
+    }
+
+    /**
+     * Returns the possible contexts used by the analyser.
+     *
+     * This method uses separate logic for each context level because to iterate through
+     * the list of contexts calling get_context_name for each of them would be expensive
+     * in performance terms.
+     *
+     * This generic implementation returns all the contexts in the site for the provided context level.
+     * Overwrite it for specific restrictions in your analyser.
+     *
+     * @param  string|null $query Context name filter.
+     * @return int[]
+     */
+    public static function potential_context_restrictions(string $query = null) {
+        return \core_analytics\manager::get_potential_context_restrictions(static::context_restriction_support(), $query);
+    }
+
+    /**
+     * Get the sql of a default implementation of the iterator.
+     *
+     * This method only works for analysers that return analysable elements which ids map to a context instance ids.
+     *
+     * @param  string      $tablename    The name of the table
+     * @param  int         $contextlevel The context level of the analysable
+     * @param  string|null $action
+     * @param  string|null $tablealias   The table alias
+     * @param  \context[]  $contexts     Only analysables that depend on the provided contexts. All analysables if empty.
+     * @return array                     [0] => sql and [1] => params array
+     */
+    protected function get_iterator_sql(string $tablename, int $contextlevel, ?string $action = null, ?string $tablealias = null,
+            array $contexts = []) {
+        global $DB;
+
+        if (!$tablealias) {
+            $tablealias = 'analysable';
+        }
+
+        $params = ['contextlevel' => $contextlevel, 'modelid' => $this->get_modelid()];
+        $select = $tablealias . '.*, ' . \context_helper::get_preload_record_columns_sql('ctx');
+
+        // We add the action filter on ON instead of on WHERE because otherwise records are not returned if there are existing
+        // records for another action or model.
+        $usedanalysablesjoin = ' LEFT JOIN {analytics_used_analysables} aua ON ' . $tablealias . '.id = aua.analysableid AND ' .
+            '(aua.modelid = :modelid OR aua.modelid IS NULL)';
+
+        if ($action) {
+            $usedanalysablesjoin .= " AND aua.action = :action";
+            $params = $params + ['action' => $action];
+        }
+
+        $sql = 'SELECT ' . $select . '
+                  FROM {' . $tablename . '} ' . $tablealias . '
+                  ' . $usedanalysablesjoin . '
+                  JOIN {context} ctx ON (ctx.contextlevel = :contextlevel AND ctx.instanceid = ' . $tablealias . '.id) ';
+
+        if (!$contexts) {
+            // Adding the 1 = 1 just to have the WHERE part so that all further conditions
+            // added by callers can be appended to $sql with and ' AND'.
+            $sql .= 'WHERE 1 = 1';
+        } else {
+
+            $contextsqls = [];
+            foreach ($contexts as $context) {
+                $paramkey1 = 'paramctxlike' . $context->id;
+                $paramkey2 = 'paramctxeq' . $context->id;
+                $contextsqls[] = $DB->sql_like('ctx.path', ':' . $paramkey1);
+                $contextsqls[] = 'ctx.path = :' . $paramkey2;
+
+                // This includes the context itself.
+                $params[$paramkey1] = $context->path . '/%';
+                $params[$paramkey2] = $context->path;
+            }
+            $sql .= 'WHERE (' . implode(' OR ', $contextsqls) . ')';
+        }
+
+        return [$sql, $params];
+    }
+
+    /**
+     * Returns the order by clause.
+     *
+     * @param  string|null $fieldname  The field name
+     * @param  string      $order      'ASC' or 'DESC'
+     * @param  string|null $tablealias The table alias of the field
+     * @return string
+     */
+    protected function order_sql(?string $fieldname = null, string $order = 'ASC', ?string $tablealias = null) {
+
+        if (!$tablealias) {
+            $tablealias = 'analysable';
+        }
+
+        if ($order != 'ASC' && $order != 'DESC') {
+            throw new \coding_exception('The order can only be ASC or DESC');
+        }
+
+        $ordersql = ' ORDER BY (CASE WHEN aua.timeanalysed IS NULL THEN 0 ELSE aua.timeanalysed END) ASC';
+        if ($fieldname) {
+            $ordersql .= ', ' . $tablealias . '.' . $fieldname .' ' . $order;
+        }
+
+        return $ordersql;
+    }
+}

analytics/classes/local/analyser/by_course.php

@@ -0,0 +1,77 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Abstract analyser in course basis.
+ *
+ * @package   core_analytics
+ * @copyright 2016 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\analyser;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Abstract analyser in course basis.
+ *
+ * @package   core_analytics
+ * @copyright 2016 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+abstract class by_course extends base {
+
+    /**
+     * Return the list of courses to analyse.
+     *
+     * @param string|null $action 'prediction', 'training' or null if no specific action needed.
+     * @param \context[] $contexts Only analysables that depend on the provided contexts. All analysables in the system if empty.
+     * @return \Iterator
+     */
+    public function get_analysables_iterator(?string $action = null, array $contexts = []) {
+        global $DB;
+
+        list($sql, $params) = $this->get_iterator_sql('course', CONTEXT_COURSE, $action, 'c', $contexts);
+
+        $ordersql = $this->order_sql('sortorder', 'ASC', 'c');
+
+        $recordset = $DB->get_recordset_sql($sql . $ordersql, $params);
+
+        if (!$recordset->valid()) {
+            $this->add_log(get_string('nocourses', 'analytics'));
+            return new \ArrayIterator([]);
+        }
+
+        return new \core\dml\recordset_walk($recordset, function($record) {
+
+            if ($record->id == SITEID) {
+                return false;
+            }
+            $context = \context_helper::preload_from_record($record);
+            return \core_analytics\course::instance($record, $context);
+        });
+    }
+
+    /**
+     * Can be limited to course categories or specific courses.
+     *
+     * @return array
+     */
+    public static function context_restriction_support(): array {
+        return [CONTEXT_COURSE, CONTEXT_COURSECAT];
+    }
+}

analytics/classes/local/analyser/sitewide.php

@@ -0,0 +1,49 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Site-level contents abstract analysable.
+ *
+ * @package   core_analytics
+ * @copyright 2016 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\analyser;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Site-level contents abstract analysable.
+ *
+ * @package   core_analytics
+ * @copyright 2016 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+abstract class sitewide extends base {
+
+    /**
+     * Return the list of analysables to analyse.
+     *
+     * @param string|null $action 'prediction', 'training' or null if no specific action needed.
+     * @param \context[] $contexts Ignored here.
+     * @return \Iterator
+     */
+    public function get_analysables_iterator(?string $action = null, array $contexts = []) {
+        // We can safely ignore $action as we have 1 single analysable element in this analyser.
+        return new \ArrayIterator([new \core_analytics\site()]);
+    }
+}

analytics/classes/local/analysis/result.php

@@ -0,0 +1,102 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Keeps track of the analysis results.
+ *
+ * @package   core_analytics
+ * @copyright 2019 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\analysis;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Keeps track of the analysis results.
+ *
+ * @package   core_analytics
+ * @copyright 2019 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+abstract class result {
+
+    /**
+     * @var int
+     */
+    protected $modelid;
+
+    /**
+     * @var bool
+     */
+    protected $includetarget;
+
+    /**
+     * @var array Analysis options
+     */
+    protected $options;
+
+    /**
+     * Stores analysis data at instance level.
+     * @param int   $modelid
+     * @param bool  $includetarget
+     * @param array $options
+     */
+    public function __construct(int $modelid, bool $includetarget, array $options) {
+        $this->modelid = $modelid;
+        $this->includetarget = $includetarget;
+        $this->options = $options;
+    }
+
+    /**
+     * Retrieves cached results during evaluation.
+     *
+     * @param  \core_analytics\local\time_splitting\base $timesplitting
+     * @param  \core_analytics\analysable                $analysable
+     * @return mixed It can be in whatever format the result uses.
+     */
+    public function retrieve_cached_result(\core_analytics\local\time_splitting\base $timesplitting,
+        \core_analytics\analysable $analysable) {
+        return false;
+    }
+
+    /**
+     * Stores the analysis results.
+     *
+     * @param  array $results
+     * @return bool            True if anything was successfully analysed
+     */
+    abstract public function add_analysable_results(array $results): bool;
+
+    /**
+     * Formats the result.
+     *
+     * @param  array                                     $data
+     * @param  \core_analytics\local\target\base         $target
+     * @param  \core_analytics\local\time_splitting\base $timesplitting
+     * @param  \core_analytics\analysable                $analysable
+     * @return mixed It can be in whatever format the result uses
+     */
+    abstract public function format_result(array $data, \core_analytics\local\target\base $target,
+            \core_analytics\local\time_splitting\base $timesplitting, \core_analytics\analysable $analysable);
+
+    /**
+     * Returns the results of the analysis.
+     * @return array
+     */
+    abstract public function get(): array;
+}

analytics/classes/local/analysis/result_array.php

@@ -0,0 +1,100 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Keeps track of the analysis results by storing the results in an array.
+ *
+ * @package   core_analytics
+ * @copyright 2019 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\analysis;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Keeps track of the analysis results by storing the results in an array.
+ *
+ * @package   core_analytics
+ * @copyright 2019 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class result_array extends result {
+
+    /**
+     * Stores the analysis results by time-splitting method.
+     * @var array
+     */
+    private $resultsbytimesplitting = [];
+
+    /**
+     * Stores the analysis results.
+     * @param  array $results
+     * @return bool            True if anything was successfully analysed
+     */
+    public function add_analysable_results(array $results): bool {
+
+        $any = false;
+
+        // Process all provided time splitting methods.
+        foreach ($results as $timesplittingid => $result) {
+            if (!empty($result->result)) {
+                if (empty($this->resultsbytimesplitting[$timesplittingid])) {
+                    $this->resultsbytimesplitting[$timesplittingid] = [];
+                }
+                $this->resultsbytimesplitting[$timesplittingid] += $result->result;
+                $any = true;
+            }
+        }
+        if (empty($any)) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Formats the result.
+     *
+     * @param  array                                     $data
+     * @param  \core_analytics\local\target\base         $target
+     * @param  \core_analytics\local\time_splitting\base $timesplitting
+     * @param  \core_analytics\analysable                $analysable
+     * @return mixed The data as it comes
+     */
+    public function format_result(array $data, \core_analytics\local\target\base $target,
+            \core_analytics\local\time_splitting\base $timesplitting, \core_analytics\analysable $analysable) {
+        return $data;
+    }
+
+    /**
+     * Returns the results of the analysis.
+     * @return array
+     */
+    public function get(): array {
+
+        // We join the datasets by time splitting method.
+        $timesplittingresults = array();
+        foreach ($this->resultsbytimesplitting as $timesplittingid => $results) {
+            if (empty($timesplittingresults[$timesplittingid])) {
+                $timesplittingresults[$timesplittingid] = [];
+            }
+            $timesplittingresults[$timesplittingid] += $results;
+        }
+
+        return $timesplittingresults;
+    }
+}

analytics/classes/local/analysis/result_file.php

@@ -0,0 +1,228 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Keeps track of the analysis results by storing the results in files.
+ *
+ * @package   core_analytics
+ * @copyright 2019 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\analysis;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Keeps track of the analysis results by storing the results in files.
+ *
+ * @package   core_analytics
+ * @copyright 2019 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class result_file extends result {
+
+    /**
+     * Stores the analysis results by time-splitting method.
+     * @var array
+     */
+    private $filesbytimesplitting = [];
+
+    /**
+     * Stores the analysis results.
+     * @param  array $results
+     * @return bool            True if anything was successfully analysed
+     */
+    public function add_analysable_results(array $results): bool {
+
+        $any = false;
+
+        // Process all provided time splitting methods.
+        foreach ($results as $timesplittingid => $result) {
+            if (!empty($result->result)) {
+                $this->filesbytimesplitting[$timesplittingid][] = $result->result;
+                $any = true;
+            }
+        }
+
+        if (empty($any)) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Retrieves cached results during evaluation.
+     *
+     * @param  \core_analytics\local\time_splitting\base $timesplitting
+     * @param  \core_analytics\analysable                $analysable
+     * @return mixed A \stored_file in this case.
+     */
+    public function retrieve_cached_result(\core_analytics\local\time_splitting\base $timesplitting,
+        \core_analytics\analysable $analysable) {
+
+        // For evaluation purposes we don't need to be that strict about how updated the data is,
+        // if this analyser was analysed less that 1 week ago we skip generating a new one. This
+        // helps scale the evaluation process as sites with tons of courses may need a lot of time to
+        // complete an evaluation.
+        if (!empty($this->options['evaluation']) && !empty($this->options['reuseprevanalysed'])) {
+
+            $previousanalysis = \core_analytics\dataset_manager::get_evaluation_analysable_file($this->modelid,
+                $analysable->get_id(), $timesplitting->get_id());
+            // 1 week is a partly random time interval, no need to worry about DST.
+            $boundary = time() - WEEKSECS;
+            if ($previousanalysis && $previousanalysis->get_timecreated() > $boundary) {
+                // Recover the previous analysed file and avoid generating a new one.
+                return $previousanalysis;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Formats the result.
+     *
+     * @param  array                                     $data
+     * @param  \core_analytics\local\target\base         $target
+     * @param  \core_analytics\local\time_splitting\base $timesplitting
+     * @param  \core_analytics\analysable                $analysable
+     * @return mixed A \stored_file in this case
+     */
+    public function format_result(array $data, \core_analytics\local\target\base $target,
+            \core_analytics\local\time_splitting\base $timesplitting, \core_analytics\analysable $analysable) {
+
+        if (!empty($this->includetarget)) {
+            $filearea = \core_analytics\dataset_manager::LABELLED_FILEAREA;
+        } else {
+            $filearea = \core_analytics\dataset_manager::UNLABELLED_FILEAREA;
+        }
+        $dataset = new \core_analytics\dataset_manager($this->modelid, $analysable->get_id(),
+            $timesplitting->get_id(), $filearea, $this->options['evaluation']);
+
+        // Add extra metadata.
+        $this->add_model_metadata($data, $timesplitting, $target);
+
+        // Write all calculated data to a file.
+        if (!$result = $dataset->store($data)) {
+            return false;
+        }
+
+        return $result;
+    }
+
+    /**
+     * Returns the results of the analysis.
+     * @return array
+     */
+    public function get(): array {
+
+        if ($this->options['evaluation'] === false) {
+            // Look for previous training and prediction files we generated and couldn't be used
+            // by machine learning backends because they weren't big enough.
+
+            $pendingfiles = \core_analytics\dataset_manager::get_pending_files($this->modelid, $this->includetarget,
+                array_keys($this->filesbytimesplitting));
+            foreach ($pendingfiles as $timesplittingid => $files) {
+                foreach ($files as $file) {
+                    $this->filesbytimesplitting[$timesplittingid][] = $file;
+                }
+            }
+        }
+
+        // We join the datasets by time splitting method.
+        $timesplittingfiles = array();
+        foreach ($this->filesbytimesplitting as $timesplittingid => $files) {
+
+            if ($this->options['evaluation'] === true) {
+                // Delete the previous copy. Only when evaluating.
+                \core_analytics\dataset_manager::delete_previous_evaluation_file($this->modelid, $timesplittingid);
+            }
+
+            // Merge all course files into one.
+            if ($this->includetarget) {
+                $filearea = \core_analytics\dataset_manager::LABELLED_FILEAREA;
+            } else {
+                $filearea = \core_analytics\dataset_manager::UNLABELLED_FILEAREA;
+            }
+            $timesplittingfiles[$timesplittingid] = \core_analytics\dataset_manager::merge_datasets($files,
+                $this->modelid, $timesplittingid, $filearea, $this->options['evaluation']);
+        }
+
+        if (!empty($pendingfiles)) {
+            // We must remove them now as they are already part of another dataset.
+            foreach ($pendingfiles as $timesplittingid => $files) {
+                foreach ($files as $file) {
+                    $file->delete();
+                }
+            }
+        }
+
+        return $timesplittingfiles;
+    }
+
+    /**
+     * Adds target metadata to the dataset.
+     *
+     * The final dataset document will look like this:
+     * ----------------------------------------------------
+     * metadata1,metadata2,metadata3,.....
+     * value1, value2, value3,.....
+     *
+     * header1,header2,header3,header4,.....
+     * stud1value1,stud1value2,stud1value3,stud1value4,.....
+     * stud2value1,stud2value2,stud2value3,stud2value4,.....
+     * .....
+     * ----------------------------------------------------
+     *
+     * @param array $data
+     * @param \core_analytics\local\time_splitting\base $timesplitting
+     * @param \core_analytics\local\target\base         $target
+     * @return null
+     */
+    private function add_model_metadata(array &$data, \core_analytics\local\time_splitting\base $timesplitting,
+            \core_analytics\local\target\base $target) {
+        global $CFG;
+
+        // If no target the first column is the sampleid, if target the last column is the target.
+        // This will need to be updated when we support unsupervised learning models.
+        $metadata = array(
+            'timesplitting' => $timesplitting->get_id(),
+            'nfeatures' => count(current($data)) - 1,
+            'moodleversion' => $CFG->version,
+            'targetcolumn' => $target->get_id()
+        );
+        if ($target->is_linear()) {
+            $metadata['targettype'] = 'linear';
+            $metadata['targetmin'] = $target::get_min_value();
+            $metadata['targetmax'] = $target::get_max_value();
+        } else {
+            $metadata['targettype'] = 'discrete';
+            $metadata['targetclasses'] = json_encode($target::get_classes());
+        }
+
+        // The first 2 samples will be used to store metadata about the dataset.
+        $metadatacolumns = [];
+        $metadatavalues = [];
+        foreach ($metadata as $key => $value) {
+            $metadatacolumns[] = $key;
+            $metadatavalues[] = $value;
+        }
+
+        // This will also reset samples' dataset keys.
+        array_unshift($data, $metadatacolumns, $metadatavalues);
+    }
+}

analytics/classes/local/indicator/base.php

@@ -0,0 +1,197 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Abstract base indicator.
+ *
+ * @package   core_analytics
+ * @copyright 2016 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\indicator;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Abstract base indicator.
+ *
+ * @package   core_analytics
+ * @copyright 2016 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+abstract class base extends \core_analytics\calculable {
+
+    /**
+     * Min value an indicator can return.
+     */
+    const MIN_VALUE = -1;
+
+    /**
+     * Max value an indicator can return.
+     */
+    const MAX_VALUE = 1;
+
+    /**
+     * Converts the calculated indicators to dataset feature/s.
+     *
+     * @param float|int[] $calculatedvalues
+     * @return array
+     */
+    abstract protected function to_features($calculatedvalues);
+
+    /**
+     * Calculates the sample.
+     *
+     * Return a value from self::MIN_VALUE to self::MAX_VALUE or null if the indicator can not be calculated for this sample.
+     *
+     * @param int $sampleid
+     * @param string $sampleorigin
+     * @param integer $starttime Limit the calculation to this timestart
+     * @param integer $endtime Limit the calculation to this timeend
+     * @return float|null
+     */
+    abstract protected function calculate_sample($sampleid, $sampleorigin, $starttime, $endtime);
+
+    /**
+     * Should this value be displayed?
+     *
+     * Indicators providing multiple features can be used this method to discard some of them.
+     *
+     * @param float $value
+     * @param string $subtype
+     * @return bool
+     */
+    public function should_be_displayed($value, $subtype) {
+        // We should everything by default.
+        return true;
+    }
+
+    /**
+     * Allows indicators to specify data they need.
+     *
+     * e.g. A model using courses as samples will not provide users data, but an indicator like
+     * "user is hungry" needs user data.
+     *
+     * @return null|string[] Name of the required elements (use the database tablename)
+     */
+    public static function required_sample_data() {
+        return null;
+    }
+
+    /**
+     * Returns an instance of the indicator.
+     *
+     * Useful to reset cached data.
+     *
+     * @return \core_analytics\local\indicator\base
+     */
+    public static function instance() {
+        return new static();
+    }
+
+    /**
+     * Returns the maximum value an indicator calculation can return.
+     *
+     * @return float
+     */
+    public static function get_max_value() {
+        return self::MAX_VALUE;
+    }
+
+    /**
+     * Returns the minimum value an indicator calculation can return.
+     *
+     * @return float
+     */
+    public static function get_min_value() {
+        return self::MIN_VALUE;
+    }
+
+    /**
+     * Hook to allow indicators to pre-fill data that is shared accross time range calculations.
+     *
+     * Useful to fill analysable-dependant data that does not depend on the time ranges. Use
+     * instance vars to cache data that can be re-used across samples calculations but changes
+     * between time ranges (indicator instances are reset between time ranges to avoid unexpected
+     * problems).
+     *
+     * You are also responsible of emptying previous analysable caches.
+     *
+     * @param \core_analytics\analysable $analysable
+     * @return void
+     */
+    public function fill_per_analysable_caches(\core_analytics\analysable $analysable) {
+    }
+
+    /**
+     * Calculates the indicator.
+     *
+     * Returns an array of values which size matches $sampleids size.
+     *
+     * @param int[] $sampleids
+     * @param string $samplesorigin
+     * @param integer $starttime Limit the calculation to this timestart
+     * @param integer $endtime Limit the calculation to this timeend
+     * @param array $existingcalculations Existing calculations of this indicator, indexed by sampleid.
+     * @return array [0] = [$sampleid => int[]|float[]], [1] = [$sampleid => int|float], [2] = [$sampleid => $sampleid]
+     */
+    public function calculate($sampleids, $samplesorigin, $starttime = false, $endtime = false, $existingcalculations = array()) {
+
+        if (!PHPUNIT_TEST && CLI_SCRIPT) {
+            echo '.';
+        }
+
+        $calculations = array();
+        $newcalculations = array();
+        $notnulls = array();
+        foreach ($sampleids as $sampleid => $unusedsampleid) {
+
+            if (isset($existingcalculations[$sampleid])) {
+                $calculatedvalue = $existingcalculations[$sampleid];
+            } else {
+                $calculatedvalue = $this->calculate_sample($sampleid, $samplesorigin, $starttime, $endtime);
+                $newcalculations[$sampleid] = $calculatedvalue;
+            }
+
+            if (!is_null($calculatedvalue)) {
+                $notnulls[$sampleid] = $sampleid;
+                $this->validate_calculated_value($calculatedvalue);
+            }
+
+            $calculations[$sampleid] = $calculatedvalue;
+        }
+
+        $features = $this->to_features($calculations);
+
+        return array($features, $newcalculations, $notnulls);
+    }
+
+    /**
+     * Validates the calculated value.
+     *
+     * @throws \coding_exception
+     * @param float $calculatedvalue
+     * @return true
+     */
+    protected function validate_calculated_value($calculatedvalue) {
+        if ($calculatedvalue > self::MAX_VALUE || $calculatedvalue < self::MIN_VALUE) {
+            throw new \coding_exception('Calculated values should be higher than ' . self::MIN_VALUE .
+                ' and lower than ' . self::MAX_VALUE . ' ' . $calculatedvalue . ' received');
+        }
+        return true;
+    }
+}

analytics/classes/local/indicator/binary.php

@@ -0,0 +1,128 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Abstract binary indicator.
+ *
+ * @package   core_analytics
+ * @copyright 2017 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\indicator;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Abstract binary indicator.
+ *
+ * @package   core_analytics
+ * @copyright 2017 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+abstract class binary extends discrete {
+
+    /**
+     * get_classes
+     *
+     * @return array
+     */
+    final public static function get_classes() {
+        return [-1, 1];
+    }
+
+    /**
+     * It should always be displayed.
+     *
+     * Binary values have no subtypes by default, please overwrite if
+     * your indicator is adding extra features.
+     *
+     * @param float $value
+     * @param string $subtype
+     * @return bool
+     */
+    public function should_be_displayed($value, $subtype) {
+        if ($subtype != false) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * get_display_value
+     *
+     * @param float $value
+     * @param string $subtype
+     * @return string
+     */
+    public function get_display_value($value, $subtype = false) {
+
+        // No subtypes for binary values by default.
+        if ($value == -1) {
+            return get_string('no');
+        } else if ($value == 1) {
+            return get_string('yes');
+        } else {
+            throw new \moodle_exception('errorpredictionformat', 'analytics');
+        }
+    }
+
+    /**
+     * get_calculation_outcome
+     *
+     * @param float $value
+     * @param string $subtype
+     * @return int
+     */
+    public function get_calculation_outcome($value, $subtype = false) {
+
+        // No subtypes for binary values by default.
+        if ($value == -1) {
+            return self::OUTCOME_NEGATIVE;
+        } else if ($value == 1) {
+            return self::OUTCOME_OK;
+        } else {
+            throw new \moodle_exception('errorpredictionformat', 'analytics');
+        }
+    }
+
+    /**
+     * get_feature_headers
+     *
+     * @return array
+     */
+    public static function get_feature_headers() {
+        // Just 1 single feature obtained from the calculated value.
+        return array('\\' . get_called_class());
+    }
+
+    /**
+     * to_features
+     *
+     * @param array $calculatedvalues
+     * @return array
+     */
+    protected function to_features($calculatedvalues) {
+        // Indicators with binary values have only 1 feature for indicator, here we do nothing else
+        // than converting each sample scalar value to an array of scalars with 1 element.
+        array_walk($calculatedvalues, function(&$calculatedvalue) {
+            // Just return it as an array.
+            $calculatedvalue = array($calculatedvalue);
+        });
+
+        return $calculatedvalues;
+    }
+}

analytics/classes/local/indicator/discrete.php

@@ -0,0 +1,159 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Abstract discrete indicator.
+ *
+ * @package   core_analytics
+ * @copyright 2017 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\indicator;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Abstract discrete indicator.
+ *
+ * @package   core_analytics
+ * @copyright 2017 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+abstract class discrete extends base {
+
+    /**
+     * Classes need to be defined so they can be converted internally to individual dataset features.
+     *
+     * @return string[]
+     */
+    protected static function get_classes() {
+        throw new \coding_exception('Please overwrite get_classes() specifying your discrete-values\' indicator classes');
+    }
+
+    /**
+     * Returns 1 feature header for each of the classes.
+     *
+     * @return string[]
+     */
+    public static function get_feature_headers() {
+        $fullclassname = '\\' . get_called_class();
+
+        foreach (static::get_classes() as $class) {
+            $headers[] = $fullclassname . '/' . $class;
+        }
+
+        return $headers;
+    }
+
+    /**
+     * Whether the value should be displayed or not.
+     *
+     * @param float $value
+     * @param string $subtype
+     * @return bool
+     */
+    public function should_be_displayed($value, $subtype) {
+        if ($value != static::get_max_value()) {
+            // Discrete values indicators are converted internally to 1 feature per indicator, we are only interested
+            // in showing the feature flagged with the max value.
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Returns the value to display when the prediction is $value.
+     *
+     * @param float $value
+     * @param string $subtype
+     * @return string
+     */
+    public function get_display_value($value, $subtype = false) {
+
+        $displayvalue = array_search($subtype, static::get_classes(), false);
+
+        debugging('Please overwrite \core_analytics\local\indicator\discrete::get_display_value to show something ' .
+            'different than the default "' . $displayvalue . '"', DEBUG_DEVELOPER);
+
+        return $displayvalue;
+    }
+
+    /**
+     * get_display_style
+     *
+     * @param float $ignoredvalue
+     * @param string $ignoredsubtype
+     * @return int
+     */
+    public function get_display_style($ignoredvalue, $ignoredsubtype) {
+        // No style attached to indicators classes, they are what they are, a cat,
+        // a horse or a sandwich, they are not good or bad.
+        return \core_analytics\calculable::OUTCOME_NEUTRAL;
+    }
+
+    /**
+     * From calculated values to dataset features.
+     *
+     * One column for each class.
+     *
+     * @param float[] $calculatedvalues
+     * @return float[]
+     */
+    protected function to_features($calculatedvalues) {
+
+        $classes = static::get_classes();
+
+        foreach ($calculatedvalues as $sampleid => $calculatedvalue) {
+
+            // Using intval as it may come as a float from the db.
+            $classindex = array_search(intval($calculatedvalue), $classes, true);
+
+            if ($classindex === false && !is_null($calculatedvalue)) {
+                throw new \coding_exception(get_class($this) . ' calculated value "' . $calculatedvalue .
+                    '" is not one of its defined classes (' . json_encode($classes) . ')');
+            }
+
+            // We transform the calculated value into multiple features, one for each of the possible classes.
+            $features = array_fill(0, count($classes), 0);
+
+            // 1 to the selected value.
+            if (!is_null($calculatedvalue)) {
+                $features[$classindex] = 1;
+            }
+
+            $calculatedvalues[$sampleid] = $features;
+        }
+
+        return $calculatedvalues;
+    }
+
+    /**
+     * Validates the calculated value.
+     *
+     * @param float $calculatedvalue
+     * @return true
+     */
+    protected function validate_calculated_value($calculatedvalue) {
+
+        // Using intval as it may come as a float from the db.
+        if (!in_array(intval($calculatedvalue), static::get_classes())) {
+            throw new \coding_exception(get_class($this) . ' calculated value "' . $calculatedvalue .
+                '" is not one of its defined classes (' . json_encode(static::get_classes()) . ')');
+        }
+        return true;
+    }
+}

analytics/classes/local/indicator/linear.php

@@ -0,0 +1,147 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Abstract linear indicator.
+ *
+ * @package   core_analytics
+ * @copyright 2017 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\indicator;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Abstract linear indicator.
+ *
+ * @package   core_analytics
+ * @copyright 2017 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+abstract class linear extends base {
+
+    /**
+     * Set to false to avoid context features to be added as dataset features.
+     *
+     * @return bool
+     */
+    protected static function include_averages() {
+        return true;
+    }
+
+    /**
+     * get_feature_headers
+     *
+     * @return array
+     */
+    public static function get_feature_headers() {
+
+        $fullclassname = '\\' . get_called_class();
+
+        if (static::include_averages()) {
+            // The calculated value + context indicators.
+            $headers = array($fullclassname, $fullclassname . '/mean');
+        } else {
+            $headers = array($fullclassname);
+        }
+        return $headers;
+    }
+
+    /**
+     * Show only the main feature.
+     *
+     * @param float $value
+     * @param string $subtype
+     * @return bool
+     */
+    public function should_be_displayed($value, $subtype) {
+        if ($subtype != false) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * get_display_value
+     *
+     * @param float $value
+     * @param string $subtype
+     * @return string
+     */
+    public function get_display_value($value, $subtype = false) {
+        $diff = static::get_max_value() - static::get_min_value();
+        return round(100 * ($value - static::get_min_value()) / $diff) . '%';
+    }
+
+    /**
+     * get_calculation_outcome
+     *
+     * @param float $value
+     * @param string $subtype
+     * @return int
+     */
+    public function get_calculation_outcome($value, $subtype = false) {
+        if ($value < 0) {
+            return self::OUTCOME_NEGATIVE;
+        } else {
+            return self::OUTCOME_OK;
+        }
+    }
+
+    /**
+     * Converts the calculated values to a list of features for the dataset.
+     *
+     * @param array $calculatedvalues
+     * @return array
+     */
+    protected function to_features($calculatedvalues) {
+
+        // Null mean if all calculated values are null.
+        $nullmean = true;
+        foreach ($calculatedvalues as $value) {
+            if (!is_null($value)) {
+                // Early break, we don't want to spend a lot of time here.
+                $nullmean = false;
+                break;
+            }
+        }
+
+        if ($nullmean) {
+            $mean = null;
+        } else {
+            $mean = round(array_sum($calculatedvalues) / count($calculatedvalues), 2);
+        }
+
+        foreach ($calculatedvalues as $sampleid => $calculatedvalue) {
+
+            if (!is_null($calculatedvalue)) {
+                $calculatedvalue = round($calculatedvalue, 2);
+            }
+
+            if (static::include_averages()) {
+                $calculatedvalues[$sampleid] = array($calculatedvalue, $mean);
+            } else {
+                // Basically just convert the scalar to an array of scalars with a single value.
+                $calculatedvalues[$sampleid] = array($calculatedvalue);
+            }
+        }
+
+        // Returns each sample as an array of values, appending the mean to the calculated value.
+        return $calculatedvalues;
+    }
+}

analytics/classes/local/target/base.php

@@ -0,0 +1,459 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Abstract base target.
+ *
+ * @package   core_analytics
+ * @copyright 2016 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\target;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Abstract base target.
+ *
+ * @package   core_analytics
+ * @copyright 2016 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+abstract class base extends \core_analytics\calculable {
+
+    /**
+     * This target have linear or discrete values.
+     *
+     * @return bool
+     */
+    abstract public function is_linear();
+
+    /**
+     * Returns the analyser class that should be used along with this target.
+     *
+     * @return string The full class name as a string
+     */
+    abstract public function get_analyser_class();
+
+    /**
+     * Allows the target to verify that the analysable is a good candidate.
+     *
+     * This method can be used as a quick way to discard invalid analysables.
+     * e.g. Imagine that your analysable don't have students and you need them.
+     *
+     * @param \core_analytics\analysable $analysable
+     * @param bool $fortraining
+     * @return true|string
+     */
+    abstract public function is_valid_analysable(\core_analytics\analysable $analysable, $fortraining = true);
+
+    /**
+     * Is this sample from the $analysable valid?
+     *
+     * @param int $sampleid
+     * @param \core_analytics\analysable $analysable
+     * @param bool $fortraining
+     * @return bool
+     */
+    abstract public function is_valid_sample($sampleid, \core_analytics\analysable $analysable, $fortraining = true);
+
+    /**
+     * Calculates this target for the provided samples.
+     *
+     * In case there are no values to return or the provided sample is not applicable just return null.
+     *
+     * @param int $sampleid
+     * @param \core_analytics\analysable $analysable
+     * @param int|false $starttime Limit calculations to start time
+     * @param int|false $endtime Limit calculations to end time
+     * @return float|null
+     */
+    abstract protected function calculate_sample($sampleid, \core_analytics\analysable $analysable, $starttime = false, $endtime = false);
+
+    /**
+     * Can the provided time-splitting method be used on this target?.
+     *
+     * Time-splitting methods not matching the target requirements will not be selectable by models based on this target.
+     *
+     * @param  \core_analytics\local\time_splitting\base $timesplitting
+     * @return bool
+     */
+    abstract public function can_use_timesplitting(\core_analytics\local\time_splitting\base $timesplitting): bool;
+
+    /**
+     * Is this target generating insights?
+     *
+     * Defaults to true.
+     *
+     * @return bool
+     */
+    public static function uses_insights() {
+        return true;
+    }
+
+    /**
+     * Should the insights of this model be linked from reports?
+     *
+     * @return bool
+     */
+    public function link_insights_report(): bool {
+        return true;
+    }
+
+    /**
+     * Based on facts (processed by machine learning backends) by default.
+     *
+     * @return bool
+     */
+    public static function based_on_assumptions() {
+        return false;
+    }
+
+    /**
+     * Update the last analysis time on analysable processed or always.
+     *
+     * If you overwrite this method to return false the last analysis time
+     * will only be recorded in DB when the element successfully analysed. You can
+     * safely return false for lightweight targets.
+     *
+     * @return bool
+     */
+    public function always_update_analysis_time(): bool {
+        return true;
+    }
+
+    /**
+     * Suggested actions for a user.
+     *
+     * @param \core_analytics\prediction $prediction
+     * @param bool $includedetailsaction
+     * @param bool $isinsightuser                       Force all the available actions to be returned as it the user who
+     *                                                  receives the insight is the one logged in.
+     * @return \core_analytics\prediction_action[]
+     */
+    public function prediction_actions(\core_analytics\prediction $prediction, $includedetailsaction = false,
+            $isinsightuser = false) {
+        global $PAGE;
+
+        $predictionid = $prediction->get_prediction_data()->id;
+        $contextid = $prediction->get_prediction_data()->contextid;
+        $modelid = $prediction->get_prediction_data()->modelid;
+
+        $actions = array();
+
+        if ($this->link_insights_report() && $includedetailsaction) {
+
+            $predictionurl = new \moodle_url('/report/insights/prediction.php', array('id' => $predictionid));
+            $detailstext = $this->get_view_details_text();
+
+            $actions[] = new \core_analytics\prediction_action(\core_analytics\prediction::ACTION_PREDICTION_DETAILS, $prediction,
+                $predictionurl, new \pix_icon('t/preview', $detailstext),
+                $detailstext, false, [], \core_analytics\action::TYPE_NEUTRAL);
+        }
+
+        return $actions;
+    }
+
+    /**
+     * Suggested bulk actions for a user.
+     *
+     * @param  \core_analytics\prediction[]     $predictions List of predictions suitable for the bulk actions to use.
+     * @return \core_analytics\bulk_action[]                 The list of bulk actions.
+     */
+    public function bulk_actions(array $predictions) {
+
+        $analyserclass = $this->get_analyser_class();
+        if ($analyserclass::one_sample_per_analysable()) {
+            // Default actions are useful / not useful.
+            $actions = [
+                \core_analytics\default_bulk_actions::useful(),
+                \core_analytics\default_bulk_actions::not_useful()
+            ];
+
+        } else {
+            // Accept and not applicable.
+
+            $actions = [
+                \core_analytics\default_bulk_actions::accept(),
+                \core_analytics\default_bulk_actions::not_applicable()
+            ];
+
+            if (!self::based_on_assumptions()) {
+                // We include incorrectly flagged.
+                $actions[] = \core_analytics\default_bulk_actions::incorrectly_flagged();
+            }
+        }
+
+        return $actions;
+    }
+
+    /**
+     * Adds the JS required to run the bulk actions.
+     */
+    public function add_bulk_actions_js() {
+        global $PAGE;
+        $PAGE->requires->js_call_amd('report_insights/actions', 'initBulk', ['.insights-bulk-actions']);
+    }
+
+    /**
+     * Returns the view details link text.
+     * @return string
+     */
+    private function get_view_details_text() {
+        if ($this->based_on_assumptions()) {
+            $analyserclass = $this->get_analyser_class();
+            if ($analyserclass::one_sample_per_analysable()) {
+                $detailstext = get_string('viewinsightdetails', 'analytics');
+            } else {
+                $detailstext = get_string('viewdetails', 'analytics');
+            }
+        } else {
+            $detailstext = get_string('viewprediction', 'analytics');
+        }
+
+        return $detailstext;
+    }
+
+    /**
+     * Callback to execute once a prediction has been returned from the predictions processor.
+     *
+     * Note that the analytics_predictions db record is not yet inserted.
+     *
+     * @param int $modelid
+     * @param int $sampleid
+     * @param int $rangeindex
+     * @param \context $samplecontext
+     * @param float|int $prediction
+     * @param float $predictionscore
+     * @return void
+     */
+    public function prediction_callback($modelid, $sampleid, $rangeindex, \context $samplecontext, $prediction, $predictionscore) {
+        return;
+    }
+
+    /**
+     * Generates insights notifications
+     *
+     * @param int $modelid
+     * @param \context[] $samplecontexts
+     * @param  \core_analytics\prediction[] $predictions
+     * @return void
+     */
+    public function generate_insight_notifications($modelid, $samplecontexts, array $predictions = []) {
+        // Delegate the processing of insights to the insights_generator.
+        $insightsgenerator = new \core_analytics\insights_generator($modelid, $this);
+        $insightsgenerator->generate($samplecontexts, $predictions);
+    }
+
+    /**
+     * Returns the list of users that will receive insights notifications.
+     *
+     * Feel free to overwrite if you need to but keep in mind that moodle/analytics:listinsights
+     * or moodle/analytics:listowninsights capability is required to access the list of insights.
+     *
+     * @param \context $context
+     * @return array
+     */
+    public function get_insights_users(\context $context) {
+        if ($context->contextlevel === CONTEXT_USER) {
+            if (!has_capability('moodle/analytics:listowninsights', $context, $context->instanceid)) {
+                $users = [];
+            } else {
+                $users = [$context->instanceid => \core_user::get_user($context->instanceid)];
+            }
+
+        } else if ($context->contextlevel >= CONTEXT_COURSE) {
+            // At course level or below only enrolled users although this is not ideal for
+            // teachers assigned at category level.
+            $users = get_enrolled_users($context, 'moodle/analytics:listinsights', 0, 'u.*', null, 0, 0, true);
+        } else {
+            $users = get_users_by_capability($context, 'moodle/analytics:listinsights');
+        }
+        return $users;
+    }
+
+    /**
+     * URL to the insight.
+     *
+     * @param  int $modelid
+     * @param  \context $context
+     * @return \moodle_url
+     */
+    public function get_insight_context_url($modelid, $context) {
+        return new \moodle_url('/report/insights/insights.php?modelid=' . $modelid . '&contextid=' . $context->id);
+    }
+
+    /**
+     * The insight notification subject.
+     *
+     * This is just a default message, you should overwrite it for a custom insight message.
+     *
+     * @param  int $modelid
+     * @param  \context $context
+     * @return string
+     */
+    public function get_insight_subject(int $modelid, \context $context) {
+        return get_string('insightmessagesubject', 'analytics', $context->get_context_name());
+    }
+
+    /**
+     * Returns the body message for an insight with multiple predictions.
+     *
+     * This default method is executed when the analysable used by the model generates multiple insight
+     * for each analysable (one_sample_per_analysable === false)
+     *
+     * @param  \context     $context
+     * @param  string       $contextname
+     * @param  \stdClass    $user
+     * @param  \moodle_url  $insighturl
+     * @return string[]                     The plain text message and the HTML message
+     */
+    public function get_insight_body(\context $context, string $contextname, \stdClass $user, \moodle_url $insighturl): array {
+        global $OUTPUT;
+
+        $fullmessage = get_string('insightinfomessageplain', 'analytics', $insighturl->out(false));
+        $fullmessagehtml = $OUTPUT->render_from_template('core_analytics/insight_info_message',
+            ['url' => $insighturl->out(false), 'insightinfomessage' => get_string('insightinfomessagehtml', 'analytics')]
+        );
+
+        return [$fullmessage, $fullmessagehtml];
+    }
+
+    /**
+     * Returns the body message for an insight for a single prediction.
+     *
+     * This default method is executed when the analysable used by the model generates one insight
+     * for each analysable (one_sample_per_analysable === true)
+     *
+     * @param  \context                             $context
+     * @param  \stdClass                            $user
+     * @param  \core_analytics\prediction           $prediction
+     * @param  \core_analytics\action[]             $actions        Passed by reference to remove duplicate links to actions.
+     * @return array                                                Plain text msg, HTML message and the main URL for this
+     *                                                              insight (you can return null if you are happy with the
+     *                                                              default insight URL calculated in prediction_info())
+     */
+    public function get_insight_body_for_prediction(\context $context, \stdClass $user, \core_analytics\prediction $prediction,
+            array &$actions) {
+        // No extra message by default.
+        return [FORMAT_PLAIN => '', FORMAT_HTML => '', 'url' => null];
+    }
+
+    /**
+     * Returns an instance of the child class.
+     *
+     * Useful to reset cached data.
+     *
+     * @return \core_analytics\base\target
+     */
+    public static function instance() {
+        return new static();
+    }
+
+    /**
+     * Defines a boundary to ignore predictions below the specified prediction score.
+     *
+     * Value should go from 0 to 1.
+     *
+     * @return float
+     */
+    protected function min_prediction_score() {
+        // The default minimum discards predictions with a low score.
+        return \core_analytics\model::PREDICTION_MIN_SCORE;
+    }
+
+    /**
+     * This method determines if a prediction is interesing for the model or not.
+     *
+     * @param mixed $predictedvalue
+     * @param float $predictionscore
+     * @return bool
+     */
+    public function triggers_callback($predictedvalue, $predictionscore) {
+
+        $minscore = floatval($this->min_prediction_score());
+        if ($minscore < 0) {
+            debugging(get_class($this) . ' minimum prediction score is below 0, please update it to a value between 0 and 1.');
+        } else if ($minscore > 1) {
+            debugging(get_class($this) . ' minimum prediction score is above 1, please update it to a value between 0 and 1.');
+        }
+
+        // We need to consider that targets may not have a min score.
+        if (!empty($minscore) && floatval($predictionscore) < $minscore) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Calculates the target.
+     *
+     * Returns an array of values which size matches $sampleids size.
+     *
+     * Rows with null values will be skipped as invalid by time splitting methods.
+     *
+     * @param array $sampleids
+     * @param \core_analytics\analysable $analysable
+     * @param int $starttime
+     * @param int $endtime
+     * @return array The format to follow is [userid] = scalar|null
+     */
+    public function calculate($sampleids, \core_analytics\analysable $analysable, $starttime = false, $endtime = false) {
+
+        if (!PHPUNIT_TEST && CLI_SCRIPT) {
+            echo '.';
+        }
+
+        $calculations = [];
+        foreach ($sampleids as $sampleid => $unusedsampleid) {
+
+            // No time limits when calculating the target to train models.
+            $calculatedvalue = $this->calculate_sample($sampleid, $analysable, $starttime, $endtime);
+
+            if (!is_null($calculatedvalue)) {
+                if ($this->is_linear() &&
+                        ($calculatedvalue > static::get_max_value() || $calculatedvalue < static::get_min_value())) {
+                    throw new \coding_exception('Calculated values should be higher than ' . static::get_min_value() .
+                        ' and lower than ' . static::get_max_value() . '. ' . $calculatedvalue . ' received');
+                } else if (!$this->is_linear() && static::is_a_class($calculatedvalue) === false) {
+                    throw new \coding_exception('Calculated values should be one of the target classes (' .
+                        json_encode(static::get_classes()) . '). ' . $calculatedvalue . ' received');
+                }
+            }
+            $calculations[$sampleid] = $calculatedvalue;
+        }
+        return $calculations;
+    }
+
+    /**
+     * Filters out invalid samples for training.
+     *
+     * @param int[] $sampleids
+     * @param \core_analytics\analysable $analysable
+     * @param bool $fortraining
+     * @return void
+     */
+    public function filter_out_invalid_samples(&$sampleids, \core_analytics\analysable $analysable, $fortraining = true) {
+        foreach ($sampleids as $sampleid => $unusedsampleid) {
+            if (!$this->is_valid_sample($sampleid, $analysable, $fortraining)) {
+                // Skip it and remove the sample from the list of calculated samples.
+                unset($sampleids[$sampleid]);
+            }
+        }
+    }
+}

analytics/classes/local/target/binary.php

@@ -0,0 +1,106 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Binary classifier target.
+ *
+ * @package   core_analytics
+ * @copyright 2017 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\target;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Binary classifier target.
+ *
+ * @package   core_analytics
+ * @copyright 2017 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+abstract class binary extends discrete {
+
+    /**
+     * is_linear
+     *
+     * @return bool
+     */
+    public function is_linear() {
+        return false;
+    }
+
+    /**
+     * Returns the target discrete values.
+     *
+     * Only useful for targets using discrete values, must be overwriten if it is the case.
+     *
+     * @return array
+     */
+    final public static function get_classes() {
+        return array(0, 1);
+    }
+
+    /**
+     * Returns the predicted classes that will be ignored.
+     *
+     * @return array
+     */
+    public function ignored_predicted_classes() {
+        // Zero-value class is usually ignored in binary classifiers.
+        return array(0);
+    }
+
+    /**
+     * Is the calculated value a positive outcome of this target?
+     *
+     * @param string $value
+     * @param string $ignoredsubtype
+     * @return int
+     */
+    public function get_calculation_outcome($value, $ignoredsubtype = false) {
+
+        if (!self::is_a_class($value)) {
+            throw new \moodle_exception('errorpredictionformat', 'analytics');
+        }
+
+        if (in_array($value, $this->ignored_predicted_classes(), false)) {
+            // Just in case, if it is ignored the prediction should not even be recorded but if it would, it is ignored now,
+            // which should mean that is it nothing serious.
+            return self::OUTCOME_VERY_POSITIVE;
+        }
+
+        // By default binaries are danger when prediction = 1.
+        if ($value) {
+            return self::OUTCOME_VERY_NEGATIVE;
+        }
+        return self::OUTCOME_VERY_POSITIVE;
+    }
+
+    /**
+     * classes_description
+     *
+     * @return string[]
+     */
+    protected static function classes_description() {
+        return array(
+            get_string('yes'),
+            get_string('no')
+        );
+    }
+
+}

analytics/classes/local/target/discrete.php

@@ -0,0 +1,176 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Discrete values target.
+ *
+ * @package   core_analytics
+ * @copyright 2017 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\target;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Discrete values target.
+ *
+ * @package   core_analytics
+ * @copyright 2017 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+abstract class discrete extends base {
+
+    /**
+     * Are this target calculations linear values?
+     *
+     * @return bool
+     */
+    public function is_linear() {
+        // Not supported yet.
+        throw new \coding_exception('Sorry, this version\'s prediction processors only support targets with binary values.' .
+            ' You can write your own and overwrite this method though.');
+    }
+
+    /**
+     * Is the provided class one of this target valid classes?
+     *
+     * @param mixed $class
+     * @return bool
+     */
+    protected static function is_a_class($class) {
+        return (in_array($class, static::get_classes(), false));
+    }
+
+    /**
+     * get_display_value
+     *
+     * @param float $value
+     * @param string $ignoredsubtype
+     * @return string
+     */
+    public function get_display_value($value, $ignoredsubtype = false) {
+
+        if (!self::is_a_class($value)) {
+            throw new \moodle_exception('errorpredictionformat', 'analytics');
+        }
+
+        // To discard any possible weird keys devs used.
+        $classes = array_values(static::get_classes());
+        $descriptions = array_values(static::classes_description());
+
+        if (count($classes) !== count($descriptions)) {
+            throw new \coding_exception('You need to describe all your classes (' . json_encode($classes) .
+                ') in self::classes_description');
+        }
+
+        $key = array_search($value, $classes);
+        if ($key === false) {
+            throw new \coding_exception('You need to describe all your classes (' . json_encode($classes) .
+                ') in self::classes_description');
+        }
+
+        return $descriptions[$key];
+    }
+
+    /**
+     * get_calculation_outcome
+     *
+     * @param float $value
+     * @param string $ignoredsubtype
+     * @return int
+     */
+    public function get_calculation_outcome($value, $ignoredsubtype = false) {
+
+        if (!self::is_a_class($value)) {
+            throw new \moodle_exception('errorpredictionformat', 'analytics');
+        }
+
+        if (in_array($value, $this->ignored_predicted_classes(), false)) {
+            // Just in case, if it is ignored the prediction should not even be recorded.
+            return self::OUTCOME_OK;
+        }
+
+        debugging('Please overwrite \core_analytics\local\target\discrete::get_calculation_outcome, all your target ' .
+            'classes are styled the same way otherwise', DEBUG_DEVELOPER);
+        return self::OUTCOME_OK;
+    }
+
+    /**
+     * Returns all the possible values the target calculation can return.
+     *
+     * Only useful for targets using discrete values, must be overwriten if it is the case.
+     *
+     * @return array
+     */
+    public static function get_classes() {
+        // Coding exception as this will only be called if this target have non-linear values.
+        throw new \coding_exception('Overwrite get_classes() and return an array with the different values the ' .
+            'target calculation can return');
+    }
+
+    /**
+     * Returns descriptions for each of the values the target calculation can return.
+     *
+     * The array indexes should match self::get_classes indexes.
+     *
+     * @return array
+     */
+    protected static function classes_description() {
+        throw new \coding_exception('Overwrite classes_description() and return an array with a description for each of the ' .
+            'different values the target calculation can return. Indexes should match self::get_classes indexes');
+    }
+
+    /**
+     * Returns the predicted classes that will be ignored.
+     *
+     * Better be keen to add more than less classes here, the callback is always able to discard some classes. As an example
+     * a target with classes 'grade 0-3', 'grade 3-6', 'grade 6-8' and 'grade 8-10' is interested in flagging both 'grade 6-8'
+     * and 'grade 8-10' as ignored. On the other hand, a target like dropout risk with classes 'yes', 'no' may just be
+     * interested in 'yes'.
+     *
+     * @return array List of values that will be ignored (array keys are ignored).
+     */
+    public function ignored_predicted_classes() {
+        // Coding exception as this will only be called if this target have non-linear values.
+        throw new \coding_exception('Overwrite ignored_predicted_classes() and return an array with the classes that should not ' .
+            'trigger the callback');
+    }
+
+    /**
+     * This method determines if a prediction is interesing for the model or not.
+     *
+     * This method internally calls ignored_predicted_classes to skip classes
+     * flagged by the target as not important for users.
+     *
+     * @param mixed $predictedvalue
+     * @param float $predictionscore
+     * @return bool
+     */
+    public function triggers_callback($predictedvalue, $predictionscore) {
+
+        if (!parent::triggers_callback($predictedvalue, $predictionscore)) {
+            return false;
+        }
+
+        if (in_array($predictedvalue, $this->ignored_predicted_classes())) {
+            return false;
+        }
+
+        return true;
+    }
+}

analytics/classes/local/target/linear.php

@@ -0,0 +1,118 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Linear values target.
+ *
+ * @package   core_analytics
+ * @copyright 2017 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\target;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Linear values target.
+ *
+ * @package   core_analytics
+ * @copyright 2017 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+abstract class linear extends base {
+
+    /**
+     * Are the calculated values this target returns linear values?
+     *
+     * @return bool
+     */
+    public function is_linear() {
+        // Not supported yet.
+        throw new \coding_exception('Sorry, this version\'s prediction processors only support targets with binary values.' .
+            ' You can write your own and overwrite this method though.');
+    }
+
+    /**
+     * How positive is this calculated value?
+     *
+     * @param float $value
+     * @param string $ignoredsubtype
+     * @return int
+     */
+    public function get_calculation_outcome($value, $ignoredsubtype = false) {
+
+        // This is very generic, targets will probably be interested in overwriting this.
+        $diff = static::get_max_value() - static::get_min_value();
+        if (($value - static::get_min_value()) / $diff >= 0.5) {
+            return self::OUTCOME_VERY_POSITIVE;
+        }
+        return self::OUTCOME_VERY_NEGATIVE;
+    }
+
+    /**
+     * Gets the maximum value for this target
+     *
+     * @return float
+     */
+    public static function get_max_value() {
+        // Coding exception as this will only be called if this target have linear values.
+        throw new \coding_exception('Overwrite get_max_value() and return the target max value');
+    }
+
+    /**
+     * Gets the minimum value for this target
+     *
+     * @return float
+     */
+    public static function get_min_value() {
+        // Coding exception as this will only be called if this target have linear values.
+        throw new \coding_exception('Overwrite get_min_value() and return the target min value');
+    }
+
+    /**
+     * This method determines if a prediction is interesing for the model or not.
+     *
+     * @param mixed $predictedvalue
+     * @param float $predictionscore
+     * @return bool
+     */
+    public function triggers_callback($predictedvalue, $predictionscore) {
+
+        if (!parent::triggers_callback($predictedvalue, $predictionscore)) {
+            return false;
+        }
+
+        // People may not want to set a boundary.
+        $boundary = $this->get_callback_boundary();
+        if (!empty($boundary) && floatval($predictedvalue) < $boundary) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Returns the minimum value that triggers the callback.
+     *
+     * @return float
+     */
+    protected function get_callback_boundary() {
+        // Coding exception as this will only be called if this target have linear values.
+        throw new \coding_exception('Overwrite get_callback_boundary() and return the min value that ' .
+            'should trigger the callback');
+    }
+}

analytics/classes/local/time_splitting/accumulative_parts.php

@@ -0,0 +1,72 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Range processor splitting the course in parts and accumulating data from the start.
+ *
+ * @package   core_analytics
+ * @copyright 2017 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\time_splitting;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Range processor splitting the course in parts and accumulating data from the start.
+ *
+ * @package   core_analytics
+ * @copyright 2017 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+abstract class accumulative_parts extends base implements before_now {
+
+    /**
+     * The number of parts to split the analysable duration in.
+     *
+     * @return int
+     */
+    abstract protected function get_number_parts();
+
+    /**
+     * define_ranges
+     *
+     * @return array
+     */
+    protected function define_ranges() {
+
+        $nparts = $this->get_number_parts();
+
+        $rangeduration = ($this->analysable->get_end() - $this->analysable->get_start()) / $nparts;
+
+        $ranges = array();
+        for ($i = 0; $i < $nparts; $i++) {
+            $end = $this->analysable->get_start() + intval($rangeduration * ($i + 1));
+            if ($i === ($nparts - 1)) {
+                // Better to use the end for the last one as we are using floor above.
+                $end = $this->analysable->get_end();
+            }
+            $ranges[$i] = array(
+                'start' => $this->analysable->get_start(),
+                'end' => $end,
+                'time' => $end
+            );
+        }
+
+        return $ranges;
+    }
+}

analytics/classes/local/time_splitting/after_now.php

@@ -0,0 +1,37 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Interface for time-splitting methods whose ranges' times are after time().
+ *
+ * @package   core_analytics
+ * @copyright 2019 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\time_splitting;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Interface for time-splitting methods whose ranges' times are after time().
+ *
+ * @package   core_analytics
+ * @copyright 2019 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+interface after_now {
+}

analytics/classes/local/time_splitting/after_start.php

@@ -0,0 +1,111 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Time splitting method that generates predictions X days/weeks/months after the analysable start.
+ *
+ * @package   core_analytics
+ * @copyright 2019 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\time_splitting;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Time splitting method that generates predictions X days/weeks/months after the analysable start.
+ *
+ * @package   core_analytics
+ * @copyright 2019 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+abstract class after_start extends \core_analytics\local\time_splitting\base implements before_now {
+
+    /**
+     * The period we should wait until we generate predictions for this.
+     *
+     * @param  \core_analytics\analysable $analysable
+     * @return \DateInterval
+     */
+    abstract protected function wait_period(\core_analytics\analysable $analysable);
+
+    /**
+     * Returns whether the course can be processed by this time splitting method or not.
+     *
+     * @param \core_analytics\analysable $analysable
+     * @return bool
+     */
+    public function is_valid_analysable(\core_analytics\analysable $analysable) {
+
+        if (!$analysable->get_start()) {
+            return false;
+        }
+
+        $predictionstart = $this->get_prediction_interval_start($analysable);
+        if ($analysable->get_start() > $predictionstart) {
+            // We still need to wait.
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * This time-splitting method returns one single range, the start to two days before the end.
+     *
+     * @return array The list of ranges, each of them including 'start', 'end' and 'time'
+     */
+    protected function define_ranges() {
+
+        $now = time();
+        $ranges = [
+            [
+                'start' => $this->analysable->get_start(),
+                'end' => $now,
+                'time' => $now,
+            ]
+        ];
+
+        return $ranges;
+    }
+
+    /**
+     * Whether to cache or not the indicator calculations.
+     *
+     * @return bool
+     */
+    public function cache_indicator_calculations(): bool {
+        return false;
+    }
+
+    /**
+     * Calculates the interval start time backwards, from now.
+     *
+     * @param  \core_analytics\analysable $analysable
+     * @return int
+     */
+    protected function get_prediction_interval_start(\core_analytics\analysable $analysable) {
+
+        // The prediction time is always time(). We don't want to reuse the firstanalysis time
+        // because otherwise samples (e.g. students) which start after the analysable (e.g. course)
+        // start would use an incorrect analysis interval.
+        $predictionstart = new \DateTime('now');
+        $predictionstart->sub($this->wait_period($analysable));
+
+        return $predictionstart->getTimestamp();
+    }
+}

analytics/classes/local/time_splitting/base.php

@@ -0,0 +1,311 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Base time splitting method.
+ *
+ * @package   core_analytics
+ * @copyright 2016 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\time_splitting;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Base time splitting method.
+ *
+ * @package   core_analytics
+ * @copyright 2016 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+abstract class base {
+
+    /**
+     * @var string
+     */
+    protected $id;
+
+    /**
+     * The model id.
+     *
+     * @var int
+     */
+    protected $modelid;
+
+    /**
+     * @var \core_analytics\analysable
+     */
+    protected $analysable;
+
+    /**
+     * @var array
+     */
+    protected $ranges = [];
+
+    /**
+     * Define the time splitting methods ranges.
+     *
+     * 'time' value defines when predictions are executed, their values will be compared with
+     * the current time in ready_to_predict. The ranges should be sorted by 'time' in
+     * ascending order.
+     *
+     * @return array('start' => time(), 'end' => time(), 'time' => time())
+     */
+    abstract protected function define_ranges();
+
+    /**
+     * Returns a lang_string object representing the name for the time splitting method.
+     *
+     * Used as column identificator.
+     *
+     * If there is a corresponding '_help' string this will be shown as well.
+     *
+     * @return \lang_string
+     */
+    abstract public static function get_name(): \lang_string;
+
+    /**
+     * Returns the time splitting method id.
+     *
+     * @return string
+     */
+    public function get_id() {
+        return '\\' . get_class($this);
+    }
+
+    /**
+     * Assigns the analysable and updates the time ranges according to the analysable start and end dates.
+     *
+     * @param \core_analytics\analysable $analysable
+     * @return void
+     */
+    public function set_analysable(\core_analytics\analysable $analysable) {
+        $this->analysable = $analysable;
+        $this->ranges = $this->define_ranges();
+        $this->validate_ranges();
+    }
+
+    /**
+     * Assigns the model id to this time-splitting method it case it needs it.
+     *
+     * @param int $modelid
+     */
+    public function set_modelid(int $modelid) {
+        $this->modelid = $modelid;
+    }
+
+    /**
+     * get_analysable
+     *
+     * @return \core_analytics\analysable
+     */
+    public function get_analysable() {
+        return $this->analysable;
+    }
+
+    /**
+     * Returns whether the course can be processed by this time splitting method or not.
+     *
+     * @param \core_analytics\analysable $analysable
+     * @return bool
+     */
+    public function is_valid_analysable(\core_analytics\analysable $analysable) {
+        return true;
+    }
+
+    /**
+     * Should we predict this time range now?
+     *
+     * @param array $range
+     * @return bool
+     */
+    public function ready_to_predict($range) {
+        if ($range['time'] <= time()) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Should we use this time range for training?
+     *
+     * @param array $range
+     * @return bool
+     */
+    public function ready_to_train($range) {
+        $now = time();
+        if ($range['time'] <= $now && $range['end'] <= $now) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Returns the ranges used by this time splitting method.
+     *
+     * @return array
+     */
+    public function get_all_ranges() {
+        return $this->ranges;
+    }
+
+    /**
+     * By default all ranges are for training.
+     *
+     * @return array
+     */
+    public function get_training_ranges() {
+        return $this->ranges;
+    }
+
+    /**
+     * Returns the distinct range indexes in this time splitting method.
+     *
+     * @return int[]
+     */
+    public function get_distinct_ranges() {
+        if ($this->include_range_info_in_training_data()) {
+            return array_keys($this->ranges);
+        } else {
+            return [0];
+        }
+    }
+
+    /**
+     * Returns the most recent range that can be used to predict.
+     *
+     * This method is only called when calculating predictions.
+     *
+     * @return array
+     */
+    public function get_most_recent_prediction_range() {
+
+        $ranges = $this->get_all_ranges();
+
+        // Opposite order as we are interested in the last range that can be used for prediction.
+        krsort($ranges);
+
+        // We already provided the analysable to the time splitting method, there is no need to feed it back.
+        foreach ($ranges as $rangeindex => $range) {
+            if ($this->ready_to_predict($range)) {
+                // We need to maintain the same indexes.
+                return array($rangeindex => $range);
+            }
+        }
+
+        return array();
+    }
+
+    /**
+     * Returns range data by its index.
+     *
+     * @param int $rangeindex
+     * @return array|false Range data or false if the index is not part of the existing ranges.
+     */
+    public function get_range_by_index($rangeindex) {
+        if (!isset($this->ranges[$rangeindex])) {
+            return false;
+        }
+        return $this->ranges[$rangeindex];
+    }
+
+    /**
+     * Generates a unique sample id (sample in a range index).
+     *
+     * @param int $sampleid
+     * @param int $rangeindex
+     * @return string
+     */
+    final public function append_rangeindex($sampleid, $rangeindex) {
+        return $sampleid . '-' . $rangeindex;
+    }
+
+    /**
+     * Returns the sample id and the range index from a uniquesampleid.
+     *
+     * @param string $uniquesampleid
+     * @return array array($sampleid, $rangeindex)
+     */
+    final public function infer_sample_info($uniquesampleid) {
+        return explode('-', $uniquesampleid);
+    }
+
+    /**
+     * Whether to include the range index in the training data or not.
+     *
+     * By default, we consider that the different time ranges included in a time splitting method may not be
+     * compatible between them (i.e. the indicators calculated at the end of the course can easily
+     * differ from indicators calculated at the beginning of the course). So we include the range index as
+     * one of the variables that the machine learning backend uses to generate predictions.
+     *
+     * If the indicators calculated using the different time ranges available in this time splitting method
+     * are comparable you can overwrite this method to return false.
+     *
+     * Note that:
+     *  - This is only relevant for models whose predictions are not based on assumptions
+     *    (i.e. the ones using a machine learning backend to generate predictions).
+     *  - The ranges can only be included in the training data when
+     *    we know the final number of ranges the time splitting method will have. E.g.
+     *    We can not know the final number of ranges of a 'daily' time splitting method
+     *    as we will have one new range every day.
+     * @return bool
+     */
+    public function include_range_info_in_training_data() {
+        return true;
+    }
+
+    /**
+     * Whether to cache or not the indicator calculations.
+     *
+     * Indicator calculations are stored to be reused across models. The calculations
+     * are indexed by the calculation start and end time, and these times depend on the
+     * time-splitting method. You should overwrite this method and return false if the time
+     * frames generated by your time-splitting method are unique and / or can hardly be
+     * reused by further models.
+     *
+     * @return bool
+     */
+    public function cache_indicator_calculations(): bool {
+        return true;
+    }
+
+    /**
+     * Is this method valid to evaluate prediction models?
+     *
+     * @return bool
+     */
+    public function valid_for_evaluation(): bool {
+        return true;
+    }
+
+    /**
+     * Validates the time splitting method ranges.
+     *
+     * @throws \coding_exception
+     * @return void
+     */
+    protected function validate_ranges() {
+        foreach ($this->ranges as $key => $range) {
+            if (!isset($this->ranges[$key]['start']) || !isset($this->ranges[$key]['end']) ||
+                    !isset($this->ranges[$key]['time'])) {
+                throw new \coding_exception($this->get_id() . ' time splitting method "' . $key .
+                    '" range is not fully defined. We need a start timestamp and an end timestamp.');
+            }
+        }
+    }
+}

analytics/classes/local/time_splitting/before_now.php

@@ -0,0 +1,37 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Interface for time-splitting methods whose ranges' times are before time().
+ *
+ * @package   core_analytics
+ * @copyright 2019 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\time_splitting;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Interface for time-splitting methods whose ranges' times are before time().
+ *
+ * @package   core_analytics
+ * @copyright 2019 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+interface before_now {
+}

analytics/classes/local/time_splitting/equal_parts.php

@@ -0,0 +1,88 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * X parts time splitting method.
+ *
+ * @package   core_analytics
+ * @copyright 2017 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\time_splitting;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * X parts time splitting method.
+ *
+ * @package   core_analytics
+ * @copyright 2017 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+abstract class equal_parts extends base implements before_now {
+
+    /**
+     * Returns the number of parts the analyser duration should be split in.
+     *
+     * @return int
+     */
+    abstract protected function get_number_parts();
+
+    /**
+     * Splits the analysable duration in X equal parts from the start to the end.
+     *
+     * @return array
+     */
+    protected function define_ranges() {
+
+        $nparts = $this->get_number_parts();
+
+        $rangeduration = ($this->analysable->get_end() - $this->analysable->get_start()) / $nparts;
+
+        if ($rangeduration < $nparts) {
+            // It is interesting to avoid having a single timestamp belonging to multiple time ranges
+            // because of things like community of inquiry indicators, where activities have a due date
+            // that, ideally, would fall only into 1 time range. If the analysable duration is very short
+            // it is because the model doesn't contain indicators that depend so heavily on time and therefore
+            // we don't need to worry about timestamps being present in multiple time ranges.
+            $allowmultipleranges = true;
+        }
+
+        $ranges = array();
+        for ($i = 0; $i < $nparts; $i++) {
+            $start = $this->analysable->get_start() + intval($rangeduration * $i);
+            $end = $this->analysable->get_start() + intval($rangeduration * ($i + 1));
+
+            if (empty($allowmultipleranges) && $i > 0 && $start === $ranges[$i - 1]['end']) {
+                // We add 1 second so each timestamp only belongs to 1 range.
+                $start = $start + 1;
+            }
+
+            if ($i === ($nparts - 1)) {
+                // Better to use the end for the last one as we are using floor above.
+                $end = $this->analysable->get_end();
+            }
+            $ranges[$i] = array(
+                'start' => $start,
+                'end' => $end,
+                'time' => $end
+            );
+        }
+
+        return $ranges;
+    }
+}

analytics/classes/local/time_splitting/past_periodic.php

@@ -0,0 +1,97 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Time splitting method that generates predictions regularly.
+ *
+ * @package   core_analytics
+ * @copyright 2019 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\time_splitting;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Time splitting method that generates predictions periodically.
+ *
+ * @package   core_analytics
+ * @copyright 2019 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+abstract class past_periodic extends periodic implements before_now {
+
+    /**
+     * Gets the next range with start on the provided time.
+     *
+     * The next range is based on the past period so we substract this
+     * range's periodicity from $time.
+     *
+     * @param  \DateTimeImmutable $time
+     * @return array
+     */
+    protected function get_next_range(\DateTimeImmutable $time) {
+
+        $end = $time->getTimestamp();
+        $start = $time->sub($this->periodicity())->getTimestamp();
+
+        if ($start < $this->analysable->get_start()) {
+            // We skip the first range generated as its start is prior to the analysable start.
+            return false;
+        }
+
+        return [
+            'start' => $start,
+            'end' => $end,
+            'time' => $end
+        ];
+    }
+
+    /**
+     * Get the start of the first time range.
+     *
+     * @return int A timestamp.
+     */
+    protected function get_first_start() {
+        return $this->analysable->get_start();
+    }
+
+    /**
+     * Guarantees that the last range dates end right now.
+     *
+     * @param  array  $ranges
+     * @return array
+     */
+    protected function update_last_range(array $ranges) {
+        $lastrange = end($ranges);
+
+        if ($lastrange['time'] > time()) {
+            // We just need to wait in this case.
+            return $lastrange;
+        }
+
+        $timetoenddiff = time() - $lastrange['time'];
+
+        $ranges[count($ranges) - 1] = [
+            'start' => $lastrange['start'] + $timetoenddiff,
+            'end' => $lastrange['end'] + $timetoenddiff,
+            'time' => $lastrange['time'] + $timetoenddiff,
+        ];
+
+        return $ranges;
+    }
+}

analytics/classes/local/time_splitting/periodic.php

@@ -0,0 +1,162 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Time splitting method that generates predictions regularly.
+ *
+ * @package   core_analytics
+ * @copyright 2019 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\time_splitting;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Time splitting method that generates predictions periodically.
+ *
+ * @package   core_analytics
+ * @copyright 2019 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+abstract class periodic extends base {
+
+    /**
+     * The periodicity of the predictions / training data generation.
+     *
+     * @return \DateInterval
+     */
+    abstract protected function periodicity();
+
+    /**
+     * Gets the next range with start on the provided time.
+     *
+     * @param  \DateTimeImmutable $time
+     * @return array
+     */
+    abstract protected function get_next_range(\DateTimeImmutable $time);
+
+    /**
+     * Get the start of the first time range.
+     *
+     * @return int A timestamp.
+     */
+    abstract protected function get_first_start();
+
+    /**
+     * Returns whether the analysable can be processed by this time splitting method or not.
+     *
+     * @param \core_analytics\analysable $analysable
+     * @return bool
+     */
+    public function is_valid_analysable(\core_analytics\analysable $analysable) {
+        if (!$analysable->get_start()) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * define_ranges
+     *
+     * @return array
+     */
+    protected function define_ranges() {
+
+        $periodicity = $this->periodicity();
+
+        if ($this->analysable->get_end()) {
+            $end = (new \DateTimeImmutable())->setTimestamp($this->analysable->get_end());
+        }
+        $nexttime = (new \DateTimeImmutable())->setTimestamp($this->get_first_start());
+
+        $now = new \DateTimeImmutable('now', \core_date::get_server_timezone_object());
+
+        $range = $this->get_next_range($nexttime);
+        if (!$range) {
+            $nexttime = $nexttime->add($periodicity);
+            $range = $this->get_next_range($nexttime);
+
+            if (!$range) {
+                throw new \coding_exception('The get_next_range implementation is broken. The difference between two consecutive
+                    ranges can not be more than the periodicity.');
+            }
+        }
+
+        $ranges = [];
+        $endreached = false;
+        while (($this->ready_to_predict($range) || $this->ready_to_train($range)) && !$endreached) {
+            $ranges[] = $range;
+            $nexttime = $nexttime->add($periodicity);
+            $range = $this->get_next_range($nexttime);
+
+            $endreached = (!empty($end) && $nexttime > $end);
+        }
+
+        if ($ranges && !$endreached) {
+            // If this analysable is not finished we adjust the start and end of the last element in $ranges
+            // so that it ends in time().The reason is that the start of these ranges is based on the analysable
+            // start and the end is calculated based on the start. This is to prevent the same issue we had in MDL-65348.
+            //
+            // An example of the situation we want to avoid is:
+            // A course started on a Monday, in 2015. It has no end date. Now the system is upgraded to Moodle 3.8, which
+            // includes this code. This happens on Wednesday. Periodic ranges (e.g. weekly) will be calculated from a Monday
+            // so the data provided by the time-splitting method would be from Monday to Monday, when we really want to
+            // provide data from Wednesday to the past Wednesday.
+            $ranges = $this->update_last_range($ranges);
+        }
+
+        return $ranges;
+    }
+
+    /**
+     * Overwritten as all generated rows are comparable.
+     *
+     * @return bool
+     */
+    public function include_range_info_in_training_data() {
+        return false;
+    }
+
+    /**
+     * Overwritting as the last range may be for prediction.
+     *
+     * @return array
+     */
+    public function get_training_ranges() {
+        // Cloning the array.
+        $trainingranges = $this->ranges;
+
+        foreach ($trainingranges as $rangeindex => $range) {
+            if (!$this->ready_to_train($range)) {
+                unset($trainingranges[$rangeindex]);
+            }
+        }
+
+        return $trainingranges;
+    }
+
+    /**
+     * Allows child classes to update the last range provided.
+     *
+     * @param  array  $ranges
+     * @return array
+     */
+    protected function update_last_range(array $ranges) {
+        return $ranges;
+    }
+}

analytics/classes/local/time_splitting/upcoming_periodic.php

@@ -0,0 +1,96 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Time splitting method that generates predictions periodically.
+ *
+ * @package   core_analytics
+ * @copyright 2019 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_analytics\local\time_splitting;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Time splitting method that generates predictions periodically.
+ *
+ * @package   core_analytics
+ * @copyright 2019 David Monllao {@link http://www.davidmonllao.com}
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+abstract class upcoming_periodic extends periodic implements after_now {
+
+    /**
+     * Gets the next range with start on the provided time.
+     *
+     * The next range is based on the upcoming period so we add this
+     * range's periodicity to $time.
+     *
+     * @param  \DateTimeImmutable $time
+     * @return array
+     */
+    protected function get_next_range(\DateTimeImmutable $time) {
+
+        $start = $time->getTimestamp();
+        $end = $time->add($this->periodicity())->getTimestamp();
+        return [
+            'start' => $start,
+            'end' => $end,
+            'time' => $start
+        ];
+    }
+
+    /**
+     * Whether to cache or not the indicator calculations.
+     * @return bool
+     */
+    public function cache_indicator_calculations(): bool {
+        return false;
+    }
+
+    /**
+     * Overriden as these time-splitting methods are based on future dates.
+     *
+     * @return bool
+     */
+    public function valid_for_evaluation(): bool {
+        return false;
+    }
+
+    /**
+     * Get the start of the first time range.
+     *
+     * Overwriten to start generating predictions about upcoming stuff from time().
+     *
+     * @return int A timestamp.
+     */
+    protected function get_first_start() {
+        global $DB;
+
+        $cache = \cache::make('core', 'modelfirstanalyses');
+
+        $key = $this->modelid . '_' . $this->analysable->get_id();
+        $firstanalysis = $cache->get($key);
+        if (!empty($firstanalysis)) {
+            return $firstanalysis;
+        }
+
+        // This analysable has not yet been analysed, the start is therefore now.
+        return time();
+    }
+}