[Summary view]

Differences Between: [Versions 310 and 401] [Versions 311 and 401] [Versions 39 and 401] [Versions 400 and 401] [Versions 401 and 402] [Versions 401 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       * @todo MDL-74939 Remove support for old 'local\views\secondary' class location
1688       * @param block_base $block
1689       * @return \core\navigation\views\secondary
1690       */
1691      protected function get_secondarynav(block_base $block): \core\navigation\views\secondary {
1692          $class = "core_block\\navigation\\views\\secondary";
1693          if (class_exists("block_{$block->name()}\\navigation\\views\\secondary")) {
1694              $class = "block_{$block->name()}\\navigation\\views\\secondary";
1695          } else if (class_exists("block_{$block->name()}\\local\\views\\secondary")) {
1696              // For backwards compatibility, support the old location for this class (it was in a
1697              // 'local' namespace which shouldn't be used for core APIs).
1698              debugging("The class block_{$block->name()}\\local\\views\\secondary uses a deprecated " .
1699                      "namespace. Please move it to block_{$block->name()}\\navigation\\views\\secondary.",
1700                      DEBUG_DEVELOPER);
1701              $class = "block_{$block->name()}\\local\\views\\secondary";
1702          }
1703          $secondarynav = new $class($this->page);
1704          $secondarynav->initialise();
1705          return $secondarynav;
1706      }
1707  
1708      /**
1709       * Handle showing/processing the submission from the block editing form.
1710       * @return boolean true if the form was submitted and the new config saved. Does not
1711       *      return if the editing form was displayed. False otherwise.
1712       */
1713      public function process_url_edit() {
1714          global $CFG, $DB, $PAGE, $OUTPUT;
1715  
1716          $blockid = optional_param('bui_editid', null, PARAM_INT);
1717          if (!$blockid) {
1718              return false;
1719          }
1720  
1721          require_once($CFG->dirroot . '/blocks/edit_form.php');
1722  
1723          $block = $this->find_instance($blockid);
1724  
1725          if (!$block->user_can_edit() && !$this->page->user_can_edit_blocks()) {
1726              throw new moodle_exception('nopermissions', '', $this->page->url->out(), get_string('editblock'));
1727          }
1728  
1729          $editpage = new moodle_page();
1730          $editpage->set_pagelayout('admin');
1731          $editpage->blocks->show_only_fake_blocks(true);
1732          $editpage->set_course($this->page->course);
1733          //$editpage->set_context($block->context);
1734          $editpage->set_context($this->page->context);
1735          $editpage->set_secondarynav($this->get_secondarynav($block));
1736  
1737          if ($this->page->cm) {
1738              $editpage->set_cm($this->page->cm);
1739          }
1740          $editurlbase = str_replace($CFG->wwwroot . '/', '/', $this->page->url->out_omit_querystring());
1741          $editurlparams = $this->page->url->params();
1742          $editurlparams['bui_editid'] = $blockid;
1743          $editpage->set_url($editurlbase, $editurlparams);
1744          $editpage->set_block_actions_done();
1745          // At this point we are either going to redirect, or display the form, so
1746          // overwrite global $PAGE ready for this. (Formslib refers to it.)
1747          $PAGE = $editpage;
1748          //some functions like MoodleQuickForm::addHelpButton use $OUTPUT so we need to replace that to
1749          $output = $editpage->get_renderer('core');
1750          $OUTPUT = $output;
1751  
1752          $formfile = $CFG->dirroot . '/blocks/' . $block->name() . '/edit_form.php';
1753          if (is_readable($formfile)) {
1754              require_once($formfile);
1755              $classname = 'block_' . $block->name() . '_edit_form';
1756              if (!class_exists($classname)) {
1757                  $classname = 'block_edit_form';
1758              }
1759          } else {
1760              $classname = 'block_edit_form';
1761          }
1762  
1763          $mform = new $classname($editpage->url, $block, $this->page);
1764          $mform->set_data($block->instance);
1765  
1766          if ($mform->is_cancelled()) {
1767              redirect($this->page->url);
1768  
1769          } else if ($data = $mform->get_data()) {
1770              $bi = new stdClass;
1771              $bi->id = $block->instance->id;
1772  
1773              // This may get overwritten by the special case handling below.
1774              $bi->pagetypepattern = $data->bui_pagetypepattern;
1775              $bi->showinsubcontexts = (bool) $data->bui_contexts;
1776              if (empty($data->bui_subpagepattern) || $data->bui_subpagepattern == '%@NULL@%') {
1777                  $bi->subpagepattern = null;
1778              } else {
1779                  $bi->subpagepattern = $data->bui_subpagepattern;
1780              }
1781  
1782              $systemcontext = context_system::instance();
1783              $frontpagecontext = context_course::instance(SITEID);
1784              $parentcontext = context::instance_by_id($data->bui_parentcontextid);
1785  
1786              // Updating stickiness and contexts.  See MDL-21375 for details.
1787              if (has_capability('moodle/site:manageblocks', $parentcontext)) { // Check permissions in destination
1788  
1789                  // Explicitly set the default context
1790                  $bi->parentcontextid = $parentcontext->id;
1791  
1792                  if ($data->bui_editingatfrontpage) {   // The block is being edited on the front page
1793  
1794                      // The interface here is a special case because the pagetype pattern is
1795                      // totally derived from the context menu.  Here are the excpetions.   MDL-30340
1796  
1797                      switch ($data->bui_contexts) {
1798                          case BUI_CONTEXTS_ENTIRE_SITE:
1799                              // The user wants to show the block across the entire site
1800                              $bi->parentcontextid = $systemcontext->id;
1801                              $bi->showinsubcontexts = true;
1802                              $bi->pagetypepattern  = '*';
1803                              break;
1804                          case BUI_CONTEXTS_FRONTPAGE_SUBS:
1805                              // The user wants the block shown on the front page and all subcontexts
1806                              $bi->parentcontextid = $frontpagecontext->id;
1807                              $bi->showinsubcontexts = true;
1808                              $bi->pagetypepattern  = '*';
1809                              break;
1810                          case BUI_CONTEXTS_FRONTPAGE_ONLY:
1811                              // The user want to show the front page on the frontpage only
1812                              $bi->parentcontextid = $frontpagecontext->id;
1813                              $bi->showinsubcontexts = false;
1814                              $bi->pagetypepattern  = 'site-index';
1815                              // This is the only relevant page type anyway but we'll set it explicitly just
1816                              // in case the front page grows site-index-* subpages of its own later
1817                              break;
1818                      }
1819                  }
1820              }
1821  
1822              $bits = explode('-', $bi->pagetypepattern);
1823              // hacks for some contexts
1824              if (($parentcontext->contextlevel == CONTEXT_COURSE) && ($parentcontext->instanceid != SITEID)) {
1825                  // For course context
1826                  // is page type pattern is mod-*, change showinsubcontext to 1
1827                  if ($bits[0] == 'mod' || $bi->pagetypepattern == '*') {
1828                      $bi->showinsubcontexts = 1;
1829                  } else {
1830                      $bi->showinsubcontexts = 0;
1831                  }
1832              } else  if ($parentcontext->contextlevel == CONTEXT_USER) {
1833                  // for user context
1834                  // subpagepattern should be null
1835                  if ($bits[0] == 'user' or $bits[0] == 'my') {
1836                      // we don't need subpagepattern in usercontext
1837                      $bi->subpagepattern = null;
1838                  }
1839              }
1840  
1841              $bi->defaultregion = $data->bui_defaultregion;
1842              $bi->defaultweight = $data->bui_defaultweight;
1843              $bi->timemodified = time();
1844              $DB->update_record('block_instances', $bi);
1845  
1846              if (!empty($block->config)) {
1847                  $config = clone($block->config);
1848              } else {
1849                  $config = new stdClass;
1850              }
1851              foreach ($data as $configfield => $value) {
1852                  if (strpos($configfield, 'config_') !== 0) {
1853                      continue;
1854                  }
1855                  $field = substr($configfield, 7);
1856                  $config->$field = $value;
1857              }
1858              $block->instance_config_save($config);
1859  
1860              $bp = new stdClass;
1861              $bp->visible = $data->bui_visible;
1862              $bp->region = $data->bui_region;
1863              $bp->weight = $data->bui_weight;
1864              $needbprecord = !$data->bui_visible || $data->bui_region != $data->bui_defaultregion ||
1865                      $data->bui_weight != $data->bui_defaultweight;
1866  
1867              if ($block->instance->blockpositionid && !$needbprecord) {
1868                  $DB->delete_records('block_positions', array('id' => $block->instance->blockpositionid));
1869  
1870              } else if ($block->instance->blockpositionid && $needbprecord) {
1871                  $bp->id = $block->instance->blockpositionid;
1872                  $DB->update_record('block_positions', $bp);
1873  
1874              } else if ($needbprecord) {
1875                  $bp->blockinstanceid = $block->instance->id;
1876                  $bp->contextid = $this->page->context->id;
1877                  $bp->pagetype = $this->page->pagetype;
1878                  if ($this->page->subpage) {
1879                      $bp->subpage = $this->page->subpage;
1880                  } else {
1881                      $bp->subpage = '';
1882                  }
1883                  $DB->insert_record('block_positions', $bp);
1884              }
1885  
1886              redirect($this->page->url);
1887  
1888          } else {
1889              $strheading = get_string('blockconfiga', 'moodle', $block->get_title());
1890              $editpage->set_title($strheading);
1891              $editpage->set_heading($strheading);
1892              $bits = explode('-', $this->page->pagetype);
1893              if ($bits[0] == 'tag' && !empty($this->page->subpage)) {
1894                  // better navbar for tag pages
1895                  $editpage->navbar->add(get_string('tags'), new moodle_url('/tag/'));
1896                  $tag = core_tag_tag::get($this->page->subpage);
1897                  // tag search page doesn't have subpageid
1898                  if ($tag) {
1899                      $editpage->navbar->add($tag->get_display_name(), $tag->get_view_url());
1900                  }
1901              }
1902              $editpage->navbar->add($block->get_title());
1903              $editpage->navbar->add(get_string('configuration'));
1904              echo $output->header();
1905              $mform->display();
1906              echo $output->footer();
1907              exit;
1908          }
1909      }
1910  
1911      /**
1912       * Handle showing/processing the submission from the block editing form.
1913       * @return boolean true if the form was submitted and the new config saved. Does not
1914       *      return if the editing form was displayed. False otherwise.
1915       */
1916      public function process_url_move() {
1917          global $CFG, $DB, $PAGE;
1918  
1919          $blockid = optional_param('bui_moveid', null, PARAM_INT);
1920          if (!$blockid) {
1921              return false;
1922          }
1923  
1924          require_sesskey();
1925  
1926          $block = $this->find_instance($blockid);
1927  
1928          if (!$this->page->user_can_edit_blocks()) {
1929              throw new moodle_exception('nopermissions', '', $this->page->url->out(), get_string('editblock'));
1930          }
1931  
1932          $newregion = optional_param('bui_newregion', '', PARAM_ALPHANUMEXT);
1933          $newweight = optional_param('bui_newweight', null, PARAM_FLOAT);
1934          if (!$newregion || is_null($newweight)) {
1935              // Don't have a valid target position yet, must be just starting the move.
1936              $this->movingblock = $blockid;
1937              $this->page->ensure_param_not_in_url('bui_moveid');
1938              return false;
1939          }
1940  
1941          if (!$this->is_known_region($newregion)) {
1942              throw new moodle_exception('unknownblockregion', '', $this->page->url, $newregion);
1943          }
1944  
1945          // Move this block. This may involve moving other nearby blocks.
1946          $blocks = $this->birecordsbyregion[$newregion];
1947  
1948          $maxweight = self::MAX_WEIGHT;
1949          $minweight = -self::MAX_WEIGHT;
1950  
1951          // Initialise the used weights and spareweights array with the default values
1952          $spareweights = array();
1953          $usedweights = array();
1954          for ($i = $minweight; $i <= $maxweight; $i++) {
1955              $spareweights[$i] = $i;
1956              $usedweights[$i] = array();
1957          }
1958  
1959          // Check each block and sort out where we have used weights
1960          foreach ($blocks as $bi) {
1961              if ($bi->weight > $maxweight) {
1962                  // If this statement is true then the blocks weight is more than the
1963                  // current maximum. To ensure that we can get the best block position
1964                  // we will initialise elements within the usedweights and spareweights
1965                  // arrays between the blocks weight (which will then be the new max) and
1966                  // the current max
1967                  $parseweight = $bi->weight;
1968                  while (!array_key_exists($parseweight, $usedweights)) {
1969                      $usedweights[$parseweight] = array();
1970                      $spareweights[$parseweight] = $parseweight;
1971                      $parseweight--;
1972                  }
1973                  $maxweight = $bi->weight;
1974              } else if ($bi->weight < $minweight) {
1975                  // As above except this time the blocks weight is LESS than the
1976                  // the current minimum, so we will initialise the array from the
1977                  // blocks weight (new minimum) to the current minimum
1978                  $parseweight = $bi->weight;
1979                  while (!array_key_exists($parseweight, $usedweights)) {
1980                      $usedweights[$parseweight] = array();
1981                      $spareweights[$parseweight] = $parseweight;
1982                      $parseweight++;
1983                  }
1984                  $minweight = $bi->weight;
1985              }
1986              if ($bi->id != $block->instance->id) {
1987                  unset($spareweights[$bi->weight]);
1988                  $usedweights[$bi->weight][] = $bi->id;
1989              }
1990          }
1991  
1992          // First we find the nearest gap in the list of weights.
1993          $bestdistance = max(abs($newweight - self::MAX_WEIGHT), abs($newweight + self::MAX_WEIGHT)) + 1;
1994          $bestgap = null;
1995          foreach ($spareweights as $spareweight) {
1996              if (abs($newweight - $spareweight) < $bestdistance) {
1997                  $bestdistance = abs($newweight - $spareweight);
1998                  $bestgap = $spareweight;
1999              }
2000          }
2001  
2002          // If there is no gap, we have to go outside -self::MAX_WEIGHT .. self::MAX_WEIGHT.
2003          if (is_null($bestgap)) {
2004              $bestgap = self::MAX_WEIGHT + 1;
2005              while (!empty($usedweights[$bestgap])) {
2006                  $bestgap++;
2007              }
2008          }
2009  
2010          // Now we know the gap we are aiming for, so move all the blocks along.
2011          if ($bestgap < $newweight) {
2012              $newweight = floor($newweight);
2013              for ($weight = $bestgap + 1; $weight <= $newweight; $weight++) {
2014                  if (array_key_exists($weight, $usedweights)) {
2015                      foreach ($usedweights[$weight] as $biid) {
2016                          $this->reposition_block($biid, $newregion, $weight - 1);
2017                      }
2018                  }
2019              }
2020              $this->reposition_block($block->instance->id, $newregion, $newweight);
2021          } else {
2022              $newweight = ceil($newweight);
2023              for ($weight = $bestgap - 1; $weight >= $newweight; $weight--) {
2024                  if (array_key_exists($weight, $usedweights)) {
2025                      foreach ($usedweights[$weight] as $biid) {
2026                          $this->reposition_block($biid, $newregion, $weight + 1);
2027                      }
2028                  }
2029              }
2030              $this->reposition_block($block->instance->id, $newregion, $newweight);
2031          }
2032  
2033          $this->page->ensure_param_not_in_url('bui_moveid');
2034          $this->page->ensure_param_not_in_url('bui_newregion');
2035          $this->page->ensure_param_not_in_url('bui_newweight');
2036          return true;
2037      }
2038  
2039      /**
2040       * Turns the display of normal blocks either on or off.
2041       *
2042       * @param bool $setting
2043       */
2044      public function show_only_fake_blocks($setting = true) {
2045          $this->fakeblocksonly = $setting;
2046      }
2047  }
2048  
2049  /// Helper functions for working with block classes ============================
2050  
2051  /**
2052   * Call a class method (one that does not require a block instance) on a block class.
2053   *
2054   * @param string $blockname the name of the block.
2055   * @param string $method the method name.
2056   * @param array $param parameters to pass to the method.
2057   * @return mixed whatever the method returns.
2058   */
2059  function block_method_result($blockname, $method, $param = NULL) {
2060      if(!block_load_class($blockname)) {
2061          return NULL;
2062      }
2063      return call_user_func(array('block_'.$blockname, $method), $param);
2064  }
2065  
2066  /**
2067   * Returns a new instance of the specified block instance id.
2068   *
2069   * @param int $blockinstanceid
2070   * @return block_base the requested block instance.
2071   */
2072  function block_instance_by_id($blockinstanceid) {
2073      global $DB;
2074  
2075      $blockinstance = $DB->get_record('block_instances', ['id' => $blockinstanceid]);
2076      $instance = block_instance($blockinstance->blockname, $blockinstance);
2077      return $instance;
2078  }
2079  
2080  /**
2081   * Creates a new instance of the specified block class.
2082   *
2083   * @param string $blockname the name of the block.
2084   * @param $instance block_instances DB table row (optional).
2085   * @param moodle_page $page the page this block is appearing on.
2086   * @return block_base the requested block instance.
2087   */
2088  function block_instance($blockname, $instance = NULL, $page = NULL) {
2089      if(!block_load_class($blockname)) {
2090          return false;
2091      }
2092      $classname = 'block_'.$blockname;
2093      $retval = new $classname;
2094      if($instance !== NULL) {
2095          if (is_null($page)) {
2096              global $PAGE;
2097              $page = $PAGE;
2098          }
2099          $retval->_load_instance($instance, $page);
2100      }
2101      return $retval;
2102  }
2103  
2104  /**
2105   * Load the block class for a particular type of block.
2106   *
2107   * @param string $blockname the name of the block.
2108   * @return boolean success or failure.
2109   */
2110  function block_load_class($blockname) {
2111      global $CFG;
2112  
2113      if(empty($blockname)) {
2114          return false;
2115      }
2116  
2117      $classname = 'block_'.$blockname;
2118  
2119      if(class_exists($classname)) {
2120          return true;
2121      }
2122  
2123      $blockpath = $CFG->dirroot.'/blocks/'.$blockname.'/block_'.$blockname.'.php';
2124  
2125      if (file_exists($blockpath)) {
2126          require_once($CFG->dirroot.'/blocks/moodleblock.class.php');
2127          include_once($blockpath);
2128      }else{
2129          //debugging("$blockname code does not exist in $blockpath", DEBUG_DEVELOPER);
2130          return false;
2131      }
2132  
2133      return class_exists($classname);
2134  }
2135  
2136  /**
2137   * Given a specific page type, return all the page type patterns that might
2138   * match it.
2139   *
2140   * @param string $pagetype for example 'course-view-weeks' or 'mod-quiz-view'.
2141   * @return array an array of all the page type patterns that might match this page type.
2142   */
2143  function matching_page_type_patterns($pagetype) {
2144      $patterns = array($pagetype);
2145      $bits = explode('-', $pagetype);
2146      if (count($bits) == 3 && $bits[0] == 'mod') {
2147          if ($bits[2] == 'view') {
2148              $patterns[] = 'mod-*-view';
2149          } else if ($bits[2] == 'index') {
2150              $patterns[] = 'mod-*-index';
2151          }
2152      }
2153      while (count($bits) > 0) {
2154          $patterns[] = implode('-', $bits) . '-*';
2155          array_pop($bits);
2156      }
2157      $patterns[] = '*';
2158      return $patterns;
2159  }
2160  
2161  /**
2162   * Give an specific pattern, return all the page type patterns that would also match it.
2163   *
2164   * @param  string $pattern the pattern, e.g. 'mod-forum-*' or 'mod-quiz-view'.
2165   * @return array of all the page type patterns matching.
2166   */
2167  function matching_page_type_patterns_from_pattern($pattern) {
2168      $patterns = array($pattern);
2169      if ($pattern === '*') {
2170          return $patterns;
2171      }
2172  
2173      // Only keep the part before the star because we will append -* to all the bits.
2174      $star = strpos($pattern, '-*');
2175      if ($star !== false) {
2176          $pattern = substr($pattern, 0, $star);
2177      }
2178  
2179      $patterns = array_merge($patterns, matching_page_type_patterns($pattern));
2180      $patterns = array_unique($patterns);
2181  
2182      return $patterns;
2183  }
2184  
2185  /**
2186   * Given a specific page type, parent context and currect context, return all the page type patterns
2187   * that might be used by this block.
2188   *
2189   * @param string $pagetype for example 'course-view-weeks' or 'mod-quiz-view'.
2190   * @param stdClass $parentcontext Block's parent context
2191   * @param stdClass $currentcontext Current context of block
2192   * @return array an array of all the page type patterns that might match this page type.
2193   */
2194  function generate_page_type_patterns($pagetype, $parentcontext = null, $currentcontext = null) {
2195      global $CFG; // Required for includes bellow.
2196  
2197      $bits = explode('-', $pagetype);
2198  
2199      $core = core_component::get_core_subsystems();
2200      $plugins = core_component::get_plugin_types();
2201  
2202      //progressively strip pieces off the page type looking for a match
2203      $componentarray = null;
2204      for ($i = count($bits); $i > 0; $i--) {
2205          $possiblecomponentarray = array_slice($bits, 0, $i);
2206          $possiblecomponent = implode('', $possiblecomponentarray);
2207  
2208          // Check to see if the component is a core component
2209          if (array_key_exists($possiblecomponent, $core) && !empty($core[$possiblecomponent])) {
2210              $libfile = $core[$possiblecomponent].'/lib.php';
2211              if (file_exists($libfile)) {
2212                  require_once($libfile);
2213                  $function = $possiblecomponent.'_page_type_list';
2214                  if (function_exists($function)) {
2215                      if ($patterns = $function($pagetype, $parentcontext, $currentcontext)) {
2216                          break;
2217                      }
2218                  }
2219              }
2220          }
2221  
2222          //check the plugin directory and look for a callback
2223          if (array_key_exists($possiblecomponent, $plugins) && !empty($plugins[$possiblecomponent])) {
2224  
2225              //We've found a plugin type. Look for a plugin name by getting the next section of page type
2226              if (count($bits) > $i) {
2227                  $pluginname = $bits[$i];
2228                  $directory = core_component::get_plugin_directory($possiblecomponent, $pluginname);
2229                  if (!empty($directory)){
2230                      $libfile = $directory.'/lib.php';
2231                      if (file_exists($libfile)) {
2232                          require_once($libfile);
2233                          $function = $possiblecomponent.'_'.$pluginname.'_page_type_list';
2234                          if (!function_exists($function)) {
2235                              $function = $pluginname.'_page_type_list';
2236                          }
2237                          if (function_exists($function)) {
2238                              if ($patterns = $function($pagetype, $parentcontext, $currentcontext)) {
2239                                  break;
2240                              }
2241                          }
2242                      }
2243                  }
2244              }
2245  
2246              //we'll only get to here if we still don't have any patterns
2247              //the plugin type may have a callback
2248              $directory = $plugins[$possiblecomponent];
2249              $libfile = $directory.'/lib.php';
2250              if (file_exists($libfile)) {
2251                  require_once($libfile);
2252                  $function = $possiblecomponent.'_page_type_list';
2253                  if (function_exists($function)) {
2254                      if ($patterns = $function($pagetype, $parentcontext, $currentcontext)) {
2255                          break;
2256                      }
2257                  }
2258              }
2259          }
2260      }
2261  
2262      if (empty($patterns)) {
2263          $patterns = default_page_type_list($pagetype, $parentcontext, $currentcontext);
2264      }
2265  
2266      // Ensure that the * pattern is always available if editing block 'at distance', so
2267      // we always can 'bring back' it to the original context. MDL-30340
2268      if ((!isset($currentcontext) or !isset($parentcontext) or $currentcontext->id != $parentcontext->id) && !isset($patterns['*'])) {
2269          // TODO: We could change the string here, showing its 'bring back' meaning
2270          $patterns['*'] = get_string('page-x', 'pagetype');
2271      }
2272  
2273      return $patterns;
2274  }
2275  
2276  /**
2277   * Generates a default page type list when a more appropriate callback cannot be decided upon.
2278   *
2279   * @param string $pagetype
2280   * @param stdClass $parentcontext
2281   * @param stdClass $currentcontext
2282   * @return array
2283   */
2284  function default_page_type_list($pagetype, $parentcontext = null, $currentcontext = null) {
2285      // Generate page type patterns based on current page type if
2286      // callbacks haven't been defined
2287      $patterns = array($pagetype => $pagetype);
2288      $bits = explode('-', $pagetype);
2289      while (count($bits) > 0) {
2290          $pattern = implode('-', $bits) . '-*';
2291          $pagetypestringname = 'page-'.str_replace('*', 'x', $pattern);
2292          // guessing page type description
2293          if (get_string_manager()->string_exists($pagetypestringname, 'pagetype')) {
2294              $patterns[$pattern] = get_string($pagetypestringname, 'pagetype');
2295          } else {
2296              $patterns[$pattern] = $pattern;
2297          }
2298          array_pop($bits);
2299      }
2300      $patterns['*'] = get_string('page-x', 'pagetype');
2301      return $patterns;
2302  }
2303  
2304  /**
2305   * Generates the page type list for the my moodle page
2306   *
2307   * @param string $pagetype
2308   * @param stdClass $parentcontext
2309   * @param stdClass $currentcontext
2310   * @return array
2311   */
2312  function my_page_type_list($pagetype, $parentcontext = null, $currentcontext = null) {
2313      return array('my-index' => get_string('page-my-index', 'pagetype'));
2314  }
2315  
2316  /**
2317   * Generates the page type list for a module by either locating and using the modules callback
2318   * or by generating a default list.
2319   *
2320   * @param string $pagetype
2321   * @param stdClass $parentcontext
2322   * @param stdClass $currentcontext
2323   * @return array
2324   */
2325  function mod_page_type_list($pagetype, $parentcontext = null, $currentcontext = null) {
2326      $patterns = plugin_page_type_list($pagetype, $parentcontext, $currentcontext);
2327      if (empty($patterns)) {
2328          // if modules don't have callbacks
2329          // generate two default page type patterns for modules only
2330          $bits = explode('-', $pagetype);
2331          $patterns = array($pagetype => $pagetype);
2332          if ($bits[2] == 'view') {
2333              $patterns['mod-*-view'] = get_string('page-mod-x-view', 'pagetype');
2334          } else if ($bits[2] == 'index') {
2335              $patterns['mod-*-index'] = get_string('page-mod-x-index', 'pagetype');
2336          }
2337      }
2338      return $patterns;
2339  }
2340  /// Functions update the blocks if required by the request parameters ==========
2341  
2342  /**
2343   * Return a {@link block_contents} representing the add a new block UI, if
2344   * this user is allowed to see it.
2345   *
2346   * @return block_contents an appropriate block_contents, or null if the user
2347   * cannot add any blocks here.
2348   */
2349  function block_add_block_ui($page, $output) {
2350      global $CFG, $OUTPUT;
2351      if (!$page->user_is_editing() || !$page->user_can_edit_blocks()) {
2352          return null;
2353      }
2354  
2355      $bc = new block_contents();
2356      $bc->title = get_string('addblock');
2357      $bc->add_class('block_adminblock');
2358      $bc->attributes['data-block'] = 'adminblock';
2359  
2360      $missingblocks = $page->blocks->get_addable_blocks();
2361      if (empty($missingblocks)) {
2362          $bc->content = get_string('noblockstoaddhere');
2363          return $bc;
2364      }
2365  
2366      $menu = array();
2367      foreach ($missingblocks as $block) {
2368          $menu[$block->name] = $block->title;
2369      }
2370  
2371      $actionurl = new moodle_url($page->url, array('sesskey'=>sesskey()));
2372      $select = new single_select($actionurl, 'bui_addblock', $menu, null, array(''=>get_string('adddots')), 'add_block');
2373      $select->set_label(get_string('addblock'), array('class'=>'accesshide'));
2374      $bc->content = $OUTPUT->render($select);
2375      return $bc;
2376  }
2377  
2378  /**
2379   * Actually delete from the database any blocks that are currently on this page,
2380   * but which should not be there according to blocks_name_allowed_in_format.
2381   *
2382   * @todo Write/Fix this function. Currently returns immediately
2383   * @param $course
2384   */
2385  function blocks_remove_inappropriate($course) {
2386      // TODO
2387      return;
2388      /*
2389      $blockmanager = blocks_get_by_page($page);
2390  
2391      if (empty($blockmanager)) {
2392          return;
2393      }
2394  
2395      if (($pageformat = $page->pagetype) == NULL) {
2396          return;
2397      }
2398  
2399      foreach($blockmanager as $region) {
2400          foreach($region as $instance) {
2401              $block = blocks_get_record($instance->blockid);
2402              if(!blocks_name_allowed_in_format($block->name, $pageformat)) {
2403                 blocks_delete_instance($instance->instance);
2404              }
2405          }
2406      }*/
2407  }
2408  
2409  /**
2410   * Check that a given name is in a permittable format
2411   *
2412   * @param string $name
2413   * @param string $pageformat
2414   * @return bool
2415   */
2416  function blocks_name_allowed_in_format($name, $pageformat) {
2417      $accept = NULL;
2418      $maxdepth = -1;
2419      if (!$bi = block_instance($name)) {
2420          return false;
2421      }
2422  
2423      $formats = $bi->applicable_formats();
2424      if (!$formats) {
2425          $formats = array();
2426      }
2427      foreach ($formats as $format => $allowed) {
2428          $formatregex = '/^'.str_replace('*', '[^-]*', $format).'.*$/';
2429          $depth = substr_count($format, '-');
2430          if (preg_match($formatregex, $pageformat) && $depth > $maxdepth) {
2431              $maxdepth = $depth;
2432              $accept = $allowed;
2433          }
2434      }
2435      if ($accept === NULL) {
2436          $accept = !empty($formats['all']);
2437      }
2438      return $accept;
2439  }
2440  
2441  /**
2442   * Delete a block, and associated data.
2443   *
2444   * @param object $instance a row from the block_instances table
2445   * @param bool $nolongerused legacy parameter. Not used, but kept for backwards compatibility.
2446   * @param bool $skipblockstables for internal use only. Makes @see blocks_delete_all_for_context() more efficient.
2447   */
2448  function blocks_delete_instance($instance, $nolongerused = false, $skipblockstables = false) {
2449      global $DB;
2450  
2451      // Allow plugins to use this block before we completely delete it.
2452      if ($pluginsfunction = get_plugins_with_function('pre_block_delete')) {
2453          foreach ($pluginsfunction as $plugintype => $plugins) {
2454              foreach ($plugins as $pluginfunction) {
2455                  $pluginfunction($instance);
2456              }
2457          }
2458      }
2459  
2460      if ($block = block_instance($instance->blockname, $instance)) {
2461          $block->instance_delete();
2462      }
2463      context_helper::delete_instance(CONTEXT_BLOCK, $instance->id);
2464  
2465      if (!$skipblockstables) {
2466          $DB->delete_records('block_positions', array('blockinstanceid' => $instance->id));
2467          $DB->delete_records('block_instances', array('id' => $instance->id));
2468          $DB->delete_records_list('user_preferences', 'name', array('block'.$instance->id.'hidden','docked_block_instance_'.$instance->id));
2469      }
2470  }
2471  
2472  /**
2473   * Delete multiple blocks at once.
2474   *
2475   * @param array $instanceids A list of block instance ID.
2476   */
2477  function blocks_delete_instances($instanceids) {
2478      global $DB;
2479  
2480      $limit = 1000;
2481      $count = count($instanceids);
2482      $chunks = [$instanceids];
2483      if ($count > $limit) {
2484          $chunks = array_chunk($instanceids, $limit);
2485      }
2486  
2487      // Perform deletion for each chunk.
2488      foreach ($chunks as $chunk) {
2489          $instances = $DB->get_recordset_list('block_instances', 'id', $chunk);
2490          foreach ($instances as $instance) {
2491              blocks_delete_instance($instance, false, true);
2492          }
2493          $instances->close();
2494  
2495          $DB->delete_records_list('block_positions', 'blockinstanceid', $chunk);
2496          $DB->delete_records_list('block_instances', 'id', $chunk);
2497  
2498          $preferences = array();
2499          foreach ($chunk as $instanceid) {
2500              $preferences[] = 'block' . $instanceid . 'hidden';
2501              $preferences[] = 'docked_block_instance_' . $instanceid;
2502          }
2503          $DB->delete_records_list('user_preferences', 'name', $preferences);
2504      }
2505  }
2506  
2507  /**
2508   * Delete all the blocks that belong to a particular context.
2509   *
2510   * @param int $contextid the context id.
2511   */
2512  function blocks_delete_all_for_context($contextid) {
2513      global $DB;
2514      $instances = $DB->get_recordset('block_instances', array('parentcontextid' => $contextid));
2515      foreach ($instances as $instance) {
2516          blocks_delete_instance($instance, true);
2517      }
2518      $instances->close();
2519      $DB->delete_records('block_instances', array('parentcontextid' => $contextid));
2520      $DB->delete_records('block_positions', array('contextid' => $contextid));
2521  }
2522  
2523  /**
2524   * Set a block to be visible or hidden on a particular page.
2525   *
2526   * @param object $instance a row from the block_instances, preferably LEFT JOINed with the
2527   *      block_positions table as return by block_manager.
2528   * @param moodle_page $page the back to set the visibility with respect to.
2529   * @param integer $newvisibility 1 for visible, 0 for hidden.
2530   */
2531  function blocks_set_visibility($instance, $page, $newvisibility) {
2532      global $DB;
2533      if (!empty($instance->blockpositionid)) {
2534          // Already have local information on this page.
2535          $DB->set_field('block_positions', 'visible', $newvisibility, array('id' => $instance->blockpositionid));
2536          return;
2537      }
2538  
2539      // Create a new block_positions record.
2540      $bp = new stdClass;
2541      $bp->blockinstanceid = $instance->id;
2542      $bp->contextid = $page->context->id;
2543      $bp->pagetype = $page->pagetype;
2544      if ($page->subpage) {
2545          $bp->subpage = $page->subpage;
2546      }
2547      $bp->visible = $newvisibility;
2548      $bp->region = $instance->defaultregion;
2549      $bp->weight = $instance->defaultweight;
2550      $DB->insert_record('block_positions', $bp);
2551  }
2552  
2553  /**
2554   * Get the block record for a particular blockid - that is, a particular type os block.
2555   *
2556   * @param $int blockid block type id. If null, an array of all block types is returned.
2557   * @param bool $notusedanymore No longer used.
2558   * @return array|object row from block table, or all rows.
2559   */
2560  function blocks_get_record($blockid = NULL, $notusedanymore = false) {
2561      global $PAGE;
2562      $blocks = $PAGE->blocks->get_installed_blocks();
2563      if ($blockid === NULL) {
2564          return $blocks;
2565      } else if (isset($blocks[$blockid])) {
2566          return $blocks[$blockid];
2567      } else {
2568          return false;
2569      }
2570  }
2571  
2572  /**
2573   * Find a given block by its blockid within a provide array
2574   *
2575   * @param int $blockid
2576   * @param array $blocksarray
2577   * @return bool|object Instance if found else false
2578   */
2579  function blocks_find_block($blockid, $blocksarray) {
2580      if (empty($blocksarray)) {
2581          return false;
2582      }
2583      foreach($blocksarray as $blockgroup) {
2584          if (empty($blockgroup)) {
2585              continue;
2586          }
2587          foreach($blockgroup as $instance) {
2588              if($instance->blockid == $blockid) {
2589                  return $instance;
2590              }
2591          }
2592      }
2593      return false;
2594  }
2595  
2596  // Functions for programatically adding default blocks to pages ================
2597  
2598   /**
2599    * Parse a list of default blocks. See config-dist for a description of the format.
2600    *
2601    * @param string $blocksstr Determines the starting point that the blocks are added in the region.
2602    * @return array the parsed list of default blocks
2603    */
2604  function blocks_parse_default_blocks_list($blocksstr) {
2605      $blocks = array();
2606      $bits = explode(':', $blocksstr);
2607      if (!empty($bits)) {
2608          $leftbits = trim(array_shift($bits));
2609          if ($leftbits != '') {
2610              $blocks[BLOCK_POS_LEFT] = explode(',', $leftbits);
2611          }
2612      }
2613      if (!empty($bits)) {
2614          $rightbits = trim(array_shift($bits));
2615          if ($rightbits != '') {
2616              $blocks[BLOCK_POS_RIGHT] = explode(',', $rightbits);
2617          }
2618      }
2619      return $blocks;
2620  }
2621  
2622  /**
2623   * @return array the blocks that should be added to the site course by default.
2624   */
2625  function blocks_get_default_site_course_blocks() {
2626      global $CFG;
2627  
2628      if (isset($CFG->defaultblocks_site)) {
2629          return blocks_parse_default_blocks_list($CFG->defaultblocks_site);
2630      } else {
2631          return array(
2632              BLOCK_POS_LEFT => array(),
2633              BLOCK_POS_RIGHT => array()
2634          );
2635      }
2636  }
2637  
2638  /**
2639   * Add the default blocks to a course.
2640   *
2641   * @param object $course a course object.
2642   */
2643  function blocks_add_default_course_blocks($course) {
2644      global $CFG;
2645  
2646      if (isset($CFG->defaultblocks_override)) {
2647          $blocknames = blocks_parse_default_blocks_list($CFG->defaultblocks_override);
2648  
2649      } else if ($course->id == SITEID) {
2650          $blocknames = blocks_get_default_site_course_blocks();
2651  
2652      } else if (isset($CFG->{'defaultblocks_' . $course->format})) {
2653          $blocknames = blocks_parse_default_blocks_list($CFG->{'defaultblocks_' . $course->format});
2654  
2655      } else {
2656          require_once($CFG->dirroot. '/course/lib.php');
2657          $blocknames = course_get_format($course)->get_default_blocks();
2658  
2659      }
2660  
2661      if ($course->id == SITEID) {
2662          $pagetypepattern = 'site-index';
2663      } else {
2664          $pagetypepattern = 'course-view-*';
2665      }
2666      $page = new moodle_page();
2667      $page->set_course($course);
2668      $page->blocks->add_blocks($blocknames, $pagetypepattern);
2669  }
2670  
2671  /**
2672   * Add the default system-context blocks. E.g. the admin tree.
2673   */
2674  function blocks_add_default_system_blocks() {
2675      global $DB;
2676  
2677      $page = new moodle_page();
2678      $page->set_context(context_system::instance());
2679      // We don't add blocks required by the theme, they will be auto-created.
2680      $page->blocks->add_blocks(array(BLOCK_POS_LEFT => array('admin_bookmarks')), 'admin-*', null, null, 2);
2681  
2682      if ($defaultmypage = $DB->get_record('my_pages', array('userid' => null, 'name' => '__default', 'private' => 1))) {
2683          $subpagepattern = $defaultmypage->id;
2684      } else {
2685          $subpagepattern = null;
2686      }
2687  
2688      if ($defaultmycoursespage = $DB->get_record('my_pages', array('userid' => null, 'name' => '__courses', 'private' => 0))) {
2689          $mycoursesubpagepattern = $defaultmycoursespage->id;
2690      } else {
2691          $mycoursesubpagepattern = null;
2692      }
2693  
2694      $page->blocks->add_blocks([
2695          BLOCK_POS_RIGHT => [
2696              'recentlyaccesseditems',
2697          ],
2698          'content' => [
2699              'timeline',
2700              'calendar_month',
2701          ]],
2702          'my-index',
2703          $subpagepattern
2704      );
2705  
2706      $page->blocks->add_blocks([
2707          'content' => [
2708              'myoverview'
2709          ]],
2710          'my-index',
2711          $mycoursesubpagepattern
2712      );
2713  }