Proyectos de Subversion Moodle

<?php
// This file is part of Moodle - https://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 <https://www.gnu.org/licenses/>.

/**
 * Privacy class for requesting user data.
 *
 * @package     mod_stickynotes
 * @copyright   2021 Olivier VALENTIN
 * @license     https://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

namespace mod_stickynotes\privacy;

defined('MOODLE_INTERNAL') || die();

use core_privacy\local\metadata\collection;
use core_privacy\local\request\approved_contextlist;
use core_privacy\local\request\approved_userlist;
use core_privacy\local\request\contextlist;
use core_privacy\local\request\helper;
use core_privacy\local\request\userlist;
use core_privacy\local\request\writer;
use \core_privacy\local\request\transform;

defined('MOODLE_INTERNAL') || die();

/**
 * Implementation of the privacy subsystem plugin provider for the Stickynotes activity module.
 */
class provider implements
    // This plugin stores personal data.
    \core_privacy\local\metadata\provider,

    // This plugin is a core_user_data_provider.
    \core_privacy\local\request\plugin\provider,

    // This plugin is capable of determining which users have data within it.
    \core_privacy\local\request\core_userlist_provider
{

    /**
     * Return the fields which contain personal data.
     *
     * @param collection $items a reference to the collection to use to store the metadata.
     * @return collection the updated collection of metadata items.
     */
    public static function get_metadata(collection $items): collection {
        // 1. The 'stickynotes_note' table stores information about notes created by user.
        $items->add_database_table(
            'stickynotes_note',
            [
                'id' => 'privacy:metadata:stickynotes_note:id',
                'stickyid' => 'privacy:metadata:stickynotes_note:stickyid',
                'stickycolid' => 'privacy:metadata:stickynotes_note:stickycolid',
                'userid' => 'privacy:metadata:stickynotes_note:userid',
                'message' => 'privacy:metadata:stickynotes_note:message',
                'timecreated' => 'privacy:metadata:stickynotes_note:timecreated',
                'timemodified' => 'privacy:metadata:stickynotes_note:timemodified',
            ],
            'privacy:metadata:stickynotes_note'
        );
        // 2. The 'stickynotes_vote' table stores information about which notes a user has rated.
        $items->add_database_table(
            'stickynotes_vote',
            [
                'id' => 'privacy:metadata:stickynotes_vote:id',
                'stickyid' => 'privacy:metadata:stickynotes_vote:stickyid',
                'stickynoteid' => 'privacy:metadata:stickynotes_vote:stickynoteid',
                'userid' => 'privacy:metadata:stickynotes_vote:userid',
                'vote' => 'privacy:metadata:stickynotes_vote:vote',
                'timecreated' => 'privacy:metadata:stickynotes_vote:timecreated',
            ],
            'privacy:metadata:stickynotes_vote'
        );

        return $items;
    }

/**
     * Get the list of contexts that contain user information for the specified user.
     *
     * In the case of forum, that is any forum where the user has made any post, rated any content, or has any preferences.
     *
     * @param   int         $userid     The user to search.
     * @return  contextlist $contextlist  The list of contexts used in this plugin.
     */
    public static function get_contexts_for_userid(int $userid) : \core_privacy\local\request\contextlist {
        $contextlist = new \core_privacy\local\request\contextlist();

        $params = [
            'modname'       => 'stickynotes',
            'contextlevel'  => CONTEXT_MODULE,
            'userid'        => $userid,
        ];

        // Stickynotes notes.
        $sql = "SELECT c.id
            FROM {context} c
            JOIN {course_modules} cm ON cm.id = c.instanceid AND c.contextlevel = :contextlevel
            JOIN {modules} m ON m.id = cm.module AND m.name = :modname
            JOIN {stickynotes} s ON s.id = cm.instance
            JOIN {stickynotes_column} sc ON sc.stickyid = s.id
            JOIN {stickynotes_note} sn ON sn.stickycolid = sc.id
            WHERE sn.userid = :userid
        ";
        $contextlist->add_from_sql($sql, $params);

        // Stickynotes votes.
        $sql = "SELECT c.id
            FROM {context} c
            JOIN {course_modules} cm ON cm.id = c.instanceid AND c.contextlevel = :contextlevel
            JOIN {modules} m ON m.id = cm.module AND m.name = :modname
            JOIN {stickynotes} s ON s.id = cm.instance
            JOIN {stickynotes_column} sc ON sc.stickyid = s.id
            JOIN {stickynotes_note} sn ON sn.stickycolid = sc.id
            JOIN {stickynotes_vote} sv ON sv.stickynoteid = sn.id
            WHERE sv.userid = :userid
        ";
        $contextlist->add_from_sql($sql, $params);

        return $contextlist;
    }

    /**
     * Get the list of users who have data within a context.
     *
     * @param userlist $userlist The userlist containing the list of users who have data in this context/plugin combination.
     */
    public static function get_users_in_context(userlist $userlist) {
        $context = $userlist->get_context();

        if (!is_a($context, \context_module::class)) {
            return;
        }

        $params = [
            'instanceid'    => $context->instanceid,
            'modulename'    => 'stickynotes',
        ];

        // Notes authors.
        $sql = "SELECT sn.userid
            FROM {course_modules} cm
            JOIN {modules} m ON m.id = cm.module AND m.name = :modname
            JOIN {stickynotes} s ON s.id = cm.instance
            JOIN {stickynotes_column} sc ON sc.stickyid = s.id
            JOIN {stickynotes_note} sn ON sn.stickycolid = sc.id
            WHERE cm.id = :instanceid";
        $userlist->add_from_sql('userid', $sql, $params);

        // Votes.
        $sql = "SELECT sv.userid
            FROM {course_modules} cm
            JOIN {modules} m ON m.id = cm.module AND m.name = :modname
            JOIN {stickynotes} s ON s.id = cm.instance
            JOIN {stickynotes_column} sc ON sc.stickyid = s.id
            JOIN {stickynotes_note} sn ON sn.stickycolid = sc.id
            JOIN {stickynotes_vote} sv ON sv.stickynoteid = sn.id
            WHERE cm.id = :instanceid";
      $userlist->add_from_sql('userid', $sql, $params);
    }

/**
     * Export all user data for the specified user, in the specified contexts, using the supplied exporter instance.
     *
     * @param   approved_contextlist    $contextlist    The approved contexts to export information for.
     */
    public static function export_user_data(approved_contextlist $contextlist) {
        global $DB, $CFG;

        $userid = $contextlist->get_user()->id;

        if (empty($contextlist)) {
            return;
        }
        list($contextsql, $contextparams) = $DB->get_in_or_equal($contextlist->get_contextids(), SQL_PARAMS_NAMED);
        $sql = "SELECT
                    c.id AS contextid,
                    s.id,
                    cm.id AS cmid
                  FROM {context} c
                  JOIN {course_modules} cm ON cm.id = c.instanceid
                  JOIN {stickynotes} s ON s.id = cm.instance
                 WHERE (
                    c.id {$contextsql}
                )
        ";
        // Keep a mapping of stickyid to contextid.
        $mappings = [];

        $params = ['modname' => 'stickynotes', 'contextlevel' => CONTEXT_MODULE, 'userid' => $user->id] + $contextparams;
        $stickynotesactivities = $DB->get_recordset_sql($sql, $params);

        foreach ($stickynotesactivities as $stickynotes) {
            $mappings[$stickynotes->id] = $stickynotes->contextid;

            $context = \context::instance_by_id($mappings[$stickynotes->id]);
            $subcontext = [
                get_string('pluginname', 'mod_stickynotes'),
                format_string($stickynotes->name),
                $stickynotes->id
            ];

            // Get all notes created by the user.
            $sql1notes = "SELECT id, message, timecreated, timemodified
            from {stickynotes_note}
            where userid = :userid
            and stickyid = :stickynotesid";

            $query1notes = $DB->get_records_sql($sql1notes, array('userid' => $userid, 'stickynotesid' => $stickynotes->id));
            foreach ($query1notes as $query1note) {
                $key = $query1note->id;
                $notedata[$key] = (object) [
                    'id' => $query1note->id,
                    'message' => format_string($query1note->message, true),
                    'timecreated' => transform::datetime($query1note->timecreated),
                    'timemodified' => transform::datetime($query1note->timemodified),
                ];
            }

            // Get all votes of this user.
            $sql2notes = "SELECT sv.id as idvote, sv.vote, sv.timecreated, sn.id as idnote
            from {stickynotes_note} sn
            join {stickynotes_vote} sv on sv.stickynoteid = sn.id
            where sv.userid = :userid
            and sv.stickyid = :stickynotesid";

            $query2notes = $DB->get_records_sql($sql2notes, array('userid' => $userid, 'stickynotesid' => $stickynotes->id));
            foreach ($query2notes as $query2note) {
                $key = $query2note->idnote;
                $votedata[$key] = (object) [
                    'idnote' => $query2note->idnote,
                    'vote' => $query2note->vote,
                    'timecreated' => transform::datetime($query2note->timecreated),
                ];
            }

            $stickynotes->notes = $notedata;
            $stickynotes->votes = $votedata;
            unset($notedata);
            unset($votedata);

            writer::with_context($context)->export_data([], $stickynotes);
        }
        $stickynotesactivities->close();
    }

    /**
     * Delete all data for all users in the specified context.
     *
     * @param \context $context the context to delete in.
     */
    public static function delete_data_for_all_users_in_context(\context $context) {
        global $DB;

        if (!$context instanceof \context_module) {
            return;
        }

        if ($cm = get_coursemodule_from_id('stickynotes', $context->instanceid)) {
            $DB->delete_records('stickynotes_note', ['stickyid' => $cm->instance]);
            $DB->delete_records('stickynotes_vote', ['stickyid' => $cm->instance]);
        }
    }

    /**
     * Delete all user data for the specified user, in the specified contexts.
     *
     * @param approved_contextlist $contextlist a list of contexts approved for deletion.
     */
    public static function delete_data_for_user(approved_contextlist $contextlist) {
        global $DB;

        if (empty($contextlist->count())) {
            return;
        }

        $userid = $contextlist->get_user()->id;
        foreach ($contextlist->get_contexts() as $context) {

            if (!$context instanceof \context_module) {
                continue;
            }
            $instanceid = $DB->get_field('course_modules', 'instance', ['id' => $context->instanceid]);
            if (!$instanceid) {
                continue;
            }
            $DB->delete_records('stickynotes_note', ['stickyid' => $instanceid, 'userid' => $userid]);
            $DB->delete_records('stickynotes_vote', ['stickyid' => $instanceid, 'userid' => $userid]);
        }
    }

    /**
     * Delete multiple users within a single context.
     *
     * @param approved_userlist $userlist The approved context and user information to delete information for.
     */
    public static function delete_data_for_users(approved_userlist $userlist) {
        global $DB;

        $context = $userlist->get_context();

        if (!$context instanceof \context_module) {
            return;
        }

        $cm = get_coursemodule_from_id('stickynotes', $context->instanceid);

        if (!$cm) {
            // Only stickynotes module will be handled.
            return;
        }

        $userids = $userlist->get_userids();
        list($usersql, $userparams) = $DB->get_in_or_equal($userids, SQL_PARAMS_NAMED);

        $select = "stickyid = :stickyid AND userid $usersql";
        $params = ['stickyid' => $cm->instance] + $userparams;
        $DB->delete_records_select('stickynotes_note', $select, $params);
        $DB->delete_records_select('stickynotes_note', $select, $params);
    }
}