Search moodle.org's
Developer Documentation

See Release Notes
Long Term Support Release

  • Bug fixes for general core bugs in 3.9.x will end* 10 May 2021 (12 months).
  • Bug fixes for security issues in 3.9.x will end* 8 May 2023 (36 months).
  • PHP version: minimum PHP 7.2.0 Note: minimum PHP version has increased since Moodle 3.8. PHP 7.3.x and 7.4.x are supported too.
/my/ -> lib.php (source)

Differences Between: [Versions 39 and 310] [Versions 39 and 311] [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   * My Moodle -- a user's personal dashboard
  19   *
  20   * This file contains common functions for the dashboard and profile pages.
  21   *
  22   * @package    moodlecore
  23   * @subpackage my
  24   * @copyright  2010 Remote-Learner.net
  25   * @author     Hubert Chathi <hubert@remote-learner.net>
  26   * @author     Olav Jordan <olav.jordan@remote-learner.net>
  27   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  28   */
  29  
  30  define('MY_PAGE_PUBLIC', 0);
  31  define('MY_PAGE_PRIVATE', 1);
  32  
  33  require_once("$CFG->libdir/blocklib.php");
  34  
  35  /*
  36   * For a given user, this returns the $page information for their My Moodle page
  37   *
  38   */
  39  function my_get_page($userid, $private=MY_PAGE_PRIVATE) {
  40      global $DB, $CFG;
  41  
  42      if (empty($CFG->forcedefaultmymoodle) && $userid) {  // Ignore custom My Moodle pages if admin has forced them
  43          // Does the user have their own page defined?  If so, return it.
  44          if ($customised = $DB->get_record('my_pages', array('userid' => $userid, 'private' => $private))) {
  45              return $customised;
  46          }
  47      }
  48  
  49      // Otherwise return the system default page
  50      return $DB->get_record('my_pages', array('userid' => null, 'name' => '__default', 'private' => $private));
  51  }
  52  
  53  
  54  /*
  55   * This copies a system default page to the current user
  56   *
  57   */
  58  function my_copy_page($userid, $private=MY_PAGE_PRIVATE, $pagetype='my-index') {
  59      global $DB;
  60  
  61      if ($customised = $DB->get_record('my_pages', array('userid' => $userid, 'private' => $private))) {
  62          return $customised;  // We're done!
  63      }
  64  
  65      // Get the system default page
  66      if (!$systempage = $DB->get_record('my_pages', array('userid' => null, 'private' => $private))) {
  67          return false;  // error
  68      }
  69  
  70      // Clone the basic system page record
  71      $page = clone($systempage);
  72      unset($page->id);
  73      $page->userid = $userid;
  74      $page->id = $DB->insert_record('my_pages', $page);
  75  
  76      // Clone ALL the associated blocks as well
  77      $systemcontext = context_system::instance();
  78      $usercontext = context_user::instance($userid);
  79  
  80      $blockinstances = $DB->get_records('block_instances', array('parentcontextid' => $systemcontext->id,
  81                                                                  'pagetypepattern' => $pagetype,
  82                                                                  'subpagepattern' => $systempage->id));
  83      $roles = get_all_roles();
  84      $newblockinstanceids = [];
  85      foreach ($blockinstances as $instance) {
  86          $originalid = $instance->id;
  87          $originalcontext = context_block::instance($originalid);
  88          unset($instance->id);
  89          $instance->parentcontextid = $usercontext->id;
  90          $instance->subpagepattern = $page->id;
  91          $instance->timecreated = time();
  92          $instance->timemodified = $instance->timecreated;
  93          $instance->id = $DB->insert_record('block_instances', $instance);
  94          $newblockinstanceids[$originalid] = $instance->id;
  95          $blockcontext = context_block::instance($instance->id);  // Just creates the context record
  96          $block = block_instance($instance->blockname, $instance);
  97          if (!$block->instance_copy($originalid)) {
  98              debugging("Unable to copy block-specific data for original block instance: $originalid
  99                  to new block instance: $instance->id", DEBUG_DEVELOPER);
 100          }
 101          // Check if there are any overrides on this block instance.
 102          // We check against all roles, not just roles assigned to the user.
 103          // This is so any overrides that are applied to the system default page
 104          // will be applied to the user's page as well, even if their role assignment changes in the future.
 105          foreach ($roles as $role) {
 106              $rolecapabilities = get_capabilities_from_role_on_context($role, $originalcontext);
 107              // If there are overrides, then apply them to the new block instance.
 108              foreach ($rolecapabilities as $rolecapability) {
 109                  role_change_permission(
 110                      $rolecapability->roleid,
 111                      $blockcontext,
 112                      $rolecapability->capability,
 113                      $rolecapability->permission
 114                  );
 115              }
 116          }
 117      }
 118  
 119      // Clone block position overrides.
 120      if ($blockpositions = $DB->get_records('block_positions',
 121              ['subpage' => $systempage->id, 'pagetype' => $pagetype, 'contextid' => $systemcontext->id])) {
 122          foreach ($blockpositions as &$positions) {
 123              $positions->subpage = $page->id;
 124              $positions->contextid = $usercontext->id;
 125              if (array_key_exists($positions->blockinstanceid, $newblockinstanceids)) {
 126                  // For block instances that were defined on the default dashboard and copied to the user dashboard
 127                  // use the new blockinstanceid.
 128                  $positions->blockinstanceid = $newblockinstanceids[$positions->blockinstanceid];
 129              }
 130              unset($positions->id);
 131          }
 132          $DB->insert_records('block_positions', $blockpositions);
 133      }
 134  
 135      return $page;
 136  }
 137  
 138  /*
 139   * For a given user, this deletes their My Moodle page and returns them to the system default.
 140   *
 141   * @param int $userid the id of the user whose page should be reset
 142   * @param int $private either MY_PAGE_PRIVATE or MY_PAGE_PUBLIC
 143   * @param string $pagetype either my-index or user-profile
 144   * @return mixed system page, or false on error
 145   */
 146  function my_reset_page($userid, $private=MY_PAGE_PRIVATE, $pagetype='my-index') {
 147      global $DB, $CFG;
 148  
 149      $page = my_get_page($userid, $private);
 150      if ($page->userid == $userid) {
 151          $context = context_user::instance($userid);
 152          if ($blocks = $DB->get_records('block_instances', array('parentcontextid' => $context->id,
 153                  'pagetypepattern' => $pagetype))) {
 154              foreach ($blocks as $block) {
 155                  if (is_null($block->subpagepattern) || $block->subpagepattern == $page->id) {
 156                      blocks_delete_instance($block);
 157                  }
 158              }
 159          }
 160          $DB->delete_records('block_positions', ['subpage' => $page->id, 'pagetype' => $pagetype, 'contextid' => $context->id]);
 161          $DB->delete_records('my_pages', array('id' => $page->id));
 162      }
 163  
 164      // Get the system default page
 165      if (!$systempage = $DB->get_record('my_pages', array('userid' => null, 'private' => $private))) {
 166          return false; // error
 167      }
 168  
 169      // Trigger dashboard has been reset event.
 170      $eventparams = array(
 171          'context' => context_user::instance($userid),
 172          'other' => array(
 173              'private' => $private,
 174              'pagetype' => $pagetype,
 175          ),
 176      );
 177      $event = \core\event\dashboard_reset::create($eventparams);
 178      $event->trigger();
 179      return $systempage;
 180  }
 181  
 182  /**
 183   * Resets the page customisations for all users.
 184   *
 185   * @param int $private Either MY_PAGE_PRIVATE or MY_PAGE_PUBLIC.
 186   * @param string $pagetype Either my-index or user-profile.
 187   * @return void
 188   */
 189  function my_reset_page_for_all_users($private = MY_PAGE_PRIVATE, $pagetype = 'my-index') {
 190      global $DB;
 191  
 192      // This may take a while. Raise the execution time limit.
 193      core_php_time_limit::raise();
 194  
 195      // Find all the user pages and all block instances in them.
 196      $sql = "SELECT bi.id
 197          FROM {my_pages} p
 198          JOIN {context} ctx ON ctx.instanceid = p.userid AND ctx.contextlevel = :usercontextlevel
 199          JOIN {block_instances} bi ON bi.parentcontextid = ctx.id AND
 200              bi.pagetypepattern = :pagetypepattern AND
 201              (bi.subpagepattern IS NULL OR bi.subpagepattern = " . $DB->sql_concat("''", 'p.id') . ")
 202          WHERE p.private = :private";
 203      $params = array('private' => $private,
 204          'usercontextlevel' => CONTEXT_USER,
 205          'pagetypepattern' => $pagetype);
 206      $blockids = $DB->get_fieldset_sql($sql, $params);
 207  
 208      // Wrap the SQL queries in a transaction.
 209      $transaction = $DB->start_delegated_transaction();
 210  
 211      // Delete the block instances.
 212      if (!empty($blockids)) {
 213          blocks_delete_instances($blockids);
 214      }
 215  
 216      // Finally delete the pages.
 217      $DB->delete_records_select('my_pages', 'userid IS NOT NULL AND private = :private', ['private' => $private]);
 218  
 219      // We should be good to go now.
 220      $transaction->allow_commit();
 221  
 222      // Trigger dashboard has been reset event.
 223      $eventparams = array(
 224          'context' => context_system::instance(),
 225          'other' => array(
 226              'private' => $private,
 227              'pagetype' => $pagetype,
 228          ),
 229      );
 230      $event = \core\event\dashboards_reset::create($eventparams);
 231      $event->trigger();
 232  }
 233  
 234  class my_syspage_block_manager extends block_manager {
 235      // HACK WARNING!
 236      // TODO: figure out a better way to do this
 237      /**
 238       * Load blocks using the system context, rather than the user's context.
 239       *
 240       * This is needed because the My Moodle pages set the page context to the
 241       * user's context for access control, etc.  But the blocks for the system
 242       * pages are stored in the system context.
 243       */
 244      public function load_blocks($includeinvisible = null) {
 245          $origcontext = $this->page->context;
 246          $this->page->context = context_system::instance();
 247          parent::load_blocks($includeinvisible);
 248          $this->page->context = $origcontext;
 249      }
 250  }