Chapitre 6.5 — Tutoriel complet : un module d’activité (mod_simplecheck)

public/mod/simplecheck/
├── version.php
├── lib.php                       ← FEATURE_*, add/update/delete, grades, reset
├── mod_form.php                  ← formulaire de réglage de l'instance
├── view.php                      ← la page « ouvrir l'activité »
├── index.php                     ← liste des instances du module dans un cours
├── db/
│   ├── access.php                ← capabilities
│   ├── install.xml               ← schéma (3 tables)
│   └── upgrade.php
├── classes/
│   ├── completion/
│   │   └── custom_completion.php ← règle d'achèvement personnalisée
│   ├── event/
│   │   └── course_module_viewed.php
│   └── output/
│       ├── checklist.php         ← renderable
│       └── renderer.php
├── backup/
│   └── moodle2/
│       ├── backup_simplecheck_activity_task.class.php
│       ├── backup_simplecheck_stepslib.php
│       ├── restore_simplecheck_activity_task.class.php
│       └── restore_simplecheck_stepslib.php
├── templates/
│   └── checklist.mustache
└── lang/
    └── en/
        └── simplecheck.php       ← NB : nommé d'après le module, sans « mod_ »

<?php
// public/mod/simplecheck/version.php
defined('MOODLE_INTERNAL') || die();
 
$plugin->component = 'mod_simplecheck';
$plugin->version   = 2026070800;
$plugin->requires  = 2026042000;   // Moodle 5.2
$plugin->maturity  = MATURITY_STABLE;
$plugin->release   = 'v1.0';

<?xml version="1.0" encoding="UTF-8" ?>
<!-- public/mod/simplecheck/db/install.xml -->
<XMLDB PATH="mod/simplecheck/db" VERSION="2026070800"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="../../../lib/xmldb/xmldb.xsd">
  <TABLES>
    <!-- Table principale : DOIT s'appeler comme le module. -->
    <TABLE NAME="simplecheck" COMMENT="Instances de l'activité checklist notée">
      <FIELDS>
        <FIELD NAME="id" TYPE="int" LENGTH="10" NOTNULL="true" SEQUENCE="true"/>
        <FIELD NAME="course" TYPE="int" LENGTH="10" NOTNULL="true" SEQUENCE="false"
               COMMENT="Cours propriétaire (obligatoire pour un mod)"/>
        <FIELD NAME="name" TYPE="char" LENGTH="255" NOTNULL="true" SEQUENCE="false"
               COMMENT="Nom de l'activité (obligatoire)"/>
        <FIELD NAME="intro" TYPE="text" NOTNULL="false" SEQUENCE="false"
               COMMENT="Description (obligatoire pour FEATURE_MOD_INTRO)"/>
        <FIELD NAME="introformat" TYPE="int" LENGTH="4" NOTNULL="true" DEFAULT="0" SEQUENCE="false"/>
        <FIELD NAME="grade" TYPE="int" LENGTH="10" NOTNULL="true" DEFAULT="100" SEQUENCE="false"
               COMMENT="Note maximale"/>
        <FIELD NAME="timecreated" TYPE="int" LENGTH="10" NOTNULL="true" DEFAULT="0" SEQUENCE="false"/>
        <FIELD NAME="timemodified" TYPE="int" LENGTH="10" NOTNULL="true" DEFAULT="0" SEQUENCE="false"/>
      </FIELDS>
      <KEYS>
        <KEY NAME="primary" TYPE="primary" FIELDS="id"/>
        <KEY NAME="course" TYPE="foreign" FIELDS="course" REFTABLE="course" REFFIELDS="id"/>
      </KEYS>
    </TABLE>
 
    <!-- Items de la checklist, définis par l'enseignant. -->
    <TABLE NAME="simplecheck_item" COMMENT="Items d'une checklist">
      <FIELDS>
        <FIELD NAME="id" TYPE="int" LENGTH="10" NOTNULL="true" SEQUENCE="true"/>
        <FIELD NAME="simplecheckid" TYPE="int" LENGTH="10" NOTNULL="true" SEQUENCE="false"/>
        <FIELD NAME="name" TYPE="char" LENGTH="255" NOTNULL="true" SEQUENCE="false"/>
        <FIELD NAME="position" TYPE="int" LENGTH="10" NOTNULL="true" DEFAULT="0" SEQUENCE="false"/>
      </FIELDS>
      <KEYS>
        <KEY NAME="primary" TYPE="primary" FIELDS="id"/>
        <KEY NAME="simplecheckid" TYPE="foreign" FIELDS="simplecheckid" REFTABLE="simplecheck" REFFIELDS="id"/>
      </KEYS>
    </TABLE>
 
    <!-- Coches des étudiants. -->
    <TABLE NAME="simplecheck_check" COMMENT="État coché par étudiant et par item">
      <FIELDS>
        <FIELD NAME="id" TYPE="int" LENGTH="10" NOTNULL="true" SEQUENCE="true"/>
        <FIELD NAME="simplecheckid" TYPE="int" LENGTH="10" NOTNULL="true" SEQUENCE="false"/>
        <FIELD NAME="itemid" TYPE="int" LENGTH="10" NOTNULL="true" SEQUENCE="false"/>
        <FIELD NAME="userid" TYPE="int" LENGTH="10" NOTNULL="true" SEQUENCE="false"/>
        <FIELD NAME="checked" TYPE="int" LENGTH="1" NOTNULL="true" DEFAULT="0" SEQUENCE="false"/>
        <FIELD NAME="timemodified" TYPE="int" LENGTH="10" NOTNULL="true" DEFAULT="0" SEQUENCE="false"/>
      </FIELDS>
      <KEYS>
        <KEY NAME="primary" TYPE="primary" FIELDS="id"/>
        <KEY NAME="itemid" TYPE="foreign" FIELDS="itemid" REFTABLE="simplecheck_item" REFFIELDS="id"/>
        <KEY NAME="userid" TYPE="foreign" FIELDS="userid" REFTABLE="user" REFFIELDS="id"/>
      </KEYS>
      <INDEXES>
        <INDEX NAME="simplecheckid-userid" UNIQUE="false" FIELDS="simplecheckid, userid"/>
      </INDEXES>
    </TABLE>
  </TABLES>
