Search moodle.org's
Developer Documentation

See Release Notes

  • Bug fixes for general core bugs in 4.0.x will end 8 May 2023 (12 months).
  • Bug fixes for security issues in 4.0.x will end 13 November 2023 (18 months).
  • PHP version: minimum PHP 7.3.0 Note: the minimum PHP version has increased since Moodle 3.10. PHP 7.4.x is also supported.
/lib/ -> blocklib.php (source)

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

   1  <?php
   2  
   3  // This file is part of Moodle - http://moodle.org/
   4  //
   5  // Moodle is free software: you can redistribute it and/or modify
   6  // it under the terms of the GNU General Public License as published by
   7  // the Free Software Foundation, either version 3 of the License, or
   8  // (at your option) any later version.
   9  //
  10  // Moodle is distributed in the hope that it will be useful,
  11  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  // GNU General Public License for more details.
  14  //
  15  // You should have received a copy of the GNU General Public License
  16  // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  17  
  18  /**
  19   * Block Class and Functions
  20   *
  21   * This file defines the {@link block_manager} class,
  22   *
  23   * @package    core
  24   * @subpackage block
  25   * @copyright  1999 onwards Martin Dougiamas  http://dougiamas.com
  26   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  27   */
  28  
  29  defined('MOODLE_INTERNAL') || die();
  30  
  31  /**#@+
  32   * Default names for the block regions in the standard theme.
  33   */
  34  define('BLOCK_POS_LEFT',  'side-pre');
  35  define('BLOCK_POS_RIGHT', 'side-post');
  36  /**#@-*/
  37  
  38  define('BUI_CONTEXTS_FRONTPAGE_ONLY', 0);
  39  define('BUI_CONTEXTS_FRONTPAGE_SUBS', 1);
  40  define('BUI_CONTEXTS_ENTIRE_SITE', 2);
  41  
  42  define('BUI_CONTEXTS_CURRENT', 0);
  43  define('BUI_CONTEXTS_CURRENT_SUBS', 1);
  44  
  45  // Position of "Add block" control, to be used in theme config as a value for $THEME->addblockposition:
  46  // - default: as a fake block that is displayed in editing mode
  47  // - flatnav: "Add block" item in the flat navigation drawer in editing mode
  48  // - custom: none of the above, theme will take care of displaying the control.
  49  define('BLOCK_ADDBLOCK_POSITION_DEFAULT', 0);
  50  define('BLOCK_ADDBLOCK_POSITION_FLATNAV', 1);
  51  define('BLOCK_ADDBLOCK_POSITION_CUSTOM', -1);
  52  
  53  /**
  54   * Exception thrown when someone tried to do something with a block that does
  55   * not exist on a page.
  56   *
  57   * @copyright 2009 Tim Hunt
  58   * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  59   * @since     Moodle 2.0
  60   */
  61  class block_not_on_page_exception extends moodle_exception {
  62      /**
  63       * Constructor
  64       * @param int $instanceid the block instance id of the block that was looked for.
  65       * @param object $page the current page.
  66       */
  67      public function __construct($instanceid, $page) {
  68          $a = new stdClass;
  69          $a->instanceid = $instanceid;
  70          $a->url = $page->url->out();
  71          parent::__construct('blockdoesnotexistonpage', '', $page->url->out(), $a);
  72      }
  73  }
  74  
  75  /**
  76   * This class keeps track of the block that should appear on a moodle_page.
  77   *
  78   * The page to work with as passed to the constructor.
  79   *
  80   * @copyright 2009 Tim Hunt
  81   * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  82   * @since     Moodle 2.0
  83   */
  84  class block_manager {
  85      /**
  86       * The UI normally only shows block weights between -MAX_WEIGHT and MAX_WEIGHT,
  87       * although other weights are valid.
  88       */
  89      const MAX_WEIGHT = 10;
  90  
  91  /// Field declarations =========================================================
  92  
  93      /**
  94       * the moodle_page we are managing blocks for.
  95       * @var moodle_page
  96       */
  97      protected $page;
  98  
  99      /** @var array region name => 1.*/
 100      protected $regions = array();
 101  
 102      /** @var string the region where new blocks are added.*/
 103      protected $defaultregion = null;
 104  
 105      /** @var array will be $DB->get_records('blocks') */
 106      protected $allblocks = null;
 107  
 108      /**
 109       * @var array blocks that this user can add to this page. Will be a subset
 110       * of $allblocks, but with array keys block->name. Access this via the
 111       * {@link get_addable_blocks()} method to ensure it is lazy-loaded.
 112       */
 113      protected $addableblocks = null;
 114  
 115      /**
 116       * Will be an array region-name => array(db rows loaded in load_blocks);
 117       * @var array
 118       */
 119      protected $birecordsbyregion = null;
 120  
 121      /**
 122       * array region-name => array(block objects); populated as necessary by
 123       * the ensure_instances_exist method.
 124       * @var array
 125       */
 126      protected $blockinstances = array();
 127  
 128      /**
 129       * array region-name => array(block_contents objects) what actually needs to
 130       * be displayed in each region.
 131       * @var array
 132       */
 133      protected $visibleblockcontent = array();
 134  
 135      /**
 136       * array region-name => array(block_contents objects) extra block-like things
 137       * to be displayed in each region, before the real blocks.
 138       * @var array
 139       */
 140      protected $extracontent = array();
 141  
 142      /**
 143       * Used by the block move id, to track whether a block is currently being moved.
 144       *
 145       * When you click on the move icon of a block, first the page needs to reload with
 146       * extra UI for choosing a new position for a particular block. In that situation
 147       * this field holds the id of the block being moved.
 148       *
 149       * @var integer|null
 150       */
 151      protected $movingblock = null;
 152  
 153      /**
 154       * Show only fake blocks
 155       */
 156      protected $fakeblocksonly = false;
 157  
 158  /// Constructor ================================================================
 159  
 160      /**
 161       * Constructor.
 162       * @param object $page the moodle_page object object we are managing the blocks for,
 163       * or a reasonable faxilimily. (See the comment at the top of this class
 164       * and {@link http://en.wikipedia.org/wiki/Duck_typing})
 165       */
 166      public function __construct($page) {
 167          $this->page = $page;
 168      }
 169  
 170  /// Getter methods =============================================================
 171  
 172      /**
 173       * Get an array of all region names on this page where a block may appear
 174       *
 175       * @return array the internal names of the regions on this page where block may appear.
 176       */
 177      public function get_regions() {
 178          if (is_null($this->defaultregion)) {
 179              $this->page->initialise_theme_and_output();
 180          }
 181          return array_keys($this->regions);
 182      }
 183  
 184      /**
 185       * Get the region name of the region blocks are added to by default
 186       *
 187       * @return string the internal names of the region where new blocks are added
 188       * by default, and where any blocks from an unrecognised region are shown.
 189       * (Imagine that blocks were added with one theme selected, then you switched
 190       * to a theme with different block positions.)
 191       */
 192      public function get_default_region() {
 193          $this->page->initialise_theme_and_output();
 194          return $this->defaultregion;
 195      }
 196  
 197      /**
 198       * The list of block types that may be added to this page.
 199       *
 200       * @return array block name => record from block table.
 201       */
 202      public function get_addable_blocks() {
 203          $this->check_is_loaded();
 204  
 205          if (!is_null($this->addableblocks)) {
 206              return $this->addableblocks;
 207          }
 208  
 209          // Lazy load.
 210          $this->addableblocks = array();
 211  
 212          $allblocks = blocks_get_record();
 213          if (empty($allblocks)) {
 214              return $this->addableblocks;
 215          }
 216  
 217          $undeletableblocks = self::get_undeletable_block_types();
 218          $unaddablebythemeblocks = $this->get_unaddable_by_theme_block_types();
 219          $requiredbythemeblocks = $this->get_required_by_theme_block_types();
 220          $pageformat = $this->page->pagetype;
 221          foreach($allblocks as $block) {
 222              if (!$bi = block_instance($block->name)) {
 223                  continue;
 224              }
 225              if ($block->visible && !in_array($block->name, $undeletableblocks) &&
 226                      !in_array($block->name, $requiredbythemeblocks) &&
 227                      !in_array($block->name, $unaddablebythemeblocks) &&
 228                      $bi->can_block_be_added($this->page) &&
 229                      ($bi->instance_allow_multiple() || !$this->is_block_present($block->name)) &&
 230                      blocks_name_allowed_in_format($block->name, $pageformat) &&
 231                      $bi->user_can_addto($this->page)) {
 232                  $block->title = $bi->get_title();
 233                  $this->addableblocks[$block->name] = $block;
 234              }
 235          }
 236  
 237          core_collator::asort_objects_by_property($this->addableblocks, 'title');
 238          return $this->addableblocks;
 239      }
 240  
 241      /**
 242       * Given a block name, find out of any of them are currently present in the page
 243  
 244       * @param string $blockname - the basic name of a block (eg "navigation")
 245       * @return boolean - is there one of these blocks in the current page?
 246       */
 247      public function is_block_present($blockname) {
 248          if (empty($this->blockinstances)) {
 249              return false;
 250          }
 251  
 252          $requiredbythemeblocks = $this->get_required_by_theme_block_types();
 253          foreach ($this->blockinstances as $region) {
 254              foreach ($region as $instance) {
 255                  if (empty($instance->instance->blockname)) {
 256                      continue;
 257                  }
 258                  if ($instance->instance->blockname == $blockname) {
 259                      if ($instance->instance->requiredbytheme) {
 260                          if (!in_array($blockname, $requiredbythemeblocks)) {
 261                              continue;
 262                          }
 263                      }
 264                      return true;
 265                  }
 266              }
 267          }
 268          return false;
 269      }
 270  
 271      /**
 272       * Find out if a block type is known by the system
 273       *
 274       * @param string $blockname the name of the type of block.
 275       * @param boolean $includeinvisible if false (default) only check 'visible' blocks, that is, blocks enabled by the admin.
 276       * @return boolean true if this block in installed.
 277       */
 278      public function is_known_block_type($blockname, $includeinvisible = false) {
 279          $blocks = $this->get_installed_blocks();
 280          foreach ($blocks as $block) {
 281              if ($block->name == $blockname && ($includeinvisible || $block->visible)) {
 282                  return true;
 283              }
 284          }
 285          return false;
 286      }
 287  
 288      /**
 289       * Find out if a region exists on a page
 290       *
 291       * @param string $region a region name
 292       * @return boolean true if this region exists on this page.
 293       */
 294      public function is_known_region($region) {
 295          if (empty($region)) {
 296              return false;
 297          }
 298          return array_key_exists($region, $this->regions);
 299      }
 300  
 301      /**
 302       * Get an array of all blocks within a given region
 303       *
 304       * @param string $region a block region that exists on this page.
 305       * @return array of block instances.
 306       */
 307      public function get_blocks_for_region($region) {
 308          $this->check_is_loaded();
 309          $this->ensure_instances_exist($region);
 310          return $this->blockinstances[$region];
 311      }
 312  
 313      /**
 314       * Returns an array of block content objects that exist in a region
 315       *
 316       * @param string $region a block region that exists on this page.
 317       * @return array of block block_contents objects for all the blocks in a region.
 318       */
 319      public function get_content_for_region($region, $output) {
 320          $this->check_is_loaded();
 321          $this->ensure_content_created($region, $output);
 322          return $this->visibleblockcontent[$region];
 323      }
 324  
 325      /**
 326       * Returns an array of block content objects for all the existings regions
 327       *
 328       * @param renderer_base $output the rendered to use
 329       * @return array of block block_contents objects for all the blocks in all regions.
 330       * @since  Moodle 3.3
 331       */
 332      public function get_content_for_all_regions($output) {
 333          $contents = array();
 334          $this->check_is_loaded();
 335  
 336          foreach ($this->regions as $region => $val) {
 337              $this->ensure_content_created($region, $output);
 338              $contents[$region] = $this->visibleblockcontent[$region];
 339          }
 340          return $contents;
 341      }
 342  
 343      /**
 344       * Helper method used by get_content_for_region.
 345       * @param string $region region name
 346       * @param float $weight weight. May be fractional, since you may want to move a block
 347       * between ones with weight 2 and 3, say ($weight would be 2.5).
 348       * @return string URL for moving block $this->movingblock to this position.
 349       */
 350      protected function get_move_target_url($region, $weight) {
 351          return new moodle_url($this->page->url, array('bui_moveid' => $this->movingblock,
 352                  'bui_newregion' => $region, 'bui_newweight' => $weight, 'sesskey' => sesskey()));
 353      }
 354  
 355      /**
 356       * Determine whether a region contains anything. (Either any real blocks, or
 357       * the add new block UI.)
 358       *
 359       * (You may wonder why the $output parameter is required. Unfortunately,
 360       * because of the way that blocks work, the only reliable way to find out
 361       * if a block will be visible is to get the content for output, and to
 362       * get the content, you need a renderer. Fortunately, this is not a
 363       * performance problem, because we cache the output that is generated, and
 364       * in almost every case where we call region_has_content, we are about to
 365       * output the blocks anyway, so we are not doing wasted effort.)
 366       *
 367       * @param string $region a block region that exists on this page.
 368       * @param core_renderer $output a core_renderer. normally the global $OUTPUT.
 369       * @return boolean Whether there is anything in this region.
 370       */
 371      public function region_has_content($region, $output) {
 372  
 373          if (!$this->is_known_region($region)) {
 374              return false;
 375          }
 376          $this->check_is_loaded();
 377          $this->ensure_content_created($region, $output);
 378          // if ($this->page->user_is_editing() && $this->page->user_can_edit_blocks()) {
 379          // Mark Nielsen's patch - part 1
 380          if ($this->page->user_is_editing() && $this->page->user_can_edit_blocks() && $this->movingblock) {
 381              // If editing is on, we need all the block regions visible, for the
 382              // move blocks UI.
 383              return true;
 384          }
 385          return !empty($this->visibleblockcontent[$region]) || !empty($this->extracontent[$region]);
 386      }
 387  
 388      /**
 389       * Determine whether a region contains any fake blocks.
 390       *
 391       * (Fake blocks are typically added to the extracontent array per region)
 392       *
 393       * @param string $region a block region that exists on this page.
 394       * @return boolean Whether there are fake blocks in this region.
 395       */
 396      public function region_has_fakeblocks($region): bool {
 397          return !empty($this->extracontent[$region]);
 398      }
 399  
 400      /**
 401       * Get an array of all of the installed blocks.
 402       *
 403       * @return array contents of the block table.
 404       */
 405      public function get_installed_blocks() {
 406          global $DB;
 407          if (is_null($this->allblocks)) {
 408              $this->allblocks = $DB->get_records('block');
 409          }
 410          return $this->allblocks;
 411      }
 412  
 413      /**
 414       * @return array names of block types that must exist on every page with this theme.
 415       */
 416      public function get_required_by_theme_block_types() {
 417          $requiredbythemeblocks = false;
 418          if (isset($this->page->theme->requiredblocks)) {
 419              $requiredbythemeblocks = $this->page->theme->requiredblocks;
 420          }
 421  
 422          if ($requiredbythemeblocks === false) {
 423              return array('navigation', 'settings');
 424          } else if ($requiredbythemeblocks === '') {
 425              return array();
 426          } else if (is_string($requiredbythemeblocks)) {
 427              return explode(',', $requiredbythemeblocks);
 428          } else {
 429              return $requiredbythemeblocks;
 430          }
 431      }
 432  
 433      /**
 434       * It returns the list of blocks that can't be displayed in the "Add a block" list.
 435       * This information is taken from the unaddableblocks theme setting.
 436       *
 437       * @return array A list with the blocks that won't be displayed in the "Add a block" list.
 438       */
 439      public function get_unaddable_by_theme_block_types(): array {
 440          $unaddablebythemeblocks = [];
 441          if (isset($this->page->theme->settings->unaddableblocks) && !empty($this->page->theme->settings->unaddableblocks)) {
 442              $unaddablebythemeblocks = array_map('trim', explode(',', $this->page->theme->settings->unaddableblocks));
 443          }
 444  
 445          return $unaddablebythemeblocks;
 446      }
 447  
 448      /**
 449       * Make this block type undeletable and unaddable.
 450       *
 451       * @param mixed $blockidorname string or int
 452       */
 453      public static function protect_block($blockidorname) {
 454          global $DB;
 455  
 456          $syscontext = context_system::instance();
 457  
 458          require_capability('moodle/site:config', $syscontext);
 459  
 460          $block = false;
 461          if (is_int($blockidorname)) {
 462              $block = $DB->get_record('block', array('id' => $blockidorname), 'id, name', MUST_EXIST);
 463          } else {
 464              $block = $DB->get_record('block', array('name' => $blockidorname), 'id, name', MUST_EXIST);
 465          }
 466          $undeletableblocktypes = self::get_undeletable_block_types();
 467          if (!in_array($block->name, $undeletableblocktypes)) {
 468              $undeletableblocktypes[] = $block->name;
 469              set_config('undeletableblocktypes', implode(',', $undeletableblocktypes));
 470              add_to_config_log('block_protect', "0", "1", $block->name);
 471          }
 472      }
 473  
 474      /**
 475       * Make this block type deletable and addable.
 476       *
 477       * @param mixed $blockidorname string or int
 478       */
 479      public static function unprotect_block($blockidorname) {
 480          global $DB;
 481  
 482          $syscontext = context_system::instance();
 483  
 484          require_capability('moodle/site:config', $syscontext);
 485  
 486          $block = false;
 487          if (is_int($blockidorname)) {
 488              $block = $DB->get_record('block', array('id' => $blockidorname), 'id, name', MUST_EXIST);
 489          } else {
 490              $block = $DB->get_record('block', array('name' => $blockidorname), 'id, name', MUST_EXIST);
 491          }
 492          $undeletableblocktypes = self::get_undeletable_block_types();
 493          if (in_array($block->name, $undeletableblocktypes)) {
 494              $undeletableblocktypes = array_diff($undeletableblocktypes, array($block->name));
 495              set_config('undeletableblocktypes', implode(',', $undeletableblocktypes));
 496              add_to_config_log('block_protect', "1", "0", $block->name);
 497          }
 498  
 499      }
 500  
 501      /**
 502       * Get the list of "protected" blocks via admin block manager ui.
 503       *
 504       * @return array names of block types that cannot be added or deleted. E.g. array('navigation','settings').
 505       */
 506      public static function get_undeletable_block_types() {
 507          global $CFG;
 508          $undeletableblocks = false;
 509          if (isset($CFG->undeletableblocktypes)) {
 510              $undeletableblocks = $CFG->undeletableblocktypes;
 511          }
 512  
 513          if (empty($undeletableblocks)) {
 514              return array();
 515          } else if (is_string($undeletableblocks)) {
 516              return explode(',', $undeletableblocks);
 517          } else {
 518              return $undeletableblocks;
 519          }
 520      }
 521  
 522  /// Setter methods =============================================================
 523  
 524      /**
 525       * Add a region to a page
 526       *
 527       * @param string $region add a named region where blocks may appear on the current page.
 528       *      This is an internal name, like 'side-pre', not a string to display in the UI.
 529       * @param bool $custom True if this is a custom block region, being added by the page rather than the theme layout.
 530       */
 531      public function add_region($region, $custom = true) {
 532          global $SESSION;
 533          $this->check_not_yet_loaded();
 534          if ($custom) {
 535              if (array_key_exists($region, $this->regions)) {
 536                  // This here is EXACTLY why we should not be adding block regions into a page. It should
 537                  // ALWAYS be done in a theme layout.
 538                  debugging('A custom region conflicts with a block region in the theme.', DEBUG_DEVELOPER);
 539              }
 540              // We need to register this custom region against the page type being used.
 541              // This allows us to check, when performing block actions, that unrecognised regions can be worked with.
 542              $type = $this->page->pagetype;
 543              if (!isset($SESSION->custom_block_regions)) {
 544                  $SESSION->custom_block_regions = array($type => array($region));
 545              } else if (!isset($SESSION->custom_block_regions[$type])) {
 546                  $SESSION->custom_block_regions[$type] = array($region);
 547              } else if (!in_array($region, $SESSION->custom_block_regions[$type])) {
 548                  $SESSION->custom_block_regions[$type][] = $region;
 549              }
 550          }
 551          $this->regions[$region] = 1;
 552  
 553          // Checking the actual property instead of calling get_default_region as it ends up in a recursive call.
 554          if (empty($this->defaultregion)) {
 555              $this->set_default_region($region);
 556          }
 557      }
 558  
 559      /**
 560       * Add an array of regions
 561       * @see add_region()
 562       *
 563       * @param array $regions this utility method calls add_region for each array element.
 564       */
 565      public function add_regions($regions, $custom = true) {
 566          foreach ($regions as $region) {
 567              $this->add_region($region, $custom);
 568          }
 569      }
 570  
 571      /**
 572       * Finds custom block regions associated with a page type and registers them with this block manager.
 573       *
 574       * @param string $pagetype
 575       */
 576      public function add_custom_regions_for_pagetype($pagetype) {
 577          global $SESSION;
 578          if (isset($SESSION->custom_block_regions[$pagetype])) {
 579              foreach ($SESSION->custom_block_regions[$pagetype] as $customregion) {
 580                  $this->add_region($customregion, false);
 581              }
 582          }
 583      }
 584  
 585      /**
 586       * Set the default region for new blocks on the page
 587       *
 588       * @param string $defaultregion the internal names of the region where new
 589       * blocks should be added by default, and where any blocks from an
 590       * unrecognised region are shown.
 591       */
 592      public function set_default_region($defaultregion) {
 593          $this->check_not_yet_loaded();
 594          if ($defaultregion) {
 595              $this->check_region_is_known($defaultregion);
 596          }
 597          $this->defaultregion = $defaultregion;
 598      }
 599  
 600      /**
 601       * Add something that looks like a block, but which isn't an actual block_instance,
 602       * to this page.
 603       *
 604       * @param block_contents $bc the content of the block-like thing.
 605       * @param string $region a block region that exists on this page.
 606       */
 607      public function add_fake_block($bc, $region) {
 608          $this->page->initialise_theme_and_output();
 609          if (!$this->is_known_region($region)) {
 610              $region = $this->get_default_region();
 611          }
 612          if (array_key_exists($region, $this->visibleblockcontent)) {
 613              throw new coding_exception('block_manager has already prepared the blocks in region ' .
 614                      $region . 'for output. It is too late to add a fake block.');
 615          }
 616          if (!isset($bc->attributes['data-block'])) {
 617              $bc->attributes['data-block'] = '_fake';
 618          }
 619          $bc->attributes['class'] .= ' block_fake';
 620          $this->extracontent[$region][] = $bc;
 621      }
 622  
 623      /**
 624       * Checks to see whether all of the blocks within the given region are docked
 625       *
 626       * @see region_uses_dock
 627       * @param string $region
 628       * @return bool True if all of the blocks within that region are docked
 629       *
 630       * Return false as from MDL-64506
 631       */
 632      public function region_completely_docked($region, $output) {
 633          return false;
 634      }
 635  
 636      /**
 637       * Checks to see whether any of the blocks within the given regions are docked
 638       *
 639       * @see region_completely_docked
 640       * @param array|string $regions array of regions (or single region)
 641       * @return bool True if any of the blocks within that region are docked
 642       *
 643       * Return false as from MDL-64506
 644       */
 645      public function region_uses_dock($regions, $output) {
 646          return false;
 647      }
 648  
 649  /// Actions ====================================================================
 650  
 651      /**
 652       * This method actually loads the blocks for our page from the database.
 653       *
 654       * @param boolean|null $includeinvisible
 655       *      null (default) - load hidden blocks if $this->page->user_is_editing();
 656       *      true - load hidden blocks.
 657       *      false - don't load hidden blocks.
 658       */
 659      public function load_blocks($includeinvisible = null) {
 660          global $DB, $CFG;
 661  
 662          if (!is_null($this->birecordsbyregion)) {
 663              // Already done.
 664              return;
 665          }
 666  
 667          if ($CFG->version < 2009050619) {
 668              // Upgrade/install not complete. Don't try too show any blocks.
 669              $this->birecordsbyregion = array();
 670              return;
 671          }
 672  
 673          // Ensure we have been initialised.
 674          if (is_null($this->defaultregion)) {
 675              $this->page->initialise_theme_and_output();
 676              // If there are still no block regions, then there are no blocks on this page.
 677              if (empty($this->regions)) {
 678                  $this->birecordsbyregion = array();
 679                  return;
 680              }
 681          }
 682  
 683          // Check if we need to load normal blocks
 684          if ($this->fakeblocksonly) {
 685              $this->birecordsbyregion = $this->prepare_per_region_arrays();
 686              return;
 687          }
 688  
 689          // Exclude auto created blocks if they are not undeletable in this theme.
 690          $requiredbytheme = $this->get_required_by_theme_block_types();
 691          $requiredbythemecheck = '';
 692          $requiredbythemeparams = array();
 693          $requiredbythemenotparams = array();
 694          if (!empty($requiredbytheme)) {
 695              list($testsql, $requiredbythemeparams) = $DB->get_in_or_equal($requiredbytheme, SQL_PARAMS_NAMED, 'requiredbytheme');
 696              list($testnotsql, $requiredbythemenotparams) = $DB->get_in_or_equal($requiredbytheme, SQL_PARAMS_NAMED,
 697                                                                                  'notrequiredbytheme', false);
 698              $requiredbythemecheck = 'AND ((bi.blockname ' . $testsql . ' AND bi.requiredbytheme = 1) OR ' .
 699                                  ' (bi.blockname ' . $testnotsql . ' AND bi.requiredbytheme = 0))';
 700          } else {
 701              $requiredbythemecheck = 'AND (bi.requiredbytheme = 0)';
 702          }
 703  
 704          if (is_null($includeinvisible)) {
 705              $includeinvisible = $this->page->user_is_editing();
 706          }
 707          if ($includeinvisible) {
 708              $visiblecheck = '';
 709          } else {
 710              $visiblecheck = 'AND (bp.visible = 1 OR bp.visible IS NULL) AND (bs.visible = 1 OR bs.visible IS NULL)';
 711          }
 712  
 713          $context = $this->page->context;
 714          $contexttest = 'bi.parentcontextid IN (:contextid2, :contextid3)';
 715          $parentcontextparams = array();
 716          $parentcontextids = $context->get_parent_context_ids();
 717          if ($parentcontextids) {
 718              list($parentcontexttest, $parentcontextparams) =
 719                      $DB->get_in_or_equal($parentcontextids, SQL_PARAMS_NAMED, 'parentcontext');
 720              $contexttest = "($contexttest OR (bi.showinsubcontexts = 1 AND bi.parentcontextid $parentcontexttest))";
 721          }
 722  
 723          $pagetypepatterns = matching_page_type_patterns($this->page->pagetype);
 724          list($pagetypepatterntest, $pagetypepatternparams) =
 725                  $DB->get_in_or_equal($pagetypepatterns, SQL_PARAMS_NAMED, 'pagetypepatterntest');
 726  
 727          $ccselect = ', ' . context_helper::get_preload_record_columns_sql('ctx');
 728          $ccjoin = "LEFT JOIN {context} ctx ON (ctx.instanceid = bi.id AND ctx.contextlevel = :contextlevel)";
 729  
 730          $systemcontext = context_system::instance();
 731          $params = array(
 732              'contextlevel' => CONTEXT_BLOCK,
 733              'subpage1' => $this->page->subpage,
 734              'subpage2' => $this->page->subpage,
 735              'subpage3' => $this->page->subpage,
 736              'contextid1' => $context->id,
 737              'contextid2' => $context->id,
 738              'contextid3' => $systemcontext->id,
 739              'contextid4' => $systemcontext->id,
 740              'pagetype' => $this->page->pagetype,
 741              'pagetype2' => $this->page->pagetype,
 742          );
 743          if ($this->page->subpage === '') {
 744              $params['subpage1'] = '';
 745              $params['subpage2'] = '';
 746              $params['subpage3'] = '';
 747          }
 748          $sql = "SELECT
 749                      bi.id,
 750                      COALESCE(bp.id, bs.id) AS blockpositionid,
 751                      bi.blockname,
 752                      bi.parentcontextid,
 753                      bi.showinsubcontexts,
 754                      bi.pagetypepattern,
 755                      bi.requiredbytheme,
 756                      bi.subpagepattern,
 757                      bi.defaultregion,
 758                      bi.defaultweight,
 759                      COALESCE(bp.visible, bs.visible, 1) AS visible,
 760                      COALESCE(bp.region, bs.region, bi.defaultregion) AS region,
 761                      COALESCE(bp.weight, bs.weight, bi.defaultweight) AS weight,
 762                      bi.configdata
 763                      $ccselect
 764  
 765                  FROM {block_instances} bi
 766                  JOIN {block} b ON bi.blockname = b.name
 767                  LEFT JOIN {block_positions} bp ON bp.blockinstanceid = bi.id
 768                                                    AND bp.contextid = :contextid1
 769                                                    AND bp.pagetype = :pagetype
 770                                                    AND bp.subpage = :subpage1
 771                  LEFT JOIN {block_positions} bs ON bs.blockinstanceid = bi.id
 772                                                    AND bs.contextid = :contextid4
 773                                                    AND bs.pagetype = :pagetype2
 774                                                    AND bs.subpage = :subpage3
 775                  $ccjoin
 776  
 777                  WHERE
 778                  $contexttest
 779                  AND bi.pagetypepattern $pagetypepatterntest
 780                  AND (bi.subpagepattern IS NULL OR bi.subpagepattern = :subpage2)
 781                  $visiblecheck
 782                  AND b.visible = 1
 783                  $requiredbythemecheck
 784  
 785                  ORDER BY
 786                      COALESCE(bp.region, bs.region, bi.defaultregion),
 787                      COALESCE(bp.weight, bs.weight, bi.defaultweight),
 788                      bi.id";
 789  
 790          $allparams = $params + $parentcontextparams + $pagetypepatternparams + $requiredbythemeparams + $requiredbythemenotparams;
 791          $blockinstances = $DB->get_recordset_sql($sql, $allparams);
 792  
 793          $this->birecordsbyregion = $this->prepare_per_region_arrays();
 794          $unknown = array();
 795          foreach ($blockinstances as $bi) {
 796              context_helper::preload_from_record($bi);
 797              if ($this->is_known_region($bi->region)) {
 798                  $this->birecordsbyregion[$bi->region][] = $bi;
 799              } else {
 800                  $unknown[] = $bi;
 801              }
 802          }
 803          $blockinstances->close();
 804  
 805          // Pages don't necessarily have a defaultregion. The  one time this can
 806          // happen is when there are no theme block regions, but the script itself
 807          // has a block region in the main content area.
 808          if (!empty($this->defaultregion)) {
 809              $this->birecordsbyregion[$this->defaultregion] =
 810                      array_merge($this->birecordsbyregion[$this->defaultregion], $unknown);
 811          }
 812      }
 813  
 814      /**
 815       * Add a block to the current page, or related pages. The block is added to
 816       * context $this->page->contextid. If $pagetypepattern $subpagepattern
 817       *
 818       * @param string $blockname The type of block to add.
 819       * @param string $region the block region on this page to add the block to.
 820       * @param integer $weight determines the order where this block appears in the region.
 821       * @param boolean $showinsubcontexts whether this block appears in subcontexts, or just the current context.
 822       * @param string|null $pagetypepattern which page types this block should appear on. Defaults to just the current page type.
 823       * @param string|null $subpagepattern which subpage this block should appear on. NULL = any (the default), otherwise only the specified subpage.
 824       */
 825      public function add_block($blockname, $region, $weight, $showinsubcontexts, $pagetypepattern = NULL, $subpagepattern = NULL) {
 826          global $DB;
 827          // Allow invisible blocks because this is used when adding default page blocks, which
 828          // might include invisible ones if the user makes some default blocks invisible
 829          $this->check_known_block_type($blockname, true);
 830          $this->check_region_is_known($region);
 831  
 832          if (empty($pagetypepattern)) {
 833              $pagetypepattern = $this->page->pagetype;
 834          }
 835  
 836          $blockinstance = new stdClass;
 837          $blockinstance->blockname = $blockname;
 838          $blockinstance->parentcontextid = $this->page->context->id;
 839          $blockinstance->showinsubcontexts = !empty($showinsubcontexts);
 840          $blockinstance->pagetypepattern = $pagetypepattern;
 841          $blockinstance->subpagepattern = $subpagepattern;
 842          $blockinstance->defaultregion = $region;
 843          $blockinstance->defaultweight = $weight;
 844          $blockinstance->configdata = '';
 845          $blockinstance->timecreated = time();
 846          $blockinstance->timemodified = $blockinstance->timecreated;
 847          $blockinstance->id = $DB->insert_record('block_instances', $blockinstance);
 848  
 849          // Ensure the block context is created.
 850          context_block::instance($blockinstance->id);
 851  
 852          // If the new instance was created, allow it to do additional setup
 853          if ($block = block_instance($blockname, $blockinstance)) {
 854              $block->instance_create();
 855          }
 856      }
 857  
 858      /**
 859       * When passed a block name create a new instance of the block in the specified region.
 860       *
 861       * @param string $blockname Name of the block to add.
 862       * @param null|string $blockregion If defined add the new block to the specified region.
 863       */
 864      public function add_block_at_end_of_default_region($blockname, $blockregion = null) {
 865          if (empty($this->birecordsbyregion)) {
 866              // No blocks or block regions exist yet.
 867              return;
 868          }
 869  
 870          if ($blockregion === null) {
 871              $defaulregion = $this->get_default_region();
 872          } else {
 873              $defaulregion = $blockregion;
 874          }
 875  
 876          $lastcurrentblock = end($this->birecordsbyregion[$defaulregion]);
 877          if ($lastcurrentblock) {
 878              $weight = $lastcurrentblock->weight + 1;
 879          } else {
 880              $weight = 0;
 881          }
 882  
 883          if ($this->page->subpage) {
 884              $subpage = $this->page->subpage;
 885          } else {
 886              $subpage = null;
 887          }
 888  
 889          // Special case. Course view page type include the course format, but we
 890          // want to add the block non-format-specifically.
 891          $pagetypepattern = $this->page->pagetype;
 892          if (strpos($pagetypepattern, 'course-view') === 0) {
 893              $pagetypepattern = 'course-view-*';
 894          }
 895  
 896          // We should end using this for ALL the blocks, making always the 1st option
 897          // the default one to be used. Until then, this is one hack to avoid the
 898          // 'pagetypewarning' message on blocks initial edition (MDL-27829) caused by
 899          // non-existing $pagetypepattern set. This way at least we guarantee one "valid"
 900          // (the FIRST $pagetypepattern will be set)
 901  
 902          // We are applying it to all blocks created in mod pages for now and only if the
 903          // default pagetype is not one of the available options
 904          if (preg_match('/^mod-.*-/', $pagetypepattern)) {
 905              $pagetypelist = generate_page_type_patterns($this->page->pagetype, null, $this->page->context);
 906              // Only go for the first if the pagetype is not a valid option
 907              if (is_array($pagetypelist) && !array_key_exists($pagetypepattern, $pagetypelist)) {
 908                  $pagetypepattern = key($pagetypelist);
 909              }
 910          }
 911          // Surely other pages like course-report will need this too, they just are not important
 912          // enough now. This will be decided in the coming days. (MDL-27829, MDL-28150)
 913  
 914          $this->add_block($blockname, $defaulregion, $weight, false, $pagetypepattern, $subpage);
 915      }
 916  
 917      /**
 918       * Convenience method, calls add_block repeatedly for all the blocks in $blocks. Optionally, a starting weight
 919       * can be used to decide the starting point that blocks are added in the region, the weight is passed to {@link add_block}
 920       * and incremented by the position of the block in the $blocks array
 921       *
 922       * @param array $blocks array with array keys the region names, and values an array of block names.
 923       * @param string $pagetypepattern optional. Passed to {@link add_block()}
 924       * @param string $subpagepattern optional. Passed to {@link add_block()}
 925       * @param boolean $showinsubcontexts optional. Passed to {@link add_block()}
 926       * @param integer $weight optional. Determines the starting point that the blocks are added in the region.
 927       */
 928      public function add_blocks($blocks, $pagetypepattern = NULL, $subpagepattern = NULL, $showinsubcontexts=false, $weight=0) {
 929          $initialweight = $weight;
 930          $this->add_regions(array_keys($blocks), false);
 931          foreach ($blocks as $region => $regionblocks) {
 932              foreach ($regionblocks as $offset => $blockname) {
 933                  $weight = $initialweight + $offset;
 934                  $this->add_block($blockname, $region, $weight, $showinsubcontexts, $pagetypepattern, $subpagepattern);
 935              }
 936          }
 937      }
 938  
 939      /**
 940       * Move a block to a new position on this page.
 941       *
 942       * If this block cannot appear on any other pages, then we change defaultposition/weight
 943       * in the block_instances table. Otherwise we just set the position on this page.
 944       *
 945       * @param $blockinstanceid the block instance id.
 946       * @param $newregion the new region name.
 947       * @param $newweight the new weight.
 948       */
 949      public function reposition_block($blockinstanceid, $newregion, $newweight) {
 950          global $DB;
 951  
 952          $this->check_region_is_known($newregion);
 953          $inst = $this->find_instance($blockinstanceid);
 954  
 955          $bi = $inst->instance;
 956          if ($bi->weight == $bi->defaultweight && $bi->region == $bi->defaultregion &&
 957                  !$bi->showinsubcontexts && strpos($bi->pagetypepattern, '*') === false &&
 958                  (!$this->page->subpage || $bi->subpagepattern)) {
 959  
 960              // Set default position
 961              $newbi = new stdClass;
 962              $newbi->id = $bi->id;
 963              $newbi->defaultregion = $newregion;
 964              $newbi->defaultweight = $newweight;
 965              $newbi->timemodified = time();
 966              $DB->update_record('block_instances', $newbi);
 967  
 968              if ($bi->blockpositionid) {
 969                  $bp = new stdClass;
 970                  $bp->id = $bi->blockpositionid;
 971                  $bp->region = $newregion;
 972                  $bp->weight = $newweight;
 973                  $DB->update_record('block_positions', $bp);
 974              }
 975  
 976          } else {
 977              // Just set position on this page.
 978              $bp = new stdClass;
 979              $bp->region = $newregion;
 980              $bp->weight = $newweight;
 981  
 982              if ($bi->blockpositionid) {
 983                  $bp->id = $bi->blockpositionid;
 984                  $DB->update_record('block_positions', $bp);
 985  
 986              } else {
 987                  $bp->blockinstanceid = $bi->id;
 988                  $bp->contextid = $this->page->context->id;
 989                  $bp->pagetype = $this->page->pagetype;
 990                  if ($this->page->subpage) {
 991                      $bp->subpage = $this->page->subpage;
 992                  } else {
 993                      $bp->subpage = '';
 994                  }
 995                  $bp->visible = $bi->visible;
 996                  $DB->insert_record('block_positions', $bp);
 997              }
 998          }
 999      }
1000  
1001      /**
1002       * Find a given block by its instance id
1003       *
1004       * @param integer $instanceid
1005       * @return block_base
1006       */
1007      public function find_instance($instanceid) {
1008          foreach ($this->regions as $region => $notused) {
1009              $this->ensure_instances_exist($region);
1010              foreach($this->blockinstances[$region] as $instance) {
1011                  if ($instance->instance->id == $instanceid) {
1012                      return $instance;
1013                  }
1014              }
1015          }
1016          throw new block_not_on_page_exception($instanceid, $this->page);
1017      }
1018  
1019  /// Inner workings =============================================================
1020  
1021      /**
1022       * Check whether the page blocks have been loaded yet
1023       *
1024       * @return void Throws coding exception if already loaded
1025       */
1026      protected function check_not_yet_loaded() {
1027          if (!is_null($this->birecordsbyregion)) {
1028              throw new coding_exception('block_manager has already loaded the blocks, to it is too late to change things that might affect which blocks are visible.');
1029          }
1030      }
1031  
1032      /**
1033       * Check whether the page blocks have been loaded yet
1034       *
1035       * Nearly identical to the above function {@link check_not_yet_loaded()} except different message
1036       *
1037       * @return void Throws coding exception if already loaded
1038       */
1039      protected function check_is_loaded() {
1040          if (is_null($this->birecordsbyregion)) {
1041              throw new coding_exception('block_manager has not yet loaded the blocks, to it is too soon to request the information you asked for.');
1042          }
1043      }
1044  
1045      /**
1046       * Check if a block type is known and usable
1047       *
1048       * @param string $blockname The block type name to search for
1049       * @param bool $includeinvisible Include disabled block types in the initial pass
1050       * @return void Coding Exception thrown if unknown or not enabled
1051       */
1052      protected function check_known_block_type($blockname, $includeinvisible = false) {
1053          if (!$this->is_known_block_type($blockname, $includeinvisible)) {
1054              if ($this->is_known_block_type($blockname, true)) {
1055                  throw new coding_exception('Unknown block type ' . $blockname);
1056              } else {
1057                  throw new coding_exception('Block type ' . $blockname . ' has been disabled by the administrator.');
1058              }
1059          }
1060      }
1061  
1062      /**
1063       * Check if a region is known by its name
1064       *
1065       * @param string $region
1066       * @return void Coding Exception thrown if the region is not known
1067       */
1068      protected function check_region_is_known($region) {
1069          if (!$this->is_known_region($region)) {
1070              throw new coding_exception('Trying to reference an unknown block region ' . $region);
1071          }
1072      }
1073  
1074      /**
1075       * Returns an array of region names as keys and nested arrays for values
1076       *
1077       * @return array an array where the array keys are the region names, and the array
1078       * values are empty arrays.
1079       */
1080      protected function prepare_per_region_arrays() {
1081          $result = array();
1082          foreach ($this->regions as $region => $notused) {
1083              $result[$region] = array();
1084          }
1085          return $result;
1086      }
1087  
1088      /**
1089       * Create a set of new block instance from a record array
1090       *
1091       * @param array $birecords An array of block instance records
1092       * @return array An array of instantiated block_instance objects
1093       */
1094      protected function create_block_instances($birecords) {
1095          $results = array();
1096          foreach ($birecords as $record) {
1097              if ($blockobject = block_instance($record->blockname, $record, $this->page)) {
1098                  $results[] = $blockobject;
1099              }
1100          }
1101          return $results;
1102      }
1103  
1104      /**
1105       * Create all the block instances for all the blocks that were loaded by
1106       * load_blocks. This is used, for example, to ensure that all blocks get a
1107       * chance to initialise themselves via the {@link block_base::specialize()}
1108       * method, before any output is done.
1109       *
1110       * It is also used to create any blocks that are "requiredbytheme" by the current theme.
1111       * These blocks that are auto-created have requiredbytheme set on the block instance
1112       * so they are only visible on themes that require them.
1113       */
1114      public function create_all_block_instances() {
1115          $missing = false;
1116  
1117          // If there are any un-removable blocks that were not created - force them.
1118          $requiredbytheme = $this->get_required_by_theme_block_types();
1119          if (!$this->fakeblocksonly) {
1120              foreach ($requiredbytheme as $forced) {
1121                  if (empty($forced)) {
1122                      continue;
1123                  }
1124                  $found = false;
1125                  foreach ($this->get_regions() as $region) {
1126                      foreach($this->birecordsbyregion[$region] as $instance) {
1127                          if ($instance->blockname == $forced) {
1128                              $found = true;
1129                          }
1130                      }
1131                  }
1132                  if (!$found) {
1133                      $this->add_block_required_by_theme($forced);
1134                      $missing = true;
1135                  }
1136              }
1137          }
1138  
1139          if ($missing) {
1140              // Some blocks were missing. Lets do it again.
1141              $this->birecordsbyregion = null;
1142              $this->load_blocks();
1143          }
1144          foreach ($this->get_regions() as $region) {
1145              $this->ensure_instances_exist($region);
1146          }
1147  
1148      }
1149  
1150      /**
1151       * Add a block that is required by the current theme but has not been
1152       * created yet. This is a special type of block that only shows in themes that
1153       * require it (by listing it in undeletable_block_types).
1154       *
1155       * @param string $blockname the name of the block type.
1156       */
1157      protected function add_block_required_by_theme($blockname) {
1158          global $DB;
1159  
1160          if (empty($this->birecordsbyregion)) {
1161              // No blocks or block regions exist yet.
1162              return;
1163          }
1164  
1165          // Never auto create blocks when we are showing fake blocks only.
1166          if ($this->fakeblocksonly) {
1167              return;
1168          }
1169  
1170          // Never add a duplicate block required by theme.
1171          if ($DB->record_exists('block_instances', array('blockname' => $blockname, 'requiredbytheme' => 1))) {
1172              return;
1173          }
1174  
1175          $systemcontext = context_system::instance();
1176          $defaultregion = $this->get_default_region();
1177          // Add a special system wide block instance only for themes that require it.
1178          $blockinstance = new stdClass;
1179          $blockinstance->blockname = $blockname;
1180          $blockinstance->parentcontextid = $systemcontext->id;
1181          $blockinstance->showinsubcontexts = true;
1182          $blockinstance->requiredbytheme = true;
1183          $blockinstance->pagetypepattern = '*';
1184          $blockinstance->subpagepattern = null;
1185          $blockinstance->defaultregion = $defaultregion;
1186          $blockinstance->defaultweight = 0;
1187          $blockinstance->configdata = '';
1188          $blockinstance->timecreated = time();
1189          $blockinstance->timemodified = $blockinstance->timecreated;
1190          $blockinstance->id = $DB->insert_record('block_instances', $blockinstance);
1191  
1192          // Ensure the block context is created.
1193          context_block::instance($blockinstance->id);
1194  
1195          // If the new instance was created, allow it to do additional setup.
1196          if ($block = block_instance($blockname, $blockinstance)) {
1197              $block->instance_create();
1198          }
1199      }
1200  
1201      /**
1202       * Return an array of content objects from a set of block instances
1203       *
1204       * @param array $instances An array of block instances
1205       * @param renderer_base The renderer to use.
1206       * @param string $region the region name.
1207       * @return array An array of block_content (and possibly block_move_target) objects.
1208       */
1209      protected function create_block_contents($instances, $output, $region) {
1210          $results = array();
1211  
1212          $lastweight = 0;
1213          $lastblock = 0;
1214          if ($this->movingblock) {
1215              $first = reset($instances);
1216              if ($first) {
1217                  $lastweight = $first->instance->weight - 2;
1218              }
1219          }
1220  
1221          foreach ($instances as $instance) {
1222              $content = $instance->get_content_for_output($output);
1223              if (empty($content)) {
1224                  continue;
1225              }
1226  
1227              if ($this->movingblock && $lastweight != $instance->instance->weight &&
1228                      $content->blockinstanceid != $this->movingblock && $lastblock != $this->movingblock) {
1229                  $results[] = new block_move_target($this->get_move_target_url($region, ($lastweight + $instance->instance->weight)/2));
1230              }
1231  
1232              if ($content->blockinstanceid == $this->movingblock) {
1233                  $content->add_class('beingmoved');
1234                  $content->annotation .= get_string('movingthisblockcancel', 'block',
1235                          html_writer::link($this->page->url, get_string('cancel')));
1236              }
1237  
1238              $results[] = $content;
1239              $lastweight = $instance->instance->weight;
1240              $lastblock = $instance->instance->id;
1241          }
1242  
1243          if ($this->movingblock && $lastblock != $this->movingblock) {
1244              $results[] = new block_move_target($this->get_move_target_url($region, $lastweight + 1));
1245          }
1246          return $results;
1247      }
1248  
1249      /**
1250       * Ensure block instances exist for a given region
1251       *
1252       * @param string $region Check for bi's with the instance with this name
1253       */
1254      protected function ensure_instances_exist($region) {
1255          $this->check_region_is_known($region);
1256          if (!array_key_exists($region, $this->blockinstances)) {
1257              $this->blockinstances[$region] =
1258                      $this->create_block_instances($this->birecordsbyregion[$region]);
1259          }
1260      }
1261  
1262      /**
1263       * Ensure that there is some content within the given region
1264       *
1265       * @param string $region The name of the region to check
1266       */
1267      public function ensure_content_created($region, $output) {
1268          $this->ensure_instances_exist($region);
1269  
1270          if (!has_capability('moodle/block:view', $this->page->context) ) {
1271              $this->visibleblockcontent[$region] = [];
1272              return;
1273          }
1274  
1275          if (!array_key_exists($region, $this->visibleblockcontent)) {
1276              $contents = array();
1277              if (array_key_exists($region, $this->extracontent)) {
1278                  $contents = $this->extracontent[$region];
1279              }
1280              $contents = array_merge($contents, $this->create_block_contents($this->blockinstances[$region], $output, $region));
1281              if (($region == $this->defaultregion) && (!isset($this->page->theme->addblockposition) ||
1282                      $this->page->theme->addblockposition == BLOCK_ADDBLOCK_POSITION_DEFAULT)) {
1283                  $addblockui = block_add_block_ui($this->page, $output);
1284                  if ($addblockui) {
1285                      $contents[] = $addblockui;
1286                  }
1287              }
1288              $this->visibleblockcontent[$region] = $contents;
1289          }
1290      }
1291  
1292  /// Process actions from the URL ===============================================
1293  
1294      /**
1295       * Get the appropriate list of editing icons for a block. This is used
1296       * to set {@link block_contents::$controls} in {@link block_base::get_contents_for_output()}.
1297       *
1298       * @param $output The core_renderer to use when generating the output. (Need to get icon paths.)
1299       * @return an array in the format for {@link block_contents::$controls}
1300       */
1301      public function edit_controls($block) {
1302          global $CFG;
1303  
1304          $controls = array();
1305          $actionurl = $this->page->url->out(false, array('sesskey'=> sesskey()));
1306          $blocktitle = $block->title;
1307          if (empty($blocktitle)) {
1308              $blocktitle = $block->arialabel;
1309          }
1310  
1311          if ($this->page->user_can_edit_blocks()) {
1312              // Move icon.
1313              $str = new lang_string('moveblock', 'block', $blocktitle);
1314              $controls[] = new action_menu_link_primary(
1315                  new moodle_url($actionurl, array('bui_moveid' => $block->instance->id)),
1316                  new pix_icon('t/move', $str, 'moodle', array('class' => 'iconsmall', 'title' => '')),
1317                  $str,
1318                  array('class' => 'editing_move')
1319              );
1320  
1321          }
1322  
1323          if ($this->page->user_can_edit_blocks() || $block->user_can_edit()) {
1324              // Edit config icon - always show - needed for positioning UI.
1325              $str = new lang_string('configureblock', 'block', $blocktitle);
1326              $editactionurl = new moodle_url($actionurl, ['bui_editid' => $block->instance->id]);
1327              $editactionurl->remove_params(['sesskey']);
1328  
1329              // Handle editing block on admin index page, prevent the page redirecting before block action can begin.
1330              if ($editactionurl->compare(new moodle_url('/admin/index.php'), URL_MATCH_BASE)) {
1331                  $editactionurl->param('cache', 1);
1332              }
1333  
1334              $controls[] = new action_menu_link_secondary(
1335                  $editactionurl,
1336                  new pix_icon('t/edit', $str, 'moodle', array('class' => 'iconsmall', 'title' => '')),
1337                  $str,
1338                  array('class' => 'editing_edit')
1339              );
1340  
1341          }
1342  
1343          if ($this->page->user_can_edit_blocks() && $block->instance_can_be_hidden()) {
1344              // Show/hide icon.
1345              if ($block->instance->visible) {
1346                  $str = new lang_string('hideblock', 'block', $blocktitle);
1347                  $url = new moodle_url($actionurl, array('bui_hideid' => $block->instance->id));
1348                  $icon = new pix_icon('t/hide', $str, 'moodle', array('class' => 'iconsmall', 'title' => ''));
1349                  $attributes = array('class' => 'editing_hide');
1350              } else {
1351                  $str = new lang_string('showblock', 'block', $blocktitle);
1352                  $url = new moodle_url($actionurl, array('bui_showid' => $block->instance->id));
1353                  $icon = new pix_icon('t/show', $str, 'moodle', array('class' => 'iconsmall', 'title' => ''));
1354                  $attributes = array('class' => 'editing_show');
1355              }
1356              $controls[] = new action_menu_link_secondary($url, $icon, $str, $attributes);
1357          }
1358  
1359          // Assign roles.
1360          if (get_assignable_roles($block->context, ROLENAME_SHORT)) {
1361              $rolesurl = new moodle_url('/admin/roles/assign.php', array('contextid' => $block->context->id,
1362                  'returnurl' => $this->page->url->out_as_local_url()));
1363              $str = new lang_string('assignrolesinblock', 'block', $blocktitle);
1364              $controls[] = new action_menu_link_secondary(
1365                  $rolesurl,
1366                  new pix_icon('i/assignroles', $str, 'moodle', array('class' => 'iconsmall', 'title' => '')),
1367                  $str, array('class' => 'editing_assignroles')
1368              );
1369          }
1370  
1371          // Permissions.
1372          if (has_capability('moodle/role:review', $block->context) or get_overridable_roles($block->context)) {
1373              $rolesurl = new moodle_url('/admin/roles/permissions.php', array('contextid' => $block->context->id,
1374                  'returnurl' => $this->page->url->out_as_local_url()));
1375              $str = get_string('permissions', 'role');
1376              $controls[] = new action_menu_link_secondary(
1377                  $rolesurl,
1378                  new pix_icon('i/permissions', $str, 'moodle', array('class' => 'iconsmall', 'title' => '')),
1379                  $str, array('class' => 'editing_permissions')
1380              );
1381          }
1382  
1383          // Change permissions.
1384          if (has_any_capability(array('moodle/role:safeoverride', 'moodle/role:override', 'moodle/role:assign'), $block->context)) {
1385              $rolesurl = new moodle_url('/admin/roles/check.php', array('contextid' => $block->context->id,
1386                  'returnurl' => $this->page->url->out_as_local_url()));
1387              $str = get_string('checkpermissions', 'role');
1388              $controls[] = new action_menu_link_secondary(
1389                  $rolesurl,
1390                  new pix_icon('i/checkpermissions', $str, 'moodle', array('class' => 'iconsmall', 'title' => '')),
1391                  $str, array('class' => 'editing_checkroles')
1392              );
1393          }
1394  
1395          if ($this->user_can_delete_block($block)) {
1396              // Delete icon.
1397              $str = new lang_string('deleteblock', 'block', $blocktitle);
1398              $deleteactionurl = new moodle_url($actionurl, ['bui_deleteid' => $block->instance->id]);
1399              $deleteactionurl->remove_params(['sesskey']);
1400  
1401              // Handle deleting block on admin index page, prevent the page redirecting before block action can begin.
1402              if ($deleteactionurl->compare(new moodle_url('/admin/index.php'), URL_MATCH_BASE)) {
1403                  $deleteactionurl->param('cache', 1);
1404              }
1405  
1406              $deleteconfirmationurl = new moodle_url($actionurl, [
1407                  'bui_deleteid' => $block->instance->id,
1408                  'bui_confirm' => 1,
1409                  'sesskey' => sesskey(),
1410              ]);
1411              $blocktitle = $block->get_title();
1412  
1413              $controls[] = new action_menu_link_secondary(
1414                  $deleteactionurl,
1415                  new pix_icon('t/delete', $str, 'moodle', array('class' => 'iconsmall', 'title' => '')),
1416                  $str,
1417                  [
1418                      'class' => 'editing_delete',
1419                      'data-modal' => 'confirmation',
1420                      'data-modal-title-str' => json_encode(['deletecheck_modal', 'block']),
1421                      'data-modal-content-str' => json_encode(['deleteblockcheck', 'block', $blocktitle]),
1422                      'data-modal-yes-button-str' => json_encode(['delete', 'core']),
1423                      'data-modal-toast' => 'true',
1424                      'data-modal-toast-confirmation-str' => json_encode(['deleteblockinprogress', 'block', $blocktitle]),
1425                      'data-modal-destination' => $deleteconfirmationurl->out(false),
1426                  ]
1427              );
1428          }
1429  
1430          if (!empty($CFG->contextlocking) && has_capability('moodle/site:managecontextlocks', $block->context)) {
1431              $parentcontext = $block->context->get_parent_context();
1432              if (empty($parentcontext) || empty($parentcontext->locked)) {
1433                  if ($block->context->locked) {
1434                      $lockicon = 'i/unlock';
1435                      $lockstring = get_string('managecontextunlock', 'admin');
1436                  } else {
1437                      $lockicon = 'i/lock';
1438                      $lockstring = get_string('managecontextlock', 'admin');
1439                  }
1440                  $controls[] = new action_menu_link_secondary(
1441                      new moodle_url(
1442                          '/admin/lock.php',
1443                          [
1444                              'id' => $block->context->id,
1445                          ]
1446                      ),
1447                      new pix_icon($lockicon, $lockstring, 'moodle', array('class' => 'iconsmall', 'title' => '')),
1448                      $lockstring,
1449                      ['class' => 'editing_lock']
1450                  );
1451              }
1452          }
1453  
1454          return $controls;
1455      }
1456  
1457      /**
1458       * @param block_base $block a block that appears on this page.
1459       * @return boolean boolean whether the currently logged in user is allowed to delete this block.
1460       */
1461      protected function user_can_delete_block($block) {
1462          return $this->page->user_can_edit_blocks() && $block->user_can_edit() &&
1463                  $block->user_can_addto($this->page) &&
1464                  !in_array($block->instance->blockname, self::get_undeletable_block_types()) &&
1465                  !in_array($block->instance->blockname, $this->get_required_by_theme_block_types());
1466      }
1467  
1468      /**
1469       * Process any block actions that were specified in the URL.
1470       *
1471       * @return boolean true if anything was done. False if not.
1472       */
1473      public function process_url_actions() {
1474          if (!$this->page->user_is_editing()) {
1475              return false;
1476          }
1477          return $this->process_url_add() || $this->process_url_delete() ||
1478              $this->process_url_show_hide() || $this->process_url_edit() ||
1479              $this->process_url_move();
1480      }
1481  
1482      /**
1483       * Handle adding a block.
1484       * @return boolean true if anything was done. False if not.
1485       */
1486      public function process_url_add() {
1487          global $CFG, $PAGE, $OUTPUT;
1488  
1489          $blocktype = optional_param('bui_addblock', null, PARAM_PLUGIN);
1490          $blockregion = optional_param('bui_blockregion', null, PARAM_TEXT);
1491  
1492          if ($blocktype === null) {
1493              return false;
1494          }
1495  
1496          require_sesskey();
1497  
1498          if (!$this->page->user_can_edit_blocks()) {
1499              throw new moodle_exception('nopermissions', '', $this->page->url->out(), get_string('addblock'));
1500          }
1501  
1502          $addableblocks = $this->get_addable_blocks();
1503  
1504          if ($blocktype === '') {
1505              // Display add block selection.
1506              $addpage = new moodle_page();
1507              $addpage->set_pagelayout('admin');
1508              $addpage->blocks->show_only_fake_blocks(true);
1509              $addpage->set_course($this->page->course);
1510              $addpage->set_context($this->page->context);
1511              if ($this->page->cm) {
1512                  $addpage->set_cm($this->page->cm);
1513              }
1514  
1515              $addpagebase = str_replace($CFG->wwwroot . '/', '/', $this->page->url->out_omit_querystring());
1516              $addpageparams = $this->page->url->params();
1517              $addpage->set_url($addpagebase, $addpageparams);
1518              $addpage->set_block_actions_done();
1519              // At this point we are going to display the block selector, overwrite global $PAGE ready for this.
1520              $PAGE = $addpage;
1521              // Some functions use $OUTPUT so we need to replace that too.
1522              $OUTPUT = $addpage->get_renderer('core');
1523  
1524              $site = get_site();
1525              $straddblock = get_string('addblock');
1526  
1527              $PAGE->navbar->add($straddblock);
1528              $PAGE->set_title($straddblock);
1529              $PAGE->set_heading($site->fullname);
1530              echo $OUTPUT->header();
1531              echo $OUTPUT->heading($straddblock);
1532  
1533              if (!$addableblocks) {
1534                  echo $OUTPUT->box(get_string('noblockstoaddhere'));
1535                  echo $OUTPUT->container($OUTPUT->action_link($addpage->url, get_string('back')), 'mx-3 mb-1');
1536              } else {
1537                  $url = new moodle_url($addpage->url, array('sesskey' => sesskey()));
1538                  echo $OUTPUT->render_from_template('core/add_block_body',
1539                      ['blocks' => array_values($addableblocks),
1540                       'url' => '?' . $url->get_query_string(false)]);
1541                  echo $OUTPUT->container($OUTPUT->action_link($addpage->url, get_string('cancel')), 'mx-3 mb-1');
1542              }
1543  
1544              echo $OUTPUT->footer();
1545              // Make sure that nothing else happens after we have displayed this form.
1546              exit;
1547          }
1548  
1549          if (!array_key_exists($blocktype, $addableblocks)) {
1550              throw new moodle_exception('cannotaddthisblocktype', '', $this->page->url->out(), $blocktype);
1551          }
1552  
1553          $this->add_block_at_end_of_default_region($blocktype, $blockregion);
1554  
1555          // If the page URL was a guess, it will contain the bui_... param, so we must make sure it is not there.
1556          $this->page->ensure_param_not_in_url('bui_addblock');
1557  
1558          return true;
1559      }
1560  
1561      /**
1562       * Handle deleting a block.
1563       * @return boolean true if anything was done. False if not.
1564       */
1565      public function process_url_delete() {
1566          global $CFG, $PAGE, $OUTPUT;
1567  
1568          $blockid = optional_param('bui_deleteid', null, PARAM_INT);
1569          $confirmdelete = optional_param('bui_confirm', null, PARAM_INT);
1570  
1571          if (!$blockid) {
1572              return false;
1573          }
1574  
1575          $block = $this->page->blocks->find_instance($blockid);
1576          if (!$this->user_can_delete_block($block)) {
1577              throw new moodle_exception('nopermissions', '', $this->page->url->out(), get_string('deleteablock'));
1578          }
1579  
1580          if (!$confirmdelete) {
1581              $deletepage = new moodle_page();
1582              $deletepage->set_pagelayout('admin');
1583              $deletepage->blocks->show_only_fake_blocks(true);
1584              $deletepage->set_course($this->page->course);
1585              $deletepage->set_context($this->page->context);
1586              if ($this->page->cm) {
1587                  $deletepage->set_cm($this->page->cm);
1588              }
1589  
1590              $deleteurlbase = str_replace($CFG->wwwroot . '/', '/', $this->page->url->out_omit_querystring());
1591              $deleteurlparams = $this->page->url->params();
1592              $deletepage->set_url($deleteurlbase, $deleteurlparams);
1593              $deletepage->set_block_actions_done();
1594              $deletepage->set_secondarynav($this->get_secondarynav($block));
1595              // At this point we are either going to redirect, or display the form, so
1596              // overwrite global $PAGE ready for this. (Formslib refers to it.)
1597              $PAGE = $deletepage;
1598              //some functions like MoodleQuickForm::addHelpButton use $OUTPUT so we need to replace that too
1599              $output = $deletepage->get_renderer('core');
1600              $OUTPUT = $output;
1601  
1602              $site = get_site();
1603              $blocktitle = $block->get_title();
1604              $strdeletecheck = get_string('deletecheck', 'block', $blocktitle);
1605              $message = get_string('deleteblockcheck', 'block', $blocktitle);
1606  
1607              // If the block is being shown in sub contexts display a warning.
1608              if ($block->instance->showinsubcontexts == 1) {
1609                  $parentcontext = context::instance_by_id($block->instance->parentcontextid);
1610                  $systemcontext = context_system::instance();
1611                  $messagestring = new stdClass();
1612                  $messagestring->location = $parentcontext->get_context_name();
1613  
1614                  // Checking for blocks that may have visibility on the front page and pages added on that.
1615                  if ($parentcontext->id != $systemcontext->id && is_inside_frontpage($parentcontext)) {
1616                      $messagestring->pagetype = get_string('showonfrontpageandsubs', 'block');
1617                  } else {
1618                      $pagetypes = generate_page_type_patterns($this->page->pagetype, $parentcontext);
1619                      $messagestring->pagetype = $block->instance->pagetypepattern;
1620                      if (isset($pagetypes[$block->instance->pagetypepattern])) {
1621                          $messagestring->pagetype = $pagetypes[$block->instance->pagetypepattern];
1622                      }
1623                  }
1624  
1625                  $message = get_string('deleteblockwarning', 'block', $messagestring);
1626              }
1627  
1628              $PAGE->navbar->add($strdeletecheck);
1629              $PAGE->set_title($blocktitle . ': ' . $strdeletecheck);
1630              $PAGE->set_heading($site->fullname);
1631              echo $OUTPUT->header();
1632              $confirmurl = new moodle_url($deletepage->url, array('sesskey' => sesskey(), 'bui_deleteid' => $block->instance->id, 'bui_confirm' => 1));
1633              $cancelurl = new moodle_url($deletepage->url);
1634              $yesbutton = new single_button($confirmurl, get_string('yes'));
1635              $nobutton = new single_button($cancelurl, get_string('no'));
1636              echo $OUTPUT->confirm($message, $yesbutton, $nobutton);
1637              echo $OUTPUT->footer();
1638              // Make sure that nothing else happens after we have displayed this form.
1639              exit;
1640          } else {
1641              require_sesskey();
1642  
1643              blocks_delete_instance($block->instance);
1644              // bui_deleteid and bui_confirm should not be in the PAGE url.
1645              $this->page->ensure_param_not_in_url('bui_deleteid');
1646              $this->page->ensure_param_not_in_url('bui_confirm');
1647              return true;
1648          }
1649      }
1650  
1651      /**
1652       * Handle showing or hiding a block.
1653       * @return boolean true if anything was done. False if not.
1654       */
1655      public function process_url_show_hide() {
1656          if ($blockid = optional_param('bui_hideid', null, PARAM_INT)) {
1657              $newvisibility = 0;
1658          } else if ($blockid = optional_param('bui_showid', null, PARAM_INT)) {
1659              $newvisibility = 1;
1660          } else {
1661              return false;
1662          }
1663  
1664          require_sesskey();
1665  
1666          $block = $this->page->blocks->find_instance($blockid);
1667  
1668          if (!$this->page->user_can_edit_blocks()) {
1669              throw new moodle_exception('nopermissions', '', $this->page->url->out(), get_string('hideshowblocks'));
1670          } else if (!$block->instance_can_be_hidden()) {
1671              return false;
1672          }
1673  
1674          blocks_set_visibility($block->instance, $this->page, $newvisibility);
1675  
1676          // If the page URL was a guses, it will contain the bui_... param, so we must make sure it is not there.
1677          $this->page->ensure_param_not_in_url('bui_hideid');
1678          $this->page->ensure_param_not_in_url('bui_showid');
1679  
1680          return true;
1681      }
1682  
1683      /**
1684       * Convenience function to check whether a block is implementing a secondary nav class and return it
1685       * initialised to the calling function
1686       *
1687       * @param block_base $block
1688       * @return \core\navigation\views\secondary
1689       */
1690      protected function get_secondarynav(block_base $block): \core\navigation\views\secondary {
1691          $class = "core_block\\navigation\\views\\secondary";
1692          if (class_exists("block_{$block->name()}\\navigation\\views\\secondary")) {
1693              $class = "block_{$block->name()}\\navigation\\views\\secondary";
1694          } else if (class_exists("block_{$block->name()}\\local\\views\\secondary")) {
1695              // For backwards compatibility, support the old location for this class (it was in a
1696              // 'local' namespace which shouldn't be used for core APIs).
1697              $class = "block_{$block->name()}\\local\\views\\secondary";
1698          }
1699          $secondarynav = new $class($this->page);
1700          $secondarynav->initialise();
1701          return $secondarynav;
1702      }
1703  
1704      /**
1705       * Handle showing/processing the submission from the block editing form.
1706       * @return boolean true if the form was submitted and the new config saved. Does not
1707       *      return if the editing form was displayed. False otherwise.
1708       */
1709      public function process_url_edit() {
1710          global $CFG, $DB, $PAGE, $OUTPUT;
1711  
1712          $blockid = optional_param('bui_editid', null, PARAM_INT);
1713          if (!$blockid) {
1714              return false;
1715          }
1716  
1717          require_once($CFG->dirroot . '/blocks/edit_form.php');
1718  
1719          $block = $this->find_instance($blockid);
1720  
1721          if (!$block->user_can_edit() && !$this->page->user_can_edit_blocks()) {
1722              throw new moodle_exception('nopermissions', '', $this->page->url->out(), get_string('editblock'));
1723          }
1724  
1725          $editpage = new moodle_page();
1726          $editpage->set_pagelayout('admin');
1727          $editpage->blocks->show_only_fake_blocks(true);
1728          $editpage->set_course($this->page->course);
1729          //$editpage->set_context($block->context);
1730          $editpage->set_context($this->page->context);
1731          $editpage->set_secondarynav($this->get_secondarynav($block));
1732  
1733          if ($this->page->cm) {
1734              $editpage->set_cm($this->page->cm);
1735          }
1736          $editurlbase = str_replace($CFG->wwwroot . '/', '/', $this->page->url->out_omit_querystring());
1737          $editurlparams = $this->page->url->params();
1738          $editurlparams['bui_editid'] = $blockid;
1739          $editpage->set_url($editurlbase, $editurlparams);
1740          $editpage->set_block_actions_done();
1741          // At this point we are either going to redirect, or display the form, so
1742          // overwrite global $PAGE ready for this. (Formslib refers to it.)
1743          $PAGE = $editpage;
1744          //some functions like MoodleQuickForm::addHelpButton use $OUTPUT so we need to replace that to
1745          $output = $editpage->get_renderer('core');
1746          $OUTPUT = $output;
1747  
1748          $formfile = $CFG->dirroot . '/blocks/' . $block->name() . '/edit_form.php';
1749          if (is_readable($formfile)) {
1750              require_once($formfile);
1751              $classname = 'block_' . $block->name() . '_edit_form';
1752              if (!class_exists($classname)) {
1753                  $classname = 'block_edit_form';
1754              }
1755          } else {
1756              $classname = 'block_edit_form';
1757          }
1758  
1759          $mform = new $classname($editpage->url, $block, $this->page);
1760          $mform->set_data($block->instance);
1761  
1762          if ($mform->is_cancelled()) {
1763              redirect($this->page->url);
1764  
1765          } else if ($data = $mform->get_data()) {
1766              $bi = new stdClass;
1767              $bi->id = $block->instance->id;
1768  
1769              // This may get overwritten by the special case handling below.
1770              $bi->pagetypepattern = $data->bui_pagetypepattern;
1771              $bi->showinsubcontexts = (bool) $data->bui_contexts;
1772              if (empty($data->bui_subpagepattern) || $data->bui_subpagepattern == '%@NULL@%') {
1773                  $bi->subpagepattern = null;
1774              } else {
1775                  $bi->subpagepattern = $data->bui_subpagepattern;
1776              }
1777  
1778              $systemcontext = context_system::instance();
1779              $frontpagecontext = context_course::instance(SITEID);
1780              $parentcontext = context::instance_by_id($data->bui_parentcontextid);
1781  
1782              // Updating stickiness and contexts.  See MDL-21375 for details.
1783              if (has_capability('moodle/site:manageblocks', $parentcontext)) { // Check permissions in destination
1784  
1785                  // Explicitly set the default context
1786                  $bi->parentcontextid = $parentcontext->id;
1787  
1788                  if ($data->bui_editingatfrontpage) {   // The block is being edited on the front page
1789  
1790                      // The interface here is a special case because the pagetype pattern is
1791                      // totally derived from the context menu.  Here are the excpetions.   MDL-30340
1792  
1793                      switch ($data->bui_contexts) {
1794                          case BUI_CONTEXTS_ENTIRE_SITE:
1795                              // The user wants to show the block across the entire site
1796                              $bi->parentcontextid = $systemcontext->id;
1797                              $bi->showinsubcontexts = true;
1798                              $bi->pagetypepattern  = '*';
1799                              break;
1800                          case BUI_CONTEXTS_FRONTPAGE_SUBS:
1801                              // The user wants the block shown on the front page and all subcontexts
1802                              $bi->parentcontextid = $frontpagecontext->id;
1803                              $bi->showinsubcontexts = true;
1804                              $bi->pagetypepattern  = '*';
1805                              break;
1806                          case BUI_CONTEXTS_FRONTPAGE_ONLY:
1807                              // The user want to show the front page on the frontpage only
1808                              $bi->parentcontextid = $frontpagecontext->id;
1809                              $bi->showinsubcontexts = false;
1810                              $bi->pagetypepattern  = 'site-index';
1811                              // This is the only relevant page type anyway but we'll set it explicitly just
1812                              // in case the front page grows site-index-* subpages of its own later
1813                              break;
1814                      }
1815                  }
1816              }
1817  
1818              $bits = explode('-', $bi->pagetypepattern);
1819              // hacks for some contexts
1820              if (($parentcontext->contextlevel == CONTEXT_COURSE) && ($parentcontext->instanceid != SITEID)) {
1821                  // For course context
1822                  // is page type pattern is mod-*, change showinsubcontext to 1
1823                  if ($bits[0] == 'mod' || $bi->pagetypepattern == '*') {
1824                      $bi->showinsubcontexts = 1;
1825                  } else {
1826                      $bi->showinsubcontexts = 0;
1827                  }
1828              } else  if ($parentcontext->contextlevel == CONTEXT_USER) {
1829                  // for user context
1830                  // subpagepattern should be null
1831                  if ($bits[0] == 'user' or $bits[0] == 'my') {
1832                      // we don't need subpagepattern in usercontext
1833                      $bi->subpagepattern = null;
1834                  }
1835              }
1836  
1837              $bi->defaultregion = $data->bui_defaultregion;
1838              $bi->defaultweight = $data->bui_defaultweight;
1839              $bi->timemodified = time();
1840              $DB->update_record('block_instances', $bi);
1841  
1842              if (!empty($block->config)) {
1843                  $config = clone($block->config);
1844              } else {
1845                  $config = new stdClass;
1846              }
1847              foreach ($data as $configfield => $value) {
1848                  if (strpos($configfield, 'config_') !== 0) {
1849                      continue;
1850                  }
1851                  $field = substr($configfield, 7);
1852                  $config->$field = $value;
1853              }
1854              $block->instance_config_save($config);
1855  
1856              $bp = new stdClass;
1857              $bp->visible = $data->bui_visible;
1858              $bp->region = $data->bui_region;
1859              $bp->weight = $data->bui_weight;
1860              $needbprecord = !$data->bui_visible || $data->bui_region != $data->bui_defaultregion ||
1861                      $data->bui_weight != $data->bui_defaultweight;
1862  
1863              if ($block->instance->blockpositionid && !$needbprecord) {
1864                  $DB->delete_records('block_positions', array('id' => $block->instance->blockpositionid));
1865  
1866              } else if ($block->instance->blockpositionid && $needbprecord) {
1867                  $bp->id = $block->instance->blockpositionid;
1868                  $DB->update_record('block_positions', $bp);
1869  
1870              } else if ($needbprecord) {
1871                  $bp->blockinstanceid = $block->instance->id;
1872                  $bp->contextid = $this->page->context->id;
1873                  $bp->pagetype = $this->page->pagetype;
1874                  if ($this->page->subpage) {
1875                      $bp->subpage = $this->page->subpage;
1876                  } else {
1877                      $bp->subpage = '';
1878                  }
1879                  $DB->insert_record('block_positions', $bp);
1880              }
1881  
1882              redirect($this->page->url);
1883  
1884          } else {
1885              $strheading = get_string('blockconfiga', 'moodle', $block->get_title());
1886              $editpage->set_title($strheading);
1887              $editpage->set_heading($strheading);
1888              $bits = explode('-', $this->page->pagetype);
1889              if ($bits[0] == 'tag' && !empty($this->page->subpage)) {
1890                  // better navbar for tag pages
1891                  $editpage->navbar->add(get_string('tags'), new moodle_url('/tag/'));
1892                  $tag = core_tag_tag::get($this->page->subpage);
1893                  // tag search page doesn't have subpageid
1894                  if ($tag) {
1895                      $editpage->navbar->add($tag->get_display_name(), $tag->get_view_url());
1896                  }
1897              }
1898              $editpage->navbar->add($block->get_title());
1899              $editpage->navbar->add(get_string('configuration'));
1900              echo $output->header();
1901              $mform->display();
1902              echo $output->footer();
1903              exit;
1904          }
1905      }
1906  
1907      /**
1908       * Handle showing/processing the submission from the block editing form.
1909       * @return boolean true if the form was submitted and the new config saved. Does not
1910       *      return if the editing form was displayed. False otherwise.
1911       */
1912      public function process_url_move() {
1913          global $CFG, $DB, $PAGE;
1914  
1915          $blockid = optional_param('bui_moveid', null, PARAM_INT);
1916          if (!$blockid) {
1917              return false;
1918          }
1919  
1920          require_sesskey();
1921  
1922          $block = $this->find_instance($blockid);
1923  
1924          if (!$this->page->user_can_edit_blocks()) {
1925              throw new moodle_exception('nopermissions', '', $this->page->url->out(), get_string('editblock'));
1926          }
1927  
1928          $newregion = optional_param('bui_newregion', '', PARAM_ALPHANUMEXT);
1929          $newweight = optional_param('bui_newweight', null, PARAM_FLOAT);
1930          if (!$newregion || is_null($newweight)) {
1931              // Don't have a valid target position yet, must be just starting the move.
1932              $this->movingblock = $blockid;
1933              $this->page->ensure_param_not_in_url('bui_moveid');
1934              return false;
1935          }
1936  
1937          if (!$this->is_known_region($newregion)) {
1938              throw new moodle_exception('unknownblockregion', '', $this->page->url, $newregion);
1939          }
1940  
1941          // Move this block. This may involve moving other nearby blocks.
1942          $blocks = $this->birecordsbyregion[$newregion];
1943  
1944          $maxweight = self::MAX_WEIGHT;
1945          $minweight = -self::MAX_WEIGHT;
1946  
1947          // Initialise the used weights and spareweights array with the default values
1948          $spareweights = array();
1949          $usedweights = array();
1950          for ($i = $minweight; $i <= $maxweight; $i++) {
1951              $spareweights[$i] = $i;
1952              $usedweights[$i] = array();
1953          }
1954  
1955          // Check each block and sort out where we have used weights
1956          foreach ($blocks as $bi) {
1957              if ($bi->weight > $maxweight) {
1958                  // If this statement is true then the blocks weight is more than the
1959                  // current maximum. To ensure that we can get the best block position
1960                  // we will initialise elements within the usedweights and spareweights
1961                  // arrays between the blocks weight (which will then be the new max) and
1962                  // the current max
1963                  $parseweight = $bi->weight;
1964                  while (!array_key_exists($parseweight, $usedweights)) {
1965                      $usedweights[$parseweight] = array();
1966                      $spareweights[$parseweight] = $parseweight;
1967                      $parseweight--;
1968                  }
1969                  $maxweight = $bi->weight;
1970              } else if ($bi->weight < $minweight) {
1971                  // As above except this time the blocks weight is LESS than the
1972                  // the current minimum, so we will initialise the array from the
1973                  // blocks weight (new minimum) to the current minimum
1974                  $parseweight = $bi->weight;
1975                  while (!array_key_exists($parseweight, $usedweights)) {
1976                      $usedweights[$parseweight] = array();
1977                      $spareweights[$parseweight] = $parseweight;
1978                      $parseweight++;
1979                  }
1980                  $minweight = $bi->weight;
1981              }
1982              if ($bi->id != $block->instance->id) {
1983                  unset($spareweights[$bi->weight]);
1984                  $usedweights[$bi->weight][] = $bi->id;
1985              }
1986          }
1987  
1988          // First we find the nearest gap in the list of weights.
1989          $bestdistance = max(abs($newweight - self::MAX_WEIGHT), abs($newweight + self::MAX_WEIGHT)) + 1;
1990          $bestgap = null;
1991          foreach ($spareweights as $spareweight) {
1992              if (abs($newweight - $spareweight) < $bestdistance) {
1993                  $bestdistance = abs($newweight - $spareweight);
1994                  $bestgap = $spareweight;
1995              }
1996          }
1997  
1998          // If there is no gap, we have to go outside -self::MAX_WEIGHT .. self::MAX_WEIGHT.
1999          if (is_null($bestgap)) {
2000              $bestgap = self::MAX_WEIGHT + 1;
2001              while (!empty($usedweights[$bestgap])) {
2002                  $bestgap++;
2003              }
2004          }
2005  
2006          // Now we know the gap we are aiming for, so move all the blocks along.
2007          if ($bestgap < $newweight) {
2008              $newweight = floor($newweight);
2009              for ($weight = $bestgap + 1; $weight <= $newweight; $weight++) {
2010                  if (array_key_exists($weight, $usedweights)) {
2011                      foreach ($usedweights[$weight] as $biid) {
2012                          $this->reposition_block($biid, $newregion, $weight - 1);
2013                      }
2014                  }
2015              }
2016              $this->reposition_block($block->instance->id, $newregion, $newweight);
2017          } else {
2018              $newweight = ceil($newweight);
2019              for ($weight = $bestgap - 1; $weight >= $newweight; $weight--) {
2020                  if (array_key_exists($weight, $usedweights)) {
2021                      foreach ($usedweights[$weight] as $biid) {
2022                          $this->reposition_block($biid, $newregion, $weight + 1);
2023                      }
2024                  }
2025              }
2026              $this->reposition_block($block->instance->id, $newregion, $newweight);
2027          }
2028  
2029          $this->page->ensure_param_not_in_url('bui_moveid');
2030          $this->page->ensure_param_not_in_url('bui_newregion');
2031          $this->page->ensure_param_not_in_url('bui_newweight');
2032          return true;
2033      }
2034  
2035      /**
2036       * Turns the display of normal blocks either on or off.
2037       *
2038       * @param bool $setting
2039       */
2040      public function show_only_fake_blocks($setting = true) {
2041          $this->fakeblocksonly = $setting;
2042      }
2043  }
2044  
2045  /// Helper functions for working with block classes ============================
2046  
2047  /**
2048   * Call a class method (one that does not require a block instance) on a block class.
2049   *
2050   * @param string $blockname the name of the block.
2051   * @param string $method the method name.
2052   * @param array $param parameters to pass to the method.
2053   * @return mixed whatever the method returns.
2054   */
2055  function block_method_result($blockname, $method, $param = NULL) {
2056      if(!block_load_class($blockname)) {
2057          return NULL;
2058      }
2059      return call_user_func(array('block_'.$blockname, $method), $param);
2060  }
2061  
2062  /**
2063   * Returns a new instance of the specified block instance id.
2064   *
2065   * @param int $blockinstanceid
2066   * @return block_base the requested block instance.
2067   */
2068  function block_instance_by_id($blockinstanceid) {
2069      global $DB;
2070  
2071      $blockinstance = $DB->get_record('block_instances', ['id' => $blockinstanceid]);
2072      $instance = block_instance($blockinstance->blockname, $blockinstance);
2073      return $instance;
2074  }
2075  
2076  /**
2077   * Creates a new instance of the specified block class.
2078   *
2079   * @param string $blockname the name of the block.
2080   * @param $instance block_instances DB table row (optional).
2081   * @param moodle_page $page the page this block is appearing on.
2082   * @return block_base the requested block instance.
2083   */
2084  function block_instance($blockname, $instance = NULL, $page = NULL) {
2085      if(!block_load_class($blockname)) {
2086          return false;
2087      }
2088      $classname = 'block_'.$blockname;
2089      $retval = new $classname;
2090      if($instance !== NULL) {
2091          if (is_null($page)) {
2092              global $PAGE;
2093              $page = $PAGE;
2094          }
2095          $retval->_load_instance($instance, $page);
2096      }
2097      return $retval;
2098  }
2099  
2100  /**
2101   * Load the block class for a particular type of block.
2102   *
2103   * @param string $blockname the name of the block.
2104   * @return boolean success or failure.
2105   */
2106  function block_load_class($blockname) {
2107      global $CFG;
2108  
2109      if(empty($blockname)) {
2110          return false;
2111      }
2112  
2113      $classname = 'block_'.$blockname;
2114  
2115      if(class_exists($classname)) {
2116          return true;
2117      }
2118  
2119      $blockpath = $CFG->dirroot.'/blocks/'.$blockname.'/block_'.$blockname.'.php';
2120  
2121      if (file_exists($blockpath)) {
2122          require_once($CFG->dirroot.'/blocks/moodleblock.class.php');
2123          include_once($blockpath);
2124      }else{
2125          //debugging("$blockname code does not exist in $blockpath", DEBUG_DEVELOPER);
2126          return false;
2127      }
2128  
2129      return class_exists($classname);
2130  }
2131  
2132  /**
2133   * Given a specific page type, return all the page type patterns that might
2134   * match it.
2135   *
2136   * @param string $pagetype for example 'course-view-weeks' or 'mod-quiz-view'.
2137   * @return array an array of all the page type patterns that might match this page type.
2138   */
2139  function matching_page_type_patterns($pagetype) {
2140      $patterns = array($pagetype);
2141      $bits = explode('-', $pagetype);
2142      if (count($bits) == 3 && $bits[0] == 'mod') {
2143          if ($bits[2] == 'view') {
2144              $patterns[] = 'mod-*-view';
2145          } else if ($bits[2] == 'index') {
2146              $patterns[] = 'mod-*-index';
2147          }
2148      }
2149      while (count($bits) > 0) {
2150          $patterns[] = implode('-', $bits) . '-*';
2151          array_pop($bits);
2152      }
2153      $patterns[] = '*';
2154      return $patterns;
2155  }
2156  
2157  /**
2158   * Give an specific pattern, return all the page type patterns that would also match it.
2159   *
2160   * @param  string $pattern the pattern, e.g. 'mod-forum-*' or 'mod-quiz-view'.
2161   * @return array of all the page type patterns matching.
2162   */
2163  function matching_page_type_patterns_from_pattern($pattern) {
2164      $patterns = array($pattern);
2165      if ($pattern === '*') {
2166          return $patterns;
2167      }
2168  
2169      // Only keep the part before the star because we will append -* to all the bits.
2170      $star = strpos($pattern, '-*');
2171      if ($star !== false) {
2172          $pattern = substr($pattern, 0, $star);
2173      }
2174  
2175      $patterns = array_merge($patterns, matching_page_type_patterns($pattern));
2176      $patterns = array_unique($patterns);
2177  
2178      return $patterns;
2179  }
2180  
2181  /**
2182   * Given a specific page type, parent context and currect context, return all the page type patterns
2183   * that might be used by this block.
2184   *
2185   * @param string $pagetype for example 'course-view-weeks' or 'mod-quiz-view'.
2186   * @param stdClass $parentcontext Block's parent context
2187   * @param stdClass $currentcontext Current context of block
2188   * @return array an array of all the page type patterns that might match this page type.
2189   */
2190  function generate_page_type_patterns($pagetype, $parentcontext = null, $currentcontext = null) {
2191      global $CFG; // Required for includes bellow.
2192  
2193      $bits = explode('-', $pagetype);
2194  
2195      $core = core_component::get_core_subsystems();
2196      $plugins = core_component::get_plugin_types();
2197  
2198      //progressively strip pieces off the page type looking for a match
2199      $componentarray = null;
2200      for ($i = count($bits); $i > 0; $i--) {
2201          $possiblecomponentarray = array_slice($bits, 0, $i);
2202          $possiblecomponent = implode('', $possiblecomponentarray);
2203  
2204          // Check to see if the component is a core component
2205          if (array_key_exists($possiblecomponent, $core) && !empty($core[$possiblecomponent])) {
2206              $libfile = $core[$possiblecomponent].'/lib.php';
2207              if (file_exists($libfile)) {
2208                  require_once($libfile);
2209                  $function = $possiblecomponent.'_page_type_list';
2210                  if (function_exists($function)) {
2211                      if ($patterns = $function($pagetype, $parentcontext, $currentcontext)) {
2212                          break;
2213                      }
2214                  }
2215              }
2216          }
2217  
2218          //check the plugin directory and look for a callback
2219          if (array_key_exists($possiblecomponent, $plugins) && !empty($plugins[$possiblecomponent])) {
2220  
2221              //We've found a plugin type. Look for a plugin name by getting the next section of page type
2222              if (count($bits) > $i) {
2223                  $pluginname = $bits[$i];
2224                  $directory = core_component::get_plugin_directory($possiblecomponent, $pluginname);
2225                  if (!empty($directory)){
2226                      $libfile = $directory.'/lib.php';
2227                      if (file_exists($libfile)) {
2228                          require_once($libfile);
2229                          $function = $possiblecomponent.'_'.$pluginname.'_page_type_list';
2230                          if (!function_exists($function)) {
2231                              $function = $pluginname.'_page_type_list';
2232                          }
2233                          if (function_exists($function)) {
2234                              if ($patterns = $function($pagetype, $parentcontext, $currentcontext)) {
2235                                  break;
2236                              }
2237                          }
2238                      }
2239                  }
2240              }
2241  
2242              //we'll only get to here if we still don't have any patterns
2243              //the plugin type may have a callback
2244              $directory = $plugins[$possiblecomponent];
2245              $libfile = $directory.'/lib.php';
2246              if (file_exists($libfile)) {
2247                  require_once($libfile);
2248                  $function = $possiblecomponent.'_page_type_list';
2249                  if (function_exists($function)) {
2250                      if ($patterns = $function($pagetype, $parentcontext, $currentcontext)) {
2251                          break;
2252                      }
2253                  }
2254              }
2255          }
2256      }
2257  
2258      if (empty($patterns)) {
2259          $patterns = default_page_type_list($pagetype, $parentcontext, $currentcontext);
2260      }
2261  
2262      // Ensure that the * pattern is always available if editing block 'at distance', so
2263      // we always can 'bring back' it to the original context. MDL-30340
2264      if ((!isset($currentcontext) or !isset($parentcontext) or $currentcontext->id != $parentcontext->id) && !isset($patterns['*'])) {
2265          // TODO: We could change the string here, showing its 'bring back' meaning
2266          $patterns['*'] = get_string('page-x', 'pagetype');
2267      }
2268  
2269      return $patterns;
2270  }
2271  
2272  /**
2273   * Generates a default page type list when a more appropriate callback cannot be decided upon.
2274   *
2275   * @param string $pagetype
2276   * @param stdClass $parentcontext
2277   * @param stdClass $currentcontext
2278   * @return array
2279   */
2280  function default_page_type_list($pagetype, $parentcontext = null, $currentcontext = null) {
2281      // Generate page type patterns based on current page type if
2282      // callbacks haven't been defined
2283      $patterns = array($pagetype => $pagetype);
2284      $bits = explode('-', $pagetype);
2285      while (count($bits) > 0) {
2286          $pattern = implode('-', $bits) . '-*';
2287          $pagetypestringname = 'page-'.str_replace('*', 'x', $pattern);
2288          // guessing page type description
2289          if (get_string_manager()->string_exists($pagetypestringname, 'pagetype')) {
2290              $patterns[$pattern] = get_string($pagetypestringname, 'pagetype');
2291          } else {
2292              $patterns[$pattern] = $pattern;
2293          }
2294          array_pop($bits);
2295      }
2296      $patterns['*'] = get_string('page-x', 'pagetype');
2297      return $patterns;
2298  }
2299  
2300  /**
2301   * Generates the page type list for the my moodle page
2302   *
2303   * @param string $pagetype
2304   * @param stdClass $parentcontext
2305   * @param stdClass $currentcontext
2306   * @return array
2307   */
2308  function my_page_type_list($pagetype, $parentcontext = null, $currentcontext = null) {
2309      return array('my-index' => get_string('page-my-index', 'pagetype'));
2310  }
2311  
2312  /**
2313   * Generates the page type list for a module by either locating and using the modules callback
2314   * or by generating a default list.
2315   *
2316   * @param string $pagetype
2317   * @param stdClass $parentcontext
2318   * @param stdClass $currentcontext
2319   * @return array
2320   */
2321  function mod_page_type_list($pagetype, $parentcontext = null, $currentcontext = null) {
2322      $patterns = plugin_page_type_list($pagetype, $parentcontext, $currentcontext);
2323      if (empty($patterns)) {
2324          // if modules don't have callbacks
2325          // generate two default page type patterns for modules only
2326          $bits = explode('-', $pagetype);
2327          $patterns = array($pagetype => $pagetype);
2328          if ($bits[2] == 'view') {
2329              $patterns['mod-*-view'] = get_string('page-mod-x-view', 'pagetype');
2330          } else if ($bits[2] == 'index') {
2331              $patterns['mod-*-index'] = get_string('page-mod-x-index', 'pagetype');
2332          }
2333      }
2334      return $patterns;
2335  }
2336  /// Functions update the blocks if required by the request parameters ==========
2337  
2338  /**
2339   * Return a {@link block_contents} representing the add a new block UI, if
2340   * this user is allowed to see it.
2341   *
2342   * @return block_contents an appropriate block_contents, or null if the user
2343   * cannot add any blocks here.
2344   */
2345  function block_add_block_ui($page, $output) {
2346      global $CFG, $OUTPUT;
2347      if (!$page->user_is_editing() || !$page->user_can_edit_blocks()) {
2348          return null;
2349      }
2350  
2351      $bc = new block_contents();
2352      $bc->title = get_string('addblock');
2353      $bc->add_class('block_adminblock');
2354      $bc->attributes['data-block'] = 'adminblock';
2355  
2356      $missingblocks = $page->blocks->get_addable_blocks();
2357      if (empty($missingblocks)) {
2358          $bc->content = get_string('noblockstoaddhere');
2359          return $bc;
2360      }
2361  
2362      $menu = array();
2363      foreach ($missingblocks as $block) {
2364          $menu[$block->name] = $block->title;
2365      }
2366  
2367      $actionurl = new moodle_url($page->url, array('sesskey'=>sesskey()));
2368      $select = new single_select($actionurl, 'bui_addblock', $menu, null, array(''=>get_string('adddots')), 'add_block');
2369      $select->set_label(get_string('addblock'), array('class'=>'accesshide'));
2370      $bc->content = $OUTPUT->render($select);
2371      return $bc;
2372  }
2373  
2374  /**
2375   * Actually delete from the database any blocks that are currently on this page,
2376   * but which should not be there according to blocks_name_allowed_in_format.
2377   *
2378   * @todo Write/Fix this function. Currently returns immediately
2379   * @param $course
2380   */
2381  function blocks_remove_inappropriate($course) {
2382      // TODO
2383      return;
2384      /*
2385      $blockmanager = blocks_get_by_page($page);
2386  
2387      if (empty($blockmanager)) {
2388          return;
2389      }
2390  
2391      if (($pageformat = $page->pagetype) == NULL) {
2392          return;
2393      }
2394  
2395      foreach($blockmanager as $region) {
2396          foreach($region as $instance) {
2397              $block = blocks_get_record($instance->blockid);
2398              if(!blocks_name_allowed_in_format($block->name, $pageformat)) {
2399                 blocks_delete_instance($instance->instance);
2400              }
2401          }
2402      }*/
2403  }
2404  
2405  /**
2406   * Check that a given name is in a permittable format
2407   *
2408   * @param string $name
2409   * @param string $pageformat
2410   * @return bool
2411   */
2412  function blocks_name_allowed_in_format($name, $pageformat) {
2413      $accept = NULL;
2414      $maxdepth = -1;
2415      if (!$bi = block_instance($name)) {
2416          return false;
2417      }
2418  
2419      $formats = $bi->applicable_formats();
2420      if (!$formats) {
2421          $formats = array();
2422      }
2423      foreach ($formats as $format => $allowed) {
2424          $formatregex = '/^'.str_replace('*', '[^-]*', $format).'.*$/';
2425          $depth = substr_count($format, '-');
2426          if (preg_match($formatregex, $pageformat) && $depth > $maxdepth) {
2427              $maxdepth = $depth;
2428              $accept = $allowed;
2429          }
2430      }
2431      if ($accept === NULL) {
2432          $accept = !empty($formats['all']);
2433      }
2434      return $accept;
2435  }
2436  
2437  /**
2438   * Delete a block, and associated data.
2439   *
2440   * @param object $instance a row from the block_instances table
2441   * @param bool $nolongerused legacy parameter. Not used, but kept for backwards compatibility.
2442   * @param bool $skipblockstables for internal use only. Makes @see blocks_delete_all_for_context() more efficient.
2443   */
2444  function blocks_delete_instance($instance, $nolongerused = false, $skipblockstables = false) {
2445      global $DB;
2446  
2447      // Allow plugins to use this block before we completely delete it.
2448      if ($pluginsfunction = get_plugins_with_function('pre_block_delete')) {
2449          foreach ($pluginsfunction as $plugintype => $plugins) {
2450              foreach ($plugins as $pluginfunction) {
2451                  $pluginfunction($instance);
2452              }
2453          }
2454      }
2455  
2456      if ($block = block_instance($instance->blockname, $instance)) {
2457          $block->instance_delete();
2458      }
2459      context_helper::delete_instance(CONTEXT_BLOCK, $instance->id);
2460  
2461      if (!$skipblockstables) {
2462          $DB->delete_records('block_positions', array('blockinstanceid' => $instance->id));
2463          $DB->delete_records('block_instances', array('id' => $instance->id));
2464          $DB->delete_records_list('user_preferences', 'name', array('block'.$instance->id.'hidden','docked_block_instance_'.$instance->id));
2465      }
2466  }
2467  
2468  /**
2469   * Delete multiple blocks at once.
2470   *
2471   * @param array $instanceids A list of block instance ID.
2472   */
2473  function blocks_delete_instances($instanceids) {
2474      global $DB;
2475  
2476      $limit = 1000;
2477      $count = count($instanceids);
2478      $chunks = [$instanceids];
2479      if ($count > $limit) {
2480          $chunks = array_chunk($instanceids, $limit);
2481      }
2482  
2483      // Perform deletion for each chunk.
2484      foreach ($chunks as $chunk) {
2485          $instances = $DB->get_recordset_list('block_instances', 'id', $chunk);
2486          foreach ($instances as $instance) {
2487              blocks_delete_instance($instance, false, true);
2488          }
2489          $instances->close();
2490  
2491          $DB->delete_records_list('block_positions', 'blockinstanceid', $chunk);
2492          $DB->delete_records_list('block_instances', 'id', $chunk);
2493  
2494          $preferences = array();
2495          foreach ($chunk as $instanceid) {
2496              $preferences[] = 'block' . $instanceid . 'hidden';
2497              $preferences[] = 'docked_block_instance_' . $instanceid;
2498          }
2499          $DB->delete_records_list('user_preferences', 'name', $preferences);
2500      }
2501  }
2502  
2503  /**
2504   * Delete all the blocks that belong to a particular context.
2505   *
2506   * @param int $contextid the context id.
2507   */
2508  function blocks_delete_all_for_context($contextid) {
2509      global $DB;
2510      $instances = $DB->get_recordset('block_instances', array('parentcontextid' => $contextid));
2511      foreach ($instances as $instance) {
2512          blocks_delete_instance($instance, true);
2513      }
2514      $instances->close();
2515      $DB->delete_records('block_instances', array('parentcontextid' => $contextid));
2516      $DB->delete_records('block_positions', array('contextid' => $contextid));
2517  }
2518  
2519  /**
2520   * Set a block to be visible or hidden on a particular page.
2521   *
2522   * @param object $instance a row from the block_instances, preferably LEFT JOINed with the
2523   *      block_positions table as return by block_manager.
2524   * @param moodle_page $page the back to set the visibility with respect to.
2525   * @param integer $newvisibility 1 for visible, 0 for hidden.
2526   */
2527  function blocks_set_visibility($instance, $page, $newvisibility) {
2528      global $DB;
2529      if (!empty($instance->blockpositionid)) {
2530          // Already have local information on this page.
2531          $DB->set_field('block_positions', 'visible', $newvisibility, array('id' => $instance->blockpositionid));
2532          return;
2533      }
2534  
2535      // Create a new block_positions record.
2536      $bp = new stdClass;
2537      $bp->blockinstanceid = $instance->id;
2538      $bp->contextid = $page->context->id;
2539      $bp->pagetype = $page->pagetype;
2540      if ($page->subpage) {
2541          $bp->subpage = $page->subpage;
2542      }
2543      $bp->visible = $newvisibility;
2544      $bp->region = $instance->defaultregion;
2545      $bp->weight = $instance->defaultweight;
2546      $DB->insert_record('block_positions', $bp);
2547  }
2548  
2549  /**
2550   * Get the block record for a particular blockid - that is, a particular type os block.
2551   *
2552   * @param $int blockid block type id. If null, an array of all block types is returned.
2553   * @param bool $notusedanymore No longer used.
2554   * @return array|object row from block table, or all rows.
2555   */
2556  function blocks_get_record($blockid = NULL, $notusedanymore = false) {
2557      global $PAGE;
2558      $blocks = $PAGE->blocks->get_installed_blocks();
2559      if ($blockid === NULL) {
2560          return $blocks;
2561      } else if (isset($blocks[$blockid])) {
2562          return $blocks[$blockid];
2563      } else {
2564          return false;
2565      }
2566  }
2567  
2568  /**
2569   * Find a given block by its blockid within a provide array
2570   *
2571   * @param int $blockid
2572   * @param array $blocksarray
2573   * @return bool|object Instance if found else false
2574   */
2575  function blocks_find_block($blockid, $blocksarray) {
2576      if (empty($blocksarray)) {
2577          return false;
2578      }
2579      foreach($blocksarray as $blockgroup) {
2580          if (empty($blockgroup)) {
2581              continue;
2582          }
2583          foreach($blockgroup as $instance) {
2584              if($instance->blockid == $blockid) {
2585                  return $instance;
2586              }
2587          }
2588      }
2589      return false;
2590  }
2591  
2592  // Functions for programatically adding default blocks to pages ================
2593  
2594   /**
2595    * Parse a list of default blocks. See config-dist for a description of the format.
2596    *
2597    * @param string $blocksstr Determines the starting point that the blocks are added in the region.
2598    * @return array the parsed list of default blocks
2599    */
2600  function blocks_parse_default_blocks_list($blocksstr) {
2601      $blocks = array();
2602      $bits = explode(':', $blocksstr);
2603      if (!empty($bits)) {
2604          $leftbits = trim(array_shift($bits));
2605          if ($leftbits != '') {
2606              $blocks[BLOCK_POS_LEFT] = explode(',', $leftbits);
2607          }
2608      }
2609      if (!empty($bits)) {
2610          $rightbits = trim(array_shift($bits));
2611          if ($rightbits != '') {
2612              $blocks[BLOCK_POS_RIGHT] = explode(',', $rightbits);
2613          }
2614      }
2615      return $blocks;
2616  }
2617  
2618  /**
2619   * @return array the blocks that should be added to the site course by default.
2620   */
2621  function blocks_get_default_site_course_blocks() {
2622      global $CFG;
2623  
2624      if (isset($CFG->defaultblocks_site)) {
2625          return blocks_parse_default_blocks_list($CFG->defaultblocks_site);
2626      } else {
2627          return array(
2628              BLOCK_POS_LEFT => array(),
2629              BLOCK_POS_RIGHT => array()
2630          );
2631      }
2632  }
2633  
2634  /**
2635   * Add the default blocks to a course.
2636   *
2637   * @param object $course a course object.
2638   */
2639  function blocks_add_default_course_blocks($course) {
2640      global $CFG;
2641  
2642      if (isset($CFG->defaultblocks_override)) {
2643          $blocknames = blocks_parse_default_blocks_list($CFG->defaultblocks_override);
2644  
2645      } else if ($course->id == SITEID) {
2646          $blocknames = blocks_get_default_site_course_blocks();
2647  
2648      } else if (isset($CFG->{'defaultblocks_' . $course->format})) {
2649          $blocknames = blocks_parse_default_blocks_list($CFG->{'defaultblocks_' . $course->format});
2650  
2651      } else {
2652          require_once($CFG->dirroot. '/course/lib.php');
2653          $blocknames = course_get_format($course)->get_default_blocks();
2654  
2655      }
2656  
2657      if ($course->id == SITEID) {
2658          $pagetypepattern = 'site-index';
2659      } else {
2660          $pagetypepattern = 'course-view-*';
2661      }
2662      $page = new moodle_page();
2663      $page->set_course($course);
2664      $page->blocks->add_blocks($blocknames, $pagetypepattern);
2665  }
2666  
2667  /**
2668   * Add the default system-context blocks. E.g. the admin tree.
2669   */
2670  function blocks_add_default_system_blocks() {
2671      global $DB;
2672  
2673      $page = new moodle_page();
2674      $page->set_context(context_system::instance());
2675      // We don't add blocks required by the theme, they will be auto-created.
2676      $page->blocks->add_blocks(array(BLOCK_POS_LEFT => array('admin_bookmarks')), 'admin-*', null, null, 2);
2677  
2678      if ($defaultmypage = $DB->get_record('my_pages', array('userid' => null, 'name' => '__default', 'private' => 1))) {
2679          $subpagepattern = $defaultmypage->id;
2680      } else {
2681          $subpagepattern = null;
2682      }
2683  
2684      if ($defaultmycoursespage = $DB->get_record('my_pages', array('userid' => null, 'name' => '__courses', 'private' => 0))) {
2685          $mycoursesubpagepattern = $defaultmycoursespage->id;
2686      } else {
2687          $mycoursesubpagepattern = null;
2688      }
2689  
2690      $page->blocks->add_blocks([
2691          BLOCK_POS_RIGHT => [
2692              'recentlyaccesseditems',
2693          ],
2694          'content' => [
2695              'timeline',
2696              'calendar_month',
2697          ]],
2698          'my-index',
2699          $subpagepattern
2700      );
2701  
2702      $page->blocks->add_blocks([
2703          'content' => [
2704              'myoverview'
2705          ]],
2706          'my-index',
2707          $mycoursesubpagepattern
2708      );
2709  }