[Summary view]

Differences Between: [Versions 39 and 400] [Versions 39 and 401] [Versions 39 and 402] [Versions 39 and 403]

   1  <?php
   2  // This file is part of Moodle - http://moodle.org/
   3  //
   4  // Moodle is free software: you can redistribute it and/or modify
   5  // it under the terms of the GNU General Public License as published by
   6  // the Free Software Foundation, either version 3 of the License, or
   7  // (at your option) any later version.
   8  //
   9  // Moodle is distributed in the hope that it will be useful,
  10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  // GNU General Public License for more details.
  13  //
  14  // You should have received a copy of the GNU General Public License
  15  // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16  
  17  /**
  18   * Privacy class for requesting user data.
  19   *
  20   * @package    mod_assign
  21   * @copyright  2018 Adrian Greeve <adrian@moodle.com>
  22   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23   */
  24  
  25  namespace mod_assign\privacy;
  26  
  27  defined('MOODLE_INTERNAL') || die();
  28  
  29  require_once($CFG->dirroot . '/mod/assign/locallib.php');
  30  
  31  use \core_privacy\local\metadata\collection;
  32  use \core_privacy\local\request\contextlist;
  33  use \core_privacy\local\request\writer;
  34  use \core_privacy\local\request\approved_contextlist;
  35  use \core_privacy\local\request\transform;
  36  use \core_privacy\local\request\helper;
  37  use \core_privacy\local\request\userlist;
  38  use \core_privacy\local\request\approved_userlist;
  39  use \core_privacy\manager;
  40  
  41  /**
  42   * Privacy class for requesting user data.
  43   *
  44   * @package    mod_assign
  45   * @copyright  2018 Adrian Greeve <adrian@moodle.com>
  46   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  47   */
  48  class provider implements
  49          \core_privacy\local\metadata\provider,
  50          \core_privacy\local\request\plugin\provider,
  51          \core_privacy\local\request\user_preference_provider,
  52          \core_privacy\local\request\core_userlist_provider {
  53  
  54      /** Interface for all assign submission sub-plugins. */
  55      const ASSIGNSUBMISSION_INTERFACE = 'mod_assign\privacy\assignsubmission_provider';
  56  
  57      /** Interface for all assign submission sub-plugins. This allows for deletion of users with a context. */
  58      const ASSIGNSUBMISSION_USER_INTERFACE = 'mod_assign\privacy\assignsubmission_user_provider';
  59  
  60      /** Interface for all assign feedback sub-plugins. This allows for deletion of users with a context. */
  61      const ASSIGNFEEDBACK_USER_INTERFACE = 'mod_assign\privacy\assignfeedback_user_provider';
  62  
  63      /** Interface for all assign feedback sub-plugins. */
  64      const ASSIGNFEEDBACK_INTERFACE = 'mod_assign\privacy\assignfeedback_provider';
  65  
  66      /**
  67       * Provides meta data that is stored about a user with mod_assign
  68       *
  69       * @param  collection $collection A collection of meta data items to be added to.
  70       * @return  collection Returns the collection of metadata.
  71       */
  72      public static function get_metadata(collection $collection) : collection {
  73          $assigngrades = [
  74                  'userid' => 'privacy:metadata:userid',
  75                  'timecreated' => 'privacy:metadata:timecreated',
  76                  'timemodified' => 'timemodified',
  77                  'grader' => 'privacy:metadata:grader',
  78                  'grade' => 'privacy:metadata:grade',
  79                  'attemptnumber' => 'attemptnumber'
  80          ];
  81          $assignoverrides = [
  82                  'groupid' => 'privacy:metadata:groupid',
  83                  'userid' => 'privacy:metadata:userid',
  84                  'allowsubmissionsfromdate' => 'allowsubmissionsfromdate',
  85                  'duedate' => 'duedate',
  86                  'cutoffdate' => 'cutoffdate'
  87          ];
  88          $assignsubmission = [
  89                  'userid' => 'privacy:metadata:userid',
  90                  'timecreated' => 'privacy:metadata:timecreated',
  91                  'timemodified' => 'timemodified',
  92                  'status' => 'gradingstatus',
  93                  'groupid' => 'privacy:metadata:groupid',
  94                  'attemptnumber' => 'attemptnumber',
  95                  'latest' => 'privacy:metadata:latest'
  96          ];
  97          $assignuserflags = [
  98                  'userid' => 'privacy:metadata:userid',
  99                  'assignment' => 'privacy:metadata:assignmentid',
 100                  'locked' => 'locksubmissions',
 101                  'mailed' => 'privacy:metadata:mailed',
 102                  'extensionduedate' => 'extensionduedate',
 103                  'workflowstate' => 'markingworkflowstate',
 104                  'allocatedmarker' => 'allocatedmarker'
 105          ];
 106          $assignusermapping = [
 107                  'assignment' => 'privacy:metadata:assignmentid',
 108                  'userid' => 'privacy:metadata:userid'
 109          ];
 110          $collection->add_database_table('assign_grades', $assigngrades, 'privacy:metadata:assigngrades');
 111          $collection->add_database_table('assign_overrides', $assignoverrides, 'privacy:metadata:assignoverrides');
 112          $collection->add_database_table('assign_submission', $assignsubmission, 'privacy:metadata:assignsubmissiondetail');
 113          $collection->add_database_table('assign_user_flags', $assignuserflags, 'privacy:metadata:assignuserflags');
 114          $collection->add_database_table('assign_user_mapping', $assignusermapping, 'privacy:metadata:assignusermapping');
 115          $collection->add_user_preference('assign_perpage', 'privacy:metadata:assignperpage');
 116          $collection->add_user_preference('assign_filter', 'privacy:metadata:assignfilter');
 117          $collection->add_user_preference('assign_markerfilter', 'privacy:metadata:assignmarkerfilter');
 118          $collection->add_user_preference('assign_workflowfilter', 'privacy:metadata:assignworkflowfilter');
 119          $collection->add_user_preference('assign_quickgrading', 'privacy:metadata:assignquickgrading');
 120          $collection->add_user_preference('assign_downloadasfolders', 'privacy:metadata:assigndownloadasfolders');
 121  
 122          // Link to subplugins.
 123          $collection->add_plugintype_link('assignsubmission', [],'privacy:metadata:assignsubmissionpluginsummary');
 124          $collection->add_plugintype_link('assignfeedback', [], 'privacy:metadata:assignfeedbackpluginsummary');
 125          $collection->add_subsystem_link('core_message', [], 'privacy:metadata:assignmessageexplanation');
 126  
 127          return $collection;
 128      }
 129  
 130      /**
 131       * Returns all of the contexts that has information relating to the userid.
 132       *
 133       * @param  int $userid The user ID.
 134       * @return contextlist an object with the contexts related to a userid.
 135       */
 136      public static function get_contexts_for_userid(int $userid) : contextlist {
 137          $params = ['modulename' => 'assign',
 138                     'contextlevel' => CONTEXT_MODULE,
 139                     'userid' => $userid,
 140                     'graderid' => $userid,
 141                     'aouserid' => $userid,
 142                     'asnuserid' => $userid,
 143                     'aufuserid' => $userid,
 144                     'aumuserid' => $userid];
 145  
 146          $sql = "SELECT ctx.id
 147                    FROM {course_modules} cm
 148                    JOIN {modules} m ON cm.module = m.id AND m.name = :modulename
 149                    JOIN {assign} a ON cm.instance = a.id
 150                    JOIN {context} ctx ON cm.id = ctx.instanceid AND ctx.contextlevel = :contextlevel
 151                    JOIN {assign_grades} ag ON a.id = ag.assignment AND (ag.userid = :userid OR ag.grader = :graderid)";
 152  
 153          $contextlist = new contextlist();
 154          $contextlist->add_from_sql($sql, $params);
 155  
 156          $sql = "SELECT ctx.id
 157                    FROM {course_modules} cm
 158                    JOIN {modules} m ON cm.module = m.id AND m.name = :modulename
 159                    JOIN {assign} a ON cm.instance = a.id
 160                    JOIN {context} ctx ON cm.id = ctx.instanceid AND ctx.contextlevel = :contextlevel
 161                    JOIN {assign_overrides} ao ON a.id = ao.assignid
 162                   WHERE ao.userid = :aouserid";
 163  
 164          $contextlist->add_from_sql($sql, $params);
 165  
 166          $sql = "SELECT ctx.id
 167                    FROM {course_modules} cm
 168                    JOIN {modules} m ON cm.module = m.id AND m.name = :modulename
 169                    JOIN {assign} a ON cm.instance = a.id
 170                    JOIN {context} ctx ON cm.id = ctx.instanceid AND ctx.contextlevel = :contextlevel
 171                    JOIN {assign_submission} asn ON a.id = asn.assignment
 172                   WHERE asn.userid = :asnuserid";
 173  
 174          $contextlist->add_from_sql($sql, $params);
 175  
 176          $sql = "SELECT ctx.id
 177                    FROM {course_modules} cm
 178                    JOIN {modules} m ON cm.module = m.id AND m.name = :modulename
 179                    JOIN {assign} a ON cm.instance = a.id
 180                    JOIN {context} ctx ON cm.id = ctx.instanceid AND ctx.contextlevel = :contextlevel
 181                    JOIN {assign_user_flags} auf ON a.id = auf.assignment
 182                   WHERE auf.userid = :aufuserid";
 183  
 184          $contextlist->add_from_sql($sql, $params);
 185  
 186          $sql = "SELECT ctx.id
 187                    FROM {course_modules} cm
 188                    JOIN {modules} m ON cm.module = m.id AND m.name = :modulename
 189                    JOIN {assign} a ON cm.instance = a.id
 190                    JOIN {context} ctx ON cm.id = ctx.instanceid AND ctx.contextlevel = :contextlevel
 191                    JOIN {assign_user_mapping} aum ON a.id = aum.assignment
 192                   WHERE aum.userid = :aumuserid";
 193  
 194          $contextlist->add_from_sql($sql, $params);
 195  
 196          manager::plugintype_class_callback('assignfeedback', self::ASSIGNFEEDBACK_INTERFACE,
 197                  'get_context_for_userid_within_feedback', [$userid, $contextlist]);
 198          manager::plugintype_class_callback('assignsubmission', self::ASSIGNSUBMISSION_INTERFACE,
 199                  'get_context_for_userid_within_submission', [$userid, $contextlist]);
 200  
 201          return $contextlist;
 202      }
 203  
 204      /**
 205       * Get the list of users who have data within a context.
 206       *
 207       * @param   userlist    $userlist   The userlist containing the list of users who have data in this context/plugin combination.
 208       */
 209      public static function get_users_in_context(userlist $userlist) {
 210  
 211          $context = $userlist->get_context();
 212          if ($context->contextlevel != CONTEXT_MODULE) {
 213              return;
 214          }
 215  
 216          $params = [
 217              'modulename' => 'assign',
 218              'contextid' => $context->id,
 219              'contextlevel' => CONTEXT_MODULE
 220          ];
 221  
 222          $sql = "SELECT g.userid, g.grader
 223                    FROM {context} ctx
 224                    JOIN {course_modules} cm ON cm.id = ctx.instanceid
 225                    JOIN {modules} m ON m.id = cm.module AND m.name = :modulename
 226                    JOIN {assign} a ON a.id = cm.instance
 227                    JOIN {assign_grades} g ON a.id = g.assignment
 228                   WHERE ctx.id = :contextid AND ctx.contextlevel = :contextlevel";
 229          $userlist->add_from_sql('userid', $sql, $params);
 230          $userlist->add_from_sql('grader', $sql, $params);
 231  
 232          $sql = "SELECT o.userid
 233                    FROM {context} ctx
 234                    JOIN {course_modules} cm ON cm.id = ctx.instanceid
 235                    JOIN {modules} m ON m.id = cm.module AND m.name = :modulename
 236                    JOIN {assign} a ON a.id = cm.instance
 237                    JOIN {assign_overrides} o ON a.id = o.assignid
 238                   WHERE ctx.id = :contextid AND ctx.contextlevel = :contextlevel";
 239          $userlist->add_from_sql('userid', $sql, $params);
 240  
 241          $sql = "SELECT s.userid
 242                    FROM {context} ctx
 243                    JOIN {course_modules} cm ON cm.id = ctx.instanceid
 244                    JOIN {modules} m ON m.id = cm.module AND m.name = :modulename
 245                    JOIN {assign} a ON a.id = cm.instance
 246                    JOIN {assign_submission} s ON a.id = s.assignment
 247                   WHERE ctx.id = :contextid AND ctx.contextlevel = :contextlevel";
 248          $userlist->add_from_sql('userid', $sql, $params);
 249  
 250          $sql = "SELECT uf.userid
 251                    FROM {context} ctx
 252                    JOIN {course_modules} cm ON cm.id = ctx.instanceid
 253                    JOIN {modules} m ON m.id = cm.module AND m.name = :modulename
 254                    JOIN {assign} a ON a.id = cm.instance
 255                    JOIN {assign_user_flags} uf ON a.id = uf.assignment
 256                   WHERE ctx.id = :contextid AND ctx.contextlevel = :contextlevel";
 257          $userlist->add_from_sql('userid', $sql, $params);
 258  
 259          $sql = "SELECT um.userid
 260                    FROM {context} ctx
 261                    JOIN {course_modules} cm ON cm.id = ctx.instanceid
 262                    JOIN {modules} m ON m.id = cm.module AND m.name = :modulename
 263                    JOIN {assign} a ON a.id = cm.instance
 264                    JOIN {assign_user_mapping} um ON a.id = um.assignment
 265                   WHERE ctx.id = :contextid AND ctx.contextlevel = :contextlevel";
 266          $userlist->add_from_sql('userid', $sql, $params);
 267  
 268          manager::plugintype_class_callback('assignsubmission', self::ASSIGNSUBMISSION_USER_INTERFACE,
 269                  'get_userids_from_context', [$userlist]);
 270          manager::plugintype_class_callback('assignfeedback', self::ASSIGNFEEDBACK_USER_INTERFACE,
 271                  'get_userids_from_context', [$userlist]);
 272      }
 273  
 274      /**
 275       * Write out the user data filtered by contexts.
 276       *
 277       * @param approved_contextlist $contextlist contexts that we are writing data out from.
 278       */
 279      public static function export_user_data(approved_contextlist $contextlist) {
 280          foreach ($contextlist->get_contexts() as $context) {
 281              // Check that the context is a module context.
 282              if ($context->contextlevel != CONTEXT_MODULE) {
 283                  continue;
 284              }
 285              $user = $contextlist->get_user();
 286              $assigndata = helper::get_context_data($context, $user);
 287              helper::export_context_files($context, $user);
 288  
 289              writer::with_context($context)->export_data([], $assigndata);
 290              $assign = new \assign($context, null, null);
 291  
 292              // I need to find out if I'm a student or a teacher.
 293              if ($userids = self::get_graded_users($user->id, $assign)) {
 294                  // Return teacher info.
 295                  $currentpath = [get_string('privacy:studentpath', 'mod_assign')];
 296                  foreach ($userids as $studentuserid) {
 297                      $studentpath = array_merge($currentpath, [$studentuserid->id]);
 298                      static::export_submission($assign, $studentuserid, $context, $studentpath, true);
 299                  }
 300              }
 301  
 302              static::export_overrides($context, $assign, $user);
 303              static::export_submission($assign, $user, $context, []);
 304              // Meta data.
 305              self::store_assign_user_flags($context, $assign, $user->id);
 306              if ($assign->is_blind_marking()) {
 307                  $uniqueid = $assign->get_uniqueid_for_user_static($assign->get_instance()->id, $contextlist->get_user()->id);
 308                  if ($uniqueid) {
 309                      writer::with_context($context)
 310                              ->export_metadata([get_string('blindmarking', 'mod_assign')], 'blindmarkingid', $uniqueid,
 311                                      get_string('privacy:blindmarkingidentifier', 'mod_assign'));
 312                  }
 313              }
 314          }
 315      }
 316  
 317      /**
 318       * Delete all use data which matches the specified context.
 319       *
 320       * @param \context $context The module context.
 321       */
 322      public static function delete_data_for_all_users_in_context(\context $context) {
 323          global $DB;
 324  
 325          if ($context->contextlevel == CONTEXT_MODULE) {
 326              $cm = get_coursemodule_from_id('assign', $context->instanceid);
 327              if ($cm) {
 328                  // Get the assignment related to this context.
 329                  $assign = new \assign($context, null, null);
 330                  // What to do first... Get sub plugins to delete their stuff.
 331                  $requestdata = new assign_plugin_request_data($context, $assign);
 332                  manager::plugintype_class_callback('assignsubmission', self::ASSIGNSUBMISSION_INTERFACE,
 333                      'delete_submission_for_context', [$requestdata]);
 334                  $requestdata = new assign_plugin_request_data($context, $assign);
 335                  manager::plugintype_class_callback('assignfeedback', self::ASSIGNFEEDBACK_INTERFACE,
 336                      'delete_feedback_for_context', [$requestdata]);
 337                  $DB->delete_records('assign_grades', ['assignment' => $assign->get_instance()->id]);
 338  
 339                  // Delete advanced grading information.
 340                  $gradingmanager = get_grading_manager($context, 'mod_assign', 'submissions');
 341                  $controller = $gradingmanager->get_active_controller();
 342                  if (isset($controller)) {
 343                      \core_grading\privacy\provider::delete_instance_data($context);
 344                  }
 345  
 346                  // Time to roll my own method for deleting overrides.
 347                  static::delete_overrides_for_users($assign);
 348                  $DB->delete_records('assign_submission', ['assignment' => $assign->get_instance()->id]);
 349                  $DB->delete_records('assign_user_flags', ['assignment' => $assign->get_instance()->id]);
 350                  $DB->delete_records('assign_user_mapping', ['assignment' => $assign->get_instance()->id]);
 351              }
 352          }
 353      }
 354  
 355      /**
 356       * Delete all user data for the specified user, in the specified contexts.
 357       *
 358       * @param approved_contextlist $contextlist The approved contexts and user information to delete information for.
 359       */
 360      public static function delete_data_for_user(approved_contextlist $contextlist) {
 361          global $DB;
 362  
 363          $user = $contextlist->get_user();
 364  
 365          foreach ($contextlist as $context) {
 366              if ($context->contextlevel != CONTEXT_MODULE) {
 367                  continue;
 368              }
 369              // Get the assign object.
 370              $assign = new \assign($context, null, null);
 371              $assignid = $assign->get_instance()->id;
 372  
 373              $submissions = $DB->get_records('assign_submission', ['assignment' => $assignid, 'userid' => $user->id]);
 374              foreach ($submissions as $submission) {
 375                  $requestdata = new assign_plugin_request_data($context, $assign, $submission, [], $user);
 376                  manager::plugintype_class_callback('assignsubmission', self::ASSIGNSUBMISSION_INTERFACE,
 377                          'delete_submission_for_userid', [$requestdata]);
 378              }
 379  
 380              $grades = $DB->get_records('assign_grades', ['assignment' => $assignid, 'userid' => $user->id]);
 381              $gradingmanager = get_grading_manager($context, 'mod_assign', 'submissions');
 382              $controller = $gradingmanager->get_active_controller();
 383              foreach ($grades as $grade) {
 384                  $requestdata = new assign_plugin_request_data($context, $assign, $grade, [], $user);
 385                  manager::plugintype_class_callback('assignfeedback', self::ASSIGNFEEDBACK_INTERFACE,
 386                          'delete_feedback_for_grade', [$requestdata]);
 387                  // Delete advanced grading information.
 388                  if (isset($controller)) {
 389                      \core_grading\privacy\provider::delete_instance_data($context, $grade->id);
 390                  }
 391              }
 392  
 393              static::delete_overrides_for_users($assign, [$user->id]);
 394              $DB->delete_records('assign_user_flags', ['assignment' => $assignid, 'userid' => $user->id]);
 395              $DB->delete_records('assign_user_mapping', ['assignment' => $assignid, 'userid' => $user->id]);
 396              $DB->delete_records('assign_grades', ['assignment' => $assignid, 'userid' => $user->id]);
 397              $DB->delete_records('assign_submission', ['assignment' => $assignid, 'userid' => $user->id]);
 398          }
 399      }
 400  
 401      /**
 402       * Delete multiple users within a single context.
 403       *
 404       * @param  approved_userlist $userlist The approved context and user information to delete information for.
 405       */
 406      public static function delete_data_for_users(approved_userlist $userlist) {
 407          global $DB;
 408  
 409          $context = $userlist->get_context();
 410          if ($context->contextlevel != CONTEXT_MODULE) {
 411              return;
 412          }
 413  
 414          $userids = $userlist->get_userids();
 415  
 416          $assign = new \assign($context, null, null);
 417          $assignid = $assign->get_instance()->id;
 418          $requestdata = new assign_plugin_request_data($context, $assign);
 419          $requestdata->set_userids($userids);
 420          $requestdata->populate_submissions_and_grades();
 421          manager::plugintype_class_callback('assignsubmission', self::ASSIGNSUBMISSION_USER_INTERFACE, 'delete_submissions',
 422                  [$requestdata]);
 423          manager::plugintype_class_callback('assignfeedback', self::ASSIGNFEEDBACK_USER_INTERFACE, 'delete_feedback_for_grades',
 424                  [$requestdata]);
 425  
 426          // Update this function to delete advanced grading information.
 427          $gradingmanager = get_grading_manager($context, 'mod_assign', 'submissions');
 428          $controller = $gradingmanager->get_active_controller();
 429          if (isset($controller)) {
 430              $gradeids = $requestdata->get_gradeids();
 431              // Careful here, if no gradeids are provided then all data is deleted for the context.
 432              if (!empty($gradeids)) {
 433                  \core_grading\privacy\provider::delete_data_for_instances($context, $gradeids);
 434              }
 435          }
 436  
 437          static::delete_overrides_for_users($assign, $userids);
 438          list($sql, $params) = $DB->get_in_or_equal($userids, SQL_PARAMS_NAMED);
 439          $params['assignment'] = $assignid;
 440          $DB->delete_records_select('assign_user_flags', "assignment = :assignment AND userid $sql", $params);
 441          $DB->delete_records_select('assign_user_mapping', "assignment = :assignment AND userid $sql", $params);
 442          $DB->delete_records_select('assign_grades', "assignment = :assignment AND userid $sql", $params);
 443          $DB->delete_records_select('assign_submission', "assignment = :assignment AND userid $sql", $params);
 444      }
 445  
 446      /**
 447       * Deletes assignment overrides in bulk
 448       *
 449       * @param  \assign $assign  The assignment object
 450       * @param  array   $userids An array of user IDs
 451       */
 452      protected static function delete_overrides_for_users(\assign $assign, array $userids = []) {
 453          global $DB;
 454          $assignid = $assign->get_instance()->id;
 455  
 456          $usersql = '';
 457          $params = ['assignid' => $assignid];
 458          if (!empty($userids)) {
 459              list($usersql, $userparams) = $DB->get_in_or_equal($userids, SQL_PARAMS_NAMED);
 460              $params = array_merge($params, $userparams);
 461              $overrides = $DB->get_records_select('assign_overrides', "assignid = :assignid AND userid $usersql", $params);
 462          } else {
 463              $overrides = $DB->get_records('assign_overrides', $params);
 464          }
 465          if (!empty($overrides)) {
 466              $params = ['modulename' => 'assign', 'instance' => $assignid];
 467              if (!empty($userids)) {
 468                  $params = array_merge($params, $userparams);
 469                  $DB->delete_records_select('event', "modulename = :modulename AND instance = :instance AND userid $usersql",
 470                          $params);
 471                  // Setting up for the next query.
 472                  $params = $userparams;
 473                  $usersql = "AND userid $usersql";
 474              } else {
 475                  $DB->delete_records('event', $params);
 476                  // Setting up for the next query.
 477                  $params = [];
 478              }
 479              list($overridesql, $overrideparams) = $DB->get_in_or_equal(array_keys($overrides), SQL_PARAMS_NAMED);
 480              $params = array_merge($params, $overrideparams);
 481              $DB->delete_records_select('assign_overrides', "id $overridesql $usersql", $params);
 482          }
 483      }
 484  
 485      /**
 486       * Find out if this user has graded any users.
 487       *
 488       * @param  int $userid The user ID (potential teacher).
 489       * @param  assign $assign The assignment object.
 490       * @return array If successful an array of objects with userids that this user graded, otherwise false.
 491       */
 492      protected static function get_graded_users(int $userid, \assign $assign) {
 493          $params = ['grader' => $userid, 'assignid' => $assign->get_instance()->id];
 494  
 495          $sql = "SELECT DISTINCT userid AS id
 496                    FROM {assign_grades}
 497                   WHERE grader = :grader AND assignment = :assignid";
 498  
 499          $useridlist = new useridlist($userid, $assign->get_instance()->id);
 500          $useridlist->add_from_sql($sql, $params);
 501  
 502          // Call sub-plugins to see if they have information not already collected.
 503          manager::plugintype_class_callback('assignsubmission', self::ASSIGNSUBMISSION_INTERFACE, 'get_student_user_ids',
 504                  [$useridlist]);
 505          manager::plugintype_class_callback('assignfeedback', self::ASSIGNFEEDBACK_INTERFACE, 'get_student_user_ids', [$useridlist]);
 506  
 507          $userids = $useridlist->get_userids();
 508          return ($userids) ? $userids : false;
 509      }
 510  
 511      /**
 512       * Writes out various user meta data about the assignment.
 513       *
 514       * @param  \context $context The context of this assignment.
 515       * @param  \assign $assign The assignment object.
 516       * @param  int $userid The user ID
 517       */
 518      protected static function store_assign_user_flags(\context $context, \assign $assign, int $userid) {
 519          $datatypes = ['locked' => get_string('locksubmissions', 'mod_assign'),
 520                        'mailed' => get_string('privacy:metadata:mailed', 'mod_assign'),
 521                        'extensionduedate' => get_string('extensionduedate', 'mod_assign'),
 522                        'workflowstate' => get_string('markingworkflowstate', 'mod_assign'),
 523                        'allocatedmarker' => get_string('allocatedmarker_help', 'mod_assign')];
 524          $userflags = (array)$assign->get_user_flags($userid, false);
 525  
 526          foreach ($datatypes as $key => $description) {
 527              if (isset($userflags[$key]) && !empty($userflags[$key])) {
 528                  $value = $userflags[$key];
 529                  if ($key == 'locked' || $key == 'mailed') {
 530                      $value = transform::yesno($value);
 531                  } else if ($key == 'extensionduedate') {
 532                      $value = transform::datetime($value);
 533                  }
 534                  writer::with_context($context)->export_metadata([], $key, $value, $description);
 535              }
 536          }
 537      }
 538  
 539      /**
 540       * Formats and then exports the user's grade data.
 541       *
 542       * @param  \stdClass $grade The assign grade object
 543       * @param  \context $context The context object
 544       * @param  array $currentpath Current directory path that we are exporting to.
 545       */
 546      protected static function export_grade_data(\stdClass $grade, \context $context, array $currentpath) {
 547          $gradedata = (object)[
 548              'timecreated' => transform::datetime($grade->timecreated),
 549              'timemodified' => transform::datetime($grade->timemodified),
 550              'grader' => transform::user($grade->grader),
 551              'grade' => $grade->grade,
 552              'attemptnumber' => ($grade->attemptnumber + 1)
 553          ];
 554          writer::with_context($context)
 555                  ->export_data(array_merge($currentpath, [get_string('privacy:gradepath', 'mod_assign')]), $gradedata);
 556      }
 557  
 558      /**
 559       * Formats and then exports the user's submission data.
 560       *
 561       * @param  \stdClass $submission The assign submission object
 562       * @param  \context $context The context object
 563       * @param  array $currentpath Current directory path that we are exporting to.
 564       */
 565      protected static function export_submission_data(\stdClass $submission, \context $context, array $currentpath) {
 566          $submissiondata = (object)[
 567              'timecreated' => transform::datetime($submission->timecreated),
 568              'timemodified' => transform::datetime($submission->timemodified),
 569              'status' => get_string('submissionstatus_' . $submission->status, 'mod_assign'),
 570              'groupid' => $submission->groupid,
 571              'attemptnumber' => ($submission->attemptnumber + 1),
 572              'latest' => transform::yesno($submission->latest)
 573          ];
 574          writer::with_context($context)
 575                  ->export_data(array_merge($currentpath, [get_string('privacy:submissionpath', 'mod_assign')]), $submissiondata);
 576      }
 577  
 578      /**
 579       * Stores the user preferences related to mod_assign.
 580       *
 581       * @param  int $userid The user ID that we want the preferences for.
 582       */
 583      public static function export_user_preferences(int $userid) {
 584          $context = \context_system::instance();
 585          $assignpreferences = [
 586              'assign_perpage' => ['string' => get_string('privacy:metadata:assignperpage', 'mod_assign'), 'bool' => false],
 587              'assign_filter' => ['string' => get_string('privacy:metadata:assignfilter', 'mod_assign'), 'bool' => false],
 588              'assign_markerfilter' => ['string' => get_string('privacy:metadata:assignmarkerfilter', 'mod_assign'), 'bool' => true],
 589              'assign_workflowfilter' => ['string' => get_string('privacy:metadata:assignworkflowfilter', 'mod_assign'),
 590                      'bool' => true],
 591              'assign_quickgrading' => ['string' => get_string('privacy:metadata:assignquickgrading', 'mod_assign'), 'bool' => true],
 592              'assign_downloadasfolders' => ['string' => get_string('privacy:metadata:assigndownloadasfolders', 'mod_assign'),
 593                      'bool' => true]
 594          ];
 595          foreach ($assignpreferences as $key => $preference) {
 596              $value = get_user_preferences($key, null, $userid);
 597              if ($preference['bool']) {
 598                  $value = transform::yesno($value);
 599              }
 600              if (isset($value)) {
 601                  writer::with_context($context)->export_user_preference('mod_assign', $key, $value, $preference['string']);
 602              }
 603          }
 604      }
 605  
 606      /**
 607       * Export overrides for this assignment.
 608       *
 609       * @param  \context $context Context
 610       * @param  \assign $assign The assign object.
 611       * @param  \stdClass $user The user object.
 612       */
 613      public static function export_overrides(\context $context, \assign $assign, \stdClass $user) {
 614  
 615          $overrides = $assign->override_exists($user->id);
 616          // Overrides returns an array with data in it, but an override with actual data will have the assign ID set.
 617          if (isset($overrides->assignid)) {
 618              $data = new \stdClass();
 619              if (!empty($overrides->duedate)) {
 620                  $data->duedate = transform::datetime($overrides->duedate);
 621              }
 622              if (!empty($overrides->cutoffdate)) {
 623                  $data->cutoffdate = transform::datetime($overrides->cutoffdate);
 624              }
 625              if (!empty($overrides->allowsubmissionsfromdate)) {
 626                  $data->allowsubmissionsfromdate = transform::datetime($overrides->allowsubmissionsfromdate);
 627              }
 628              if (!empty($data)) {
 629                  writer::with_context($context)->export_data([get_string('overrides', 'mod_assign')], $data);
 630              }
 631          }
 632      }
 633  
 634      /**
 635       * Exports assignment submission data for a user.
 636       *
 637       * @param  \assign         $assign           The assignment object
 638       * @param  \stdClass        $user             The user object
 639       * @param  \context_module $context          The context
 640       * @param  array           $path             The path for exporting data
 641       * @param  bool|boolean    $exportforteacher A flag for if this is exporting data as a teacher.
 642       */
 643      protected static function export_submission(\assign $assign, \stdClass $user, \context_module $context, array $path,
 644              bool $exportforteacher = false) {
 645          $submissions = $assign->get_all_submissions($user->id);
 646          $teacher = ($exportforteacher) ? $user : null;
 647          $gradingmanager = get_grading_manager($context, 'mod_assign', 'submissions');
 648          $controller = $gradingmanager->get_active_controller();
 649          foreach ($submissions as $submission) {
 650              // Attempt numbers start at zero, which is fine for programming, but doesn't make as much sense
 651              // for users.
 652              $submissionpath = array_merge($path,
 653                      [get_string('privacy:attemptpath', 'mod_assign', ($submission->attemptnumber + 1))]);
 654  
 655              $params = new assign_plugin_request_data($context, $assign, $submission, $submissionpath ,$teacher);
 656              manager::plugintype_class_callback('assignsubmission', self::ASSIGNSUBMISSION_INTERFACE,
 657                      'export_submission_user_data', [$params]);
 658              if (!isset($teacher)) {
 659                  self::export_submission_data($submission, $context, $submissionpath);
 660              }
 661              $grade = $assign->get_user_grade($user->id, false, $submission->attemptnumber);
 662              if ($grade) {
 663                  $params = new assign_plugin_request_data($context, $assign, $grade, $submissionpath, $teacher);
 664                  manager::plugintype_class_callback('assignfeedback', self::ASSIGNFEEDBACK_INTERFACE, 'export_feedback_user_data',
 665                          [$params]);
 666  
 667                  self::export_grade_data($grade, $context, $submissionpath);
 668                  // Check for advanced grading and retrieve that information.
 669                  if (isset($controller)) {
 670                      \core_grading\privacy\provider::export_item_data($context, $grade->id, $submissionpath);
 671                  }
 672              }
 673          }
 674      }
 675  }