</XMLDB>

<?php
// public/mod/simplecheck/db/access.php
defined('MOODLE_INTERNAL') || die();
 
$capabilities = [
    // Ajouter l'activité dans un cours (le nom :addinstance est attendu par le core).
    'mod/simplecheck:addinstance' => [
        'riskbitmask'          => RISK_XSS,
        'captype'              => 'write',
        'contextlevel'         => CONTEXT_COURSE,
        'archetypes'           => ['editingteacher' => CAP_ALLOW, 'manager' => CAP_ALLOW],
        'clonepermissionsfrom' => 'moodle/course:manageactivities',
    ],
    // Voir/ouvrir l'activité.
    'mod/simplecheck:view' => [
        'captype'      => 'read',
        'contextlevel' => CONTEXT_MODULE,
        'archetypes'   => ['guest' => CAP_ALLOW, 'student' => CAP_ALLOW,
                           'teacher' => CAP_ALLOW, 'editingteacher' => CAP_ALLOW],
    ],
    // Cocher des items (soumettre sa progression).
    'mod/simplecheck:submit' => [
        'captype'      => 'write',
        'contextlevel' => CONTEXT_MODULE,
        'archetypes'   => ['student' => CAP_ALLOW],
    ],
    // Voir les résultats de tous les participants.
    'mod/simplecheck:viewreports' => [
        'captype'      => 'read',
        'contextlevel' => CONTEXT_MODULE,
        'archetypes'   => ['teacher' => CAP_ALLOW, 'editingteacher' => CAP_ALLOW, 'manager' => CAP_ALLOW],
    ],
];

<?php
// public/mod/simplecheck/lib.php
defined('MOODLE_INTERNAL') || die();
 
/**
 * Déclare les fonctionnalités supportées par le module.
 *
 * @param string $feature une constante FEATURE_*
 * @return mixed true/false, ou une valeur, ou null si inconnu.
 */
