Proyectos de Subversion Moodle

<?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/>.

/**

 * Date condition.

 *

 * @package   availability_relativedate

 * @copyright 2022 eWallah.net

 * @author    Renaat Debleu <info@eWallah.net>

 * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

namespace availability_relativedate;

use context_course;

use core_availability\info;

use stdClass;

/**

 * relativedate from course start condition.

 *

 * @package   availability_relativedate

 * @copyright 2022 eWallah.net

 * @author    Renaat Debleu <info@eWallah.net>

 * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

class condition extends \core_availability\condition {

    /** @var int relativenumber (how many relative) for condition. */

    private $relativenumber;

    /** @var int relativedwm (what does the date relates to) for condition.

     *

     * 0 => minutes

     * 1 => hours

     * 2 => days

     * 3 => weeks

     * 4 => months

     */

    private $relativedwm;

    /** @var int relativestart (what date relates to) for condition.

     *

     * 1 => After Course start date

     * 2 => Before Course end date

     * 3 => After User enrolment date

     * 4 => After Enrolment method end date

     * 5 => After Course End date

     * 6 => Before Course start date

     * 7 => After completion of an activity

     */

    private $relativestart;

    /**

     * @var int Course module id of the activity used by type 6

     */

    private $relativecoursemodule;

    /**

     * Constructor.

     *

     * @param stdClass $structure Data structure from JSON decode.

     */

    public function __construct($structure) {

        $this->relativenumber = property_exists($structure, 'n') ? (int)$structure->n : 1;

        $this->relativedwm = property_exists($structure, 'd') ? (int)$structure->d : 2;

        $this->relativestart = property_exists($structure, 's') ? (int)$structure->s : 1;

        $this->relativecoursemodule = property_exists($structure, 'm') ? (int)$structure->m : 0;

    }

    /**

     * Saves the data.

     *

     * @return object data structure.

     */

    public function save() {

        return (object)[

            'type' => 'relativedate',

            'n' => intval($this->relativenumber),

            'd' => intval($this->relativedwm),

            's' => intval($this->relativestart),

            'm' => intval($this->relativecoursemodule),

        ];

    }

    /**

     * Determines whether this particular item is currently available.

     *

     * @param bool $not

     * @param info $info

     * @param bool $grabthelot

     * @param int $userid If set, specifies a different user ID to check availability for

     * @return bool True if this item is available to the user, false otherwise

     */

    public function is_available($not, info $info, $grabthelot, $userid) {

        $calc = $this->calc($info->get_course(), $userid);

        if ($calc === 0) {

            // Always not available if for some reason the value could not be calculated.

            return false;

        }

        $allow = time() >= $calc;

        if ($not) {

            $allow = !$allow;

        }

        return $allow;

    }

    /**

     * Obtains a string describing this restriction (whether or not it actually applies).

     *

     * @param bool $full Set true if this is the 'full information' view

     * @param bool $not Set true if we are inverting the condition

     * @param info $info Item we're checking

     * @return string Information string (for admin) about all restrictions on this item

     */

    public function get_description($full, $not, info $info): string {

        global $USER;

        $course = $info->get_course();

        $capability = has_capability('moodle/course:manageactivities', context_course::instance($course->id));

        $relative = (int)$this->relativestart;

        if ($relative === 2 || $relative === 5) {

            if ((!isset($course->enddate) || (int)$course->enddate === 0) && $capability) {

                return get_string('noenddate', 'availability_relativedate');

            }

        }

        if ($relative === 2 || $relative === 6) {

            $frut = $not ? 'from' : 'until';

        } else {

            $frut = $not ? 'until' : 'from';

        }

        $calc = $this->calc($course, $USER->id);

        if ($calc === 0) {

            return '(' . trim($this->get_debug_string()) . ')';

        }

        $a = new stdClass();

        $a->rnumber = userdate($calc, get_string('strftimedatetime', 'langconfig'));

        $a->rtime = ($capability && $full) ? '(' . trim($this->get_debug_string()) . ')' : '';

        $a->rela = '';

        return trim(get_string($frut, 'availability_relativedate', $a));

    }

    /**

     * Obtains a representation of the options of this condition as a string for debugging.

     *

     * @return string Text representation of parameters

     */

    protected function get_debug_string() {

        $modname = '';

        if ((int)$this->relativestart === 7) {

            $modname = ' ';

            if ($this->relativecoursemodule != -1 && get_coursemodule_from_id('', $this->relativecoursemodule)) {

                $modname .= \core_availability\condition::description_cm_name($this->relativecoursemodule);

            } else {

                $modname .= \html_writer::span(get_string('missing', 'availability_relativedate'), 'alert alert-danger');

            }

        }

        return ' ' . $this->relativenumber . ' ' . self::options_dwm($this->relativenumber)[$this->relativedwm] . ' ' .

               self::options_start($this->relativestart) . $modname;

    }

    /**

     * Obtains a the options for days week months.

     *

     * @param int $i index

     * @return string

     */

    public static function options_start(int $i) {

        switch ($i) {

            case 1:

                return get_string('datestart', 'availability_relativedate');

            case 2:

                return get_string('dateend', 'availability_relativedate');

            case 3:

                return get_string('dateenrol', 'availability_relativedate');

            case 4:

                return get_string('dateendenrol', 'availability_relativedate');

            case 5:

                return get_string('dateendafter', 'availability_relativedate');

            case 6:

                return get_string('datestartbefore', 'availability_relativedate');

            case 7:

                return get_string('datecompletion', 'availability_relativedate');

        }

        return '';

    }

    /**

     * Obtains a the options for hours days weeks months.

     *

     * @param int $number

     * @return array

     */

    public static function options_dwm($number = 2) {

        $s = $number === 1 ? '' : 's';

        return [

            1 => get_string('hour' . $s, 'availability_relativedate'),

            2 => get_string('day' . $s, 'availability_relativedate'),

            3 => get_string('week' . $s, 'availability_relativedate'),

            4 => get_string('month' . $s, 'availability_relativedate'),

        ];

    }

    /**

     * Obtains a the options for hour day week month.

     *

     * @param int $i

     * @return string

     */

    public static function option_dwm(int $i): string {

        switch ($i) {

            case 0:

                return 'minute';

            case 1:

                return 'hour';

            case 2:

                return 'day';

            case 3:

                return 'week';

            case 4:

                return 'month';

        }

        return '';

    }

    /**

     * Perform the calculation.

     *

     * @param stdClass $course

     * @param int $userid

     * @return int relative date.

     */

    private function calc($course, $userid): int {

        $x = $this->relativenumber . ' ' . $this->option_dwm($this->relativedwm);

        switch ($this->relativestart) {

            case 6:

                // Before course start date.

                return $this->fixdate("-$x", $course->startdate);

            case 2:

                // Before course end date.

                return $this->fixdate("-$x", $course->enddate);

            case 5:

                // After course end date.

                return $this->fixdate("+$x", $course->enddate);

            case 3:

                // After latest enrolment start date.

                $sql = 'SELECT ue.timestart

                        FROM {user_enrolments} ue

                        JOIN {enrol} e on ue.enrolid = e.id

                        WHERE e.courseid = :courseid AND ue.userid = :userid AND ue.timestart > 0

                        ORDER by ue.timestart DESC';

                $lowest = $this->getlowest($sql, ['courseid' => $course->id, 'userid' => $userid]);

                if ($lowest === 0) {

                    // A teacher or admin without restriction - or a student with no limit set?

                    $sql = 'SELECT ue.timecreated

                            FROM {user_enrolments} ue

                            JOIN {enrol} e on (e.id = ue.enrolid AND e.courseid = :courseid)

                            WHERE ue.userid = :userid

                            ORDER by ue.timecreated DESC';

                    $lowest = $this->getlowest($sql, ['courseid' => $course->id, 'userid' => $userid]);

                }

                return $this->fixdate("+$x", $lowest);

            case 4:

                // After latest enrolment end date.

                $sql = 'SELECT e.enrolenddate

                        FROM {user_enrolments} ue

                        JOIN {enrol} e on ue.enrolid = e.id

                        WHERE e.courseid = :courseid AND ue.userid = :userid

                        ORDER by e.enrolenddate DESC';

                $lowest = $this->getlowest($sql, ['courseid' => $course->id, 'userid' => $userid]);

                return $this->fixdate("+$x", $lowest);

            case 7:

                // Since completion of a module.

                if ($this->relativecoursemodule < 1) {

                    return 0;

                }

                $cm = new stdClass();

                $cm->id = $this->relativecoursemodule;

                $cm->course = $course->id;

                try {

                    $completion = new \completion_info($course);

                    $data = $completion->get_data($cm, false, $userid);

                    return $this->fixdate("+$x", $data->timemodified);

                } catch (\Exception $e) {

                    return 0;

                }

        }

        // After course start date.

        return $this->fixdate("+$x", $course->startdate);

    }

    /**

     * Get the record with the lowest value.

     *

     * @param string $sql

     * @param array $parameters

     * @return int lowest value.

     */

    private function getlowest($sql, $parameters): int {

        global $DB;

        if ($lowestrec = $DB->get_record_sql($sql, $parameters, IGNORE_MULTIPLE)) {

            $recs = array_values(get_object_vars($lowestrec));

            foreach ($recs as $value) {

                return $value;

            }

        }

        return 0;

    }

    /**

     * Keep the original hour.

     *

     * @param string $calc

     * @param int $newdate

     * @return int relative date.

     */

    private function fixdate($calc, $newdate): int {

        if ($newdate > 0) {

            $olddate = strtotime($calc, $newdate);

            if ($this->relativedwm > 1) {

                $arr1 = getdate($olddate);

                $arr2 = getdate($newdate);

                return mktime($arr2['hours'], $arr2['minutes'], $arr2['seconds'], $arr1['mon'], $arr1['mday'], $arr1['year']);

            }

            return $olddate;

        }

        return 0;

    }

    /**

     * Used in course/lib.php because we need to disable the completion JS if

     * a completion value affects a conditional activity.

     * @param int|stdClass $course Moodle course object

     * @param int $cmid Course-module id

     * @return bool True if this is used in a condition, false otherwise

     */

    public static function completion_value_used($course, $cmid): bool {

        global $DB;

        $courseobj = (is_object($course)) ? $course : get_course($course);

        $modinfo = get_fast_modinfo($courseobj);

        foreach ($modinfo->cms as $othercm) {

            if (is_null($othercm->availability)) {

                continue;

            }

            $ci = new \core_availability\info_module($othercm);

            $tree = $ci->get_availability_tree();

            foreach ($tree->get_all_children('availability_relativedate\condition') as $cond) {

                if ((int)$cond->relativestart === 7 && (int)$cond->relativecoursemodule === (int)$cmid) {

                    return true;

                }

            }

        }

        // Availability of sections (get_section_info_all) is always null.

        $sqllike = $DB->sql_like('availability', ':availability');

        $params = ['course' => $courseobj->id, 'availability' => '%"s":7,"m":' . $cmid . '%'];

        return count($DB->get_records_sql("SELECT id FROM {course_sections} WHERE course = :course AND $sqllike", $params)) > 0;

    }

    /**

     * Helper for updating ids, implemented for course modules and sections

     *

     * @param string $table

     * @param int $oldid

     * @param int $newid

     * @return bool

     */

    public function update_dependency_id($table, $oldid, $newid) {

        if (

            ($table === 'course_modules' || $table === 'course_sections') &&

            (int)$this->relativestart === 7 &&

            (int)$this->relativecoursemodule === (int)$oldid

        ) {

            $this->relativecoursemodule = $newid;

            return true;

        }

        return false;

    }

    /**

     * Updates this node after restore, returning true if anything changed.

     *

     * @param string $restoreid Restore ID

     * @param int $courseid ID of target course

     * @param \base_logger $logger Logger for any warnings

     * @param string $name Name of this item (for use in warning messages)

     * @return bool True if there was any change

     */

    public function update_after_restore($restoreid, $courseid, \base_logger $logger, $name): bool {

        global $DB;

        $rec = \restore_dbops::get_backup_ids_record($restoreid, 'course_module', $this->relativecoursemodule);

        if (!$rec || !$rec->newitemid) {

            // If we are on the same course (e.g. duplicate) then we can just use the existing one.

            if (!$DB->record_exists('course_modules', ['id' => $this->relativecoursemodule, 'course' => $courseid])) {

                $this->relativecoursemodule = 0;

                $logger->process(

                    "Restored item ($name has availability condition on module that was not restored",

                    \backup::LOG_WARNING

                );

            }

        } else {

            $this->relativecoursemodule = (int)$rec->newitemid;

        }

        return true;

    }

}