function simplecheck_supports($feature) {
    switch ($feature) {
        case FEATURE_MOD_INTRO:            return true;  // a une description
        case FEATURE_GRADE_HAS_GRADE:      return true;  // est noté
        case FEATURE_COMPLETION_TRACKS_VIEW: return true; // achèvement « vu »
        case FEATURE_COMPLETION_HAS_RULES: return true;  // achèvement à règles custom
        case FEATURE_BACKUP_MOODLE2:       return true;  // sauvegardable
        case FEATURE_GROUPS:               return true;
        case FEATURE_GROUPINGS:            return true;
        case FEATURE_SHOW_DESCRIPTION:     return true;
        case FEATURE_MOD_PURPOSE:          return MOD_PURPOSE_ASSESSMENT; // catégorie d'icône
        default:                           return null;  // inconnu : ne rien affirmer
    }
}

/**
 * Crée une instance. Reçoit les données du mod_form.
 *
 * @param stdClass $data données du formulaire (+ coursemodule)
 * @param mod_simplecheck_mod_form|null $mform
 * @return int l'id de la nouvelle instance
 */
function simplecheck_add_instance(stdClass $data, $mform = null): int {
    global $DB;
 
    $data->timecreated  = time();
    $data->timemodified = $data->timecreated;
 
    // Insère l'activité, récupère son id.
    $data->id = $DB->insert_record('simplecheck', $data);
 
    // Enregistre les items saisis (voir mod_form §6 : un textarea, un item par ligne).
    simplecheck_save_items($data);
 
    // Crée l'item de note dans le carnet de notes (§8).
    simplecheck_grade_item_update($data);
 
    return $data->id;
}
 
/**
 * Met à jour une instance.
 */
function simplecheck_update_instance(stdClass $data, $mform = null): bool {
    global $DB;
 
    $data->timemodified = time();
    $data->id           = $data->instance; // le core met l'id dans 'instance' à l'update.
 
    $DB->update_record('simplecheck', $data);
    simplecheck_save_items($data);
    simplecheck_grade_item_update($data);
    simplecheck_update_grades($data); // recalcule les notes (la note max a pu changer).
 
    return true;
}
 
/**
 * Supprime une instance et TOUTES ses données dépendantes.
 */
function simplecheck_delete_instance(int $id): bool {
    global $DB;
 
    if (!$simplecheck = $DB->get_record('simplecheck', ['id' => $id])) {
        return false;
    }
 
    // Ordre : données filles d'abord.
    $DB->delete_records('simplecheck_check', ['simplecheckid' => $id]);
    $DB->delete_records('simplecheck_item', ['simplecheckid' => $id]);
    $DB->delete_records('simplecheck', ['id' => $id]);
 
    // Retire l'item du carnet de notes.
    simplecheck_grade_item_update($simplecheck, 'reset');
 
    return true;
}

/**
 * (Ré)enregistre les items depuis le textarea du formulaire (un item par ligne).
 */
function simplecheck_save_items(stdClass $data): void {
    global $DB;
 
    // Stratégie simple : on efface et on réécrit les items.
    $DB->delete_records('simplecheck_item', ['simplecheckid' => $data->id]);
 
    $lines = preg_split('/\r\n|\r|\n/', (string) $data->items);
    $position = 0;
    foreach ($lines as $line) {
        $name = trim($line);
        if ($name === '') {
            continue;
        }
        $DB->insert_record('simplecheck_item', (object) [
            'simplecheckid' => $data->id,
            'name'          => $name,
            'position'      => $position++,
        ]);
    }
}

<?php
// public/mod/simplecheck/mod_form.php
defined('MOODLE_INTERNAL') || die();
 
require_once($CFG->dirroot . '/course/moodleform_mod.php');
 
class mod_simplecheck_mod_form extends moodleform_mod {
 
    public function definition(): void {
        $mform = $this->_form;
 
        // --- En-tête « Généraux » ---
        $mform->addElement('header', 'general', get_string('general', 'form'));
 
        // Nom de l'activité (champ standard obligatoire).
        $mform->addElement('text', 'name', get_string('name'), ['size' => 64]);
        $mform->setType('name', PARAM_TEXT);
        $mform->addRule('name', null, 'required', null, 'client');
 
        // Description standard (fournie par le core si FEATURE_MOD_INTRO).
        $this->standard_intro_elements();
 
        // --- Champs spécifiques ---
        $mform->addElement('header', 'itemshdr', get_string('items', 'mod_simplecheck'));
        $mform->addElement('textarea', 'items',
            get_string('items', 'mod_simplecheck'),
            ['rows' => 8, 'cols' => 60]);
        $mform->setType('items', PARAM_TEXT);
        $mform->addHelpButton('items', 'items', 'mod_simplecheck');
 
        // --- Éléments communs : notes, achèvement, groupes, visibilité… ---
        $this->standard_grading_coursemodule_elements(); // section « Note »
        $this->standard_coursemodule_elements();         // achèvement, groupes, restrictions…
 
        // Boutons standard (avec sesskey).
        $this->add_action_buttons();
    }
 
    /**
     * Pré-remplit le textarea d'items à l'édition (les items ne sont pas dans la table principale).
     */
    public function data_preprocessing(&$defaults): void {
        global $DB;
        if (!empty($this->current->id)) {
            $items = $DB->get_records('simplecheck_item',
                ['simplecheckid' => $this->current->id], 'position ASC');
            $defaults['items'] = implode("\n", array_map(fn($i) => $i->name, $items));
        }
    }
 
    /**
     * Règles d'achèvement personnalisées (affichées dans la section Achèvement).
     */
    public function add_completion_rules(): array {
        $mform = $this->_form;
        $mform->addElement('checkbox', 'completionallchecked',
            '', get_string('completionallchecked', 'mod_simplecheck'));
        return ['completionallchecked'];
    }
 
    public function completion_rule_enabled($data): bool {
        return !empty($data['completionallchecked']);
    }
}

<?php
// public/mod/simplecheck/view.php
require(__DIR__ . '/../../config.php');
require_once(__DIR__ . '/lib.php');
 
// L'activité s'ouvre soit par ?id=<cmid> (id du course module), soit par ?s=<instanceid>.
$id = optional_param('id', 0, PARAM_INT);
 
// get_coursemodule_from_id résout cm + course en vérifiant la cohérence.
[$course, $cm] = get_course_and_cm_from_cmid($id, 'simplecheck');
$simplecheck = $DB->get_record('simplecheck', ['id' => $cm->instance], '*', MUST_EXIST);
 
require_login($course, true, $cm);                 // login + inscription au cours + visibilité du cm
$context = context_module::instance($cm->id);      // contexte MODULE
require_capability('mod/simplecheck:view', $context);
 
// --- Déclenche l'event « activité vue » (traçabilité, achèvement « vu ») ---
$event = \mod_simplecheck\event\course_module_viewed::create([
    'objectid' => $simplecheck->id,
    'context'  => $context,
]);
$event->add_record_snapshot('course', $course);
$event->add_record_snapshot('simplecheck', $simplecheck);
$event->trigger();
 
// Marque la vue pour l'achèvement (FEATURE_COMPLETION_TRACKS_VIEW).
$completion = new completion_info($course);
$completion->set_module_viewed($cm);
 
// --- Traitement de la soumission (l'étudiant coche) ---
if (($data = data_submitted()) && confirm_sesskey()
        && has_capability('mod/simplecheck:submit', $context)) {
    simplecheck_save_user_checks($simplecheck, $USER->id, $data->check ?? []);
    simplecheck_update_grades($simplecheck, $USER->id); // met à jour SA note
    // Ré-évalue l'achèvement (une règle custom a pu passer à « terminé »).
    $completion->update_state($cm, COMPLETION_UNKNOWN, $USER->id);
    redirect(new moodle_url('/mod/simplecheck/view.php', ['id' => $cm->id]),
        get_string('saved', 'mod_simplecheck'), null,
        \core\output\notification::NOTIFY_SUCCESS);
}
 
// --- Configuration de page + rendu ---
$PAGE->set_url(new moodle_url('/mod/simplecheck/view.php', ['id' => $cm->id]));
$PAGE->set_context($context);
$PAGE->set_cm($cm, $course);
$PAGE->set_title(format_string($simplecheck->name));
$PAGE->set_heading(format_string($course->fullname));
 
$output     = $PAGE->get_renderer('mod_simplecheck');
$renderable = new \mod_simplecheck\output\checklist($simplecheck, $cm, $context, $USER->id);
 
echo $OUTPUT->header();
echo $OUTPUT->heading(format_string($simplecheck->name));
if (!empty($simplecheck->intro)) {
    echo $OUTPUT->box(format_module_intro('simplecheck', $simplecheck, $cm->id), 'generalbox', 'intro');
}
echo $output->render($renderable);
echo $OUTPUT->footer();

/**
 * Enregistre l'état coché des items pour un utilisateur.
 *
 * @param stdClass $simplecheck
 * @param int $userid
 * @param array $checked tableau [itemid => 1] des cases cochées
 */
function simplecheck_save_user_checks(stdClass $simplecheck, int $userid, array $checked): void {
    global $DB;
    $items = $DB->get_records('simplecheck_item', ['simplecheckid' => $simplecheck->id]);
    $now = time();
    foreach ($items as $item) {
        $ischecked = !empty($checked[$item->id]) ? 1 : 0;
        $existing = $DB->get_record('simplecheck_check',
            ['simplecheckid' => $simplecheck->id, 'itemid' => $item->id, 'userid' => $userid]);
        if ($existing) {
            $existing->checked = $ischecked;
            $existing->timemodified = $now;
            $DB->update_record('simplecheck_check', $existing);
        } else {
            $DB->insert_record('simplecheck_check', (object) [
                'simplecheckid' => $simplecheck->id,
                'itemid'        => $item->id,
                'userid'        => $userid,
                'checked'       => $ischecked,
                'timemodified'  => $now,
            ]);
        }
    }
}

/**
 * Crée ou met à jour l'item de note de l'activité dans le carnet.
 *
 * @param stdClass $simplecheck l'instance (avec ->grade = note max)
 * @param mixed $grades notes à pousser, 'reset' pour supprimer, ou null
 * @return int GRADE_UPDATE_OK, etc.
 */
function simplecheck_grade_item_update(stdClass $simplecheck, $grades = null): int {
    global $CFG;
    require_once($CFG->libdir . '/gradelib.php');
 
    $params = [
        'itemname' => $simplecheck->name,
        'gradetype' => GRADE_TYPE_VALUE,
        'grademax'  => $simplecheck->grade,
        'grademin'  => 0,
    ];
    if ($grades === 'reset') {
        $params['deleted'] = true;
        $grades = null;
    }
 
    return grade_update('mod/simplecheck', $simplecheck->course, 'mod', 'simplecheck',
        $simplecheck->id, 0, $grades, $params);
}

/**
 * Calcule et pousse les notes (pour un utilisateur, ou tous).
 *
 * @param stdClass $simplecheck
 * @param int $userid 0 = tous les utilisateurs
 */
function simplecheck_update_grades(stdClass $simplecheck, int $userid = 0): void {
    global $DB;
 
    // Nombre d'items de cette activité.
    $itemcount = $DB->count_records('simplecheck_item', ['simplecheckid' => $simplecheck->id]);
    if ($itemcount == 0) {
        // Rien à noter : on pousse des notes nulles.
        simplecheck_grade_item_update($simplecheck);
        return;
    }
 
    // Utilisateurs concernés.
    $params = ['simplecheckid' => $simplecheck->id, 'checked' => 1];
    $usersql = '';
    if ($userid) {
        $usersql = ' AND userid = :userid';
        $params['userid'] = $userid;
    }
 
    // Nombre d'items cochés par utilisateur.
    $sql = "SELECT userid, COUNT(*) AS done
              FROM {simplecheck_check}
             WHERE simplecheckid = :simplecheckid AND checked = :checked $usersql
          GROUP BY userid";
    $rows = $DB->get_records_sql($sql, $params);
 
    $grades = [];
    foreach ($rows as $row) {
        $grades[$row->userid] = (object) [
            'userid'   => $row->userid,
            // note = proportion cochée × note max.
            'rawgrade' => ($row->done / $itemcount) * $simplecheck->grade,
        ];
    }
 
    if ($grades) {
        simplecheck_grade_item_update($simplecheck, $grades);
    }
}

<?php
// public/mod/simplecheck/classes/completion/custom_completion.php
namespace mod_simplecheck\completion;
 
use core_completion\activity_custom_completion;
 
defined('MOODLE_INTERNAL') || die();
 
class custom_completion extends activity_custom_completion {
 
    /**
     * Détermine l'état d'une règle pour l'utilisateur courant.
     *
     * @param string $rule le nom de la règle (ex. 'completionallchecked')
     * @return int COMPLETION_COMPLETE ou COMPLETION_INCOMPLETE
     */
    public function get_state(string $rule): int {
        global $DB;
 
        $this->validate_rule($rule); // garde-fou
 
        $simplecheckid = $this->cm->instance;
        $userid = $this->userid;
 
        $total = $DB->count_records('simplecheck_item', ['simplecheckid' => $simplecheckid]);
        if ($total == 0) {
            return COMPLETION_INCOMPLETE;
        }
        $done = $DB->count_records('simplecheck_check',
            ['simplecheckid' => $simplecheckid, 'userid' => $userid, 'checked' => 1]);
 
        return ($done >= $total) ? COMPLETION_COMPLETE : COMPLETION_INCOMPLETE;
    }
 
    /** Les règles définies par ce module. */
    public static function get_defined_custom_rules(): array {
        return ['completionallchecked'];
    }
 
    /** Descriptions lisibles (affichées dans les rapports d'achèvement). */
    public function get_custom_rule_descriptions(): array {
        return [
            'completionallchecked' => get_string('completionallchecked_desc', 'mod_simplecheck'),
        ];
    }
 
    /** Ordre d'affichage des règles (standard + custom). */
    public function get_sort_order(): array {
        return ['completionview', 'completionallchecked', 'completionusegrade'];
    }
}

<?php
// public/mod/simplecheck/backup/moodle2/backup_simplecheck_stepslib.php
defined('MOODLE_INTERNAL') || die();
 
class backup_simplecheck_activity_structure_step extends backup_activity_structure_step {
 
    protected function define_structure(): backup_nested_element {
        // Faut-il inclure les données utilisateur (les coches) ?
        $userinfo = $this->get_setting_value('userinfo');
 
        // Élément racine : l'instance.
        $simplecheck = new backup_nested_element('simplecheck', ['id'], [
            'name', 'intro', 'introformat', 'grade', 'timecreated', 'timemodified',
        ]);
 
        // Items (structure, sans données utilisateur).
        $items = new backup_nested_element('items');
        $item  = new backup_nested_element('item', ['id'], ['name', 'position']);
 
        // Coches (données utilisateur).
        $checks = new backup_nested_element('checks');
        $check  = new backup_nested_element('check', ['id'],
            ['itemid', 'userid', 'checked', 'timemodified']);
 
        // Arbre.
        $simplecheck->add_child($items);
        $items->add_child($item);
        $simplecheck->add_child($checks);
        $checks->add_child($check);
 
        // Sources (requêtes qui alimentent l'arbre).
        $simplecheck->set_source_table('simplecheck', ['id' => backup::VAR_ACTIVITYID]);
        $item->set_source_table('simplecheck_item', ['simplecheckid' => backup::VAR_PARENTID]);
 
        if ($userinfo) {
            $check->set_source_table('simplecheck_check', ['simplecheckid' => backup::VAR_PARENTID]);
        }
 
        // Les champs référençant des utilisateurs sont « annotés » (remapping à la restauration).
        $check->annotate_ids('user', 'userid');
 
        // Fichiers éventuels (intro).
        $simplecheck->annotate_files('mod_simplecheck', 'intro', null);
 
        return $this->prepare_activity_structure($simplecheck);
    }
}

<?php
// public/mod/simplecheck/backup/moodle2/restore_simplecheck_stepslib.php (extrait)
defined('MOODLE_INTERNAL') || die();
 
class restore_simplecheck_activity_structure_step extends restore_activity_structure_step {
 
    protected function define_structure(): array {
        $paths = [];
        $userinfo = $this->get_setting_value('userinfo');
 
        $paths[] = new restore_path_element('simplecheck', '/activity/simplecheck');
        $paths[] = new restore_path_element('item', '/activity/simplecheck/items/item');
        if ($userinfo) {
            $paths[] = new restore_path_element('check', '/activity/simplecheck/checks/check');
        }
        return $this->prepare_activity_structure($paths);
    }
 
    protected function process_simplecheck(array $data): void {
        global $DB;
        $data = (object) $data;
        $data->course = $this->get_courseid();
        $newid = $DB->insert_record('simplecheck', $data);
        $this->apply_activity_instance($newid); // relie le cm au nouvel id
    }
 
    protected function process_item(array $data): void {
        global $DB;
        $data = (object) $data;
        $data->simplecheckid = $this->get_new_parentid('simplecheck');
        $newid = $DB->insert_record('simplecheck_item', $data);
        $this->set_mapping('simplecheck_item', $data->id, $newid); // pour remapper itemid des checks
    }
 
    protected function process_check(array $data): void {
        global $DB;
        $data = (object) $data;
        $data->simplecheckid = $this->get_new_parentid('simplecheck');
        $data->itemid = $this->get_mappingid('simplecheck_item', $data->itemid); // remap !
        $data->userid = $this->get_mappingid('user', $data->userid);             // remap !
        $DB->insert_record('simplecheck_check', $data);
    }
}

/**
 * Efface les données utilisateur lors d'un reset de cours.
 */
function simplecheck_reset_userdata(stdClass $data): array {
    global $DB;
 
    $status = [];
    if (!empty($data->reset_simplecheck_checks)) {
        $sql = "DELETE FROM {simplecheck_check}
                 WHERE simplecheckid IN (SELECT id FROM {simplecheck} WHERE course = :course)";
        $DB->execute($sql, ['course' => $data->courseid]);
 
        // Remet les notes à zéro.
        $simplechecks = $DB->get_records('simplecheck', ['course' => $data->courseid]);
        foreach ($simplechecks as $sc) {
            simplecheck_grade_item_update($sc, 'reset');
        }
        $status[] = [
            'component' => get_string('modulenameplural', 'mod_simplecheck'),
            'item'      => get_string('resetchecks', 'mod_simplecheck'),
            'error'     => false,
        ];
    }
    return $status;
}
 
/**
 * Ajoute notre case à cocher au formulaire de reset.
 */
function simplecheck_reset_course_form_definition($mform): void {
    $mform->addElement('header', 'simplecheckheader', get_string('modulenameplural', 'mod_simplecheck'));
    $mform->addElement('checkbox', 'reset_simplecheck_checks', get_string('resetchecks', 'mod_simplecheck'));
}

<?php
// public/mod/simplecheck/index.php
require(__DIR__ . '/../../config.php');
 
$id = required_param('id', PARAM_INT); // course id
$course = $DB->get_record('course', ['id' => $id], '*', MUST_EXIST);
require_login($course);
 
$context = context_course::instance($course->id);
$PAGE->set_url(new moodle_url('/mod/simplecheck/index.php', ['id' => $id]));
$PAGE->set_context($context);
$PAGE->set_title(get_string('modulenameplural', 'mod_simplecheck'));
 
echo $OUTPUT->header();
echo $OUTPUT->heading(get_string('modulenameplural', 'mod_simplecheck'));
 
$instances = get_all_instances_in_course('simplecheck', $course);
if (!$instances) {
    notice(get_string('noinstances', 'mod_simplecheck'), new moodle_url('/course/view.php', ['id' => $id]));
}
 
$table = new html_table();
$table->head = [get_string('name'), get_string('items', 'mod_simplecheck')];
foreach ($instances as $instance) {
    $link = new moodle_url('/mod/simplecheck/view.php', ['id' => $instance->coursemodule]);
    $count = $DB->count_records('simplecheck_item', ['simplecheckid' => $instance->id]);
    $table->data[] = [html_writer::link($link, format_string($instance->name)), $count];
}
echo html_writer::table($table);
echo $OUTPUT->footer();

/**
 * Infos affichées sur la page de cours pour cette activité.
 */
function simplecheck_get_coursemodule_info(stdClass $cm): cached_cm_info {
    global $DB;
    $info = new cached_cm_info();
    if ($simplecheck = $DB->get_record('simplecheck', ['id' => $cm->instance], 'id, name, intro, introformat')) {
        $info->name = $simplecheck->name;
        if ($cm->showdescription) {
            $info->content = format_module_intro('simplecheck', $simplecheck, $cm->id, false);
        }
    }
    return $info;
}