lib/blocklib.php

   1 <?php //$Id$
   2
   3 //This library includes all the necessary stuff to use blocks in course pages
   4
   5 define('BLOCK_MOVE_LEFT',   0x01);
   6 define('BLOCK_MOVE_RIGHT',  0x02);
   7 define('BLOCK_MOVE_UP',     0x04);
   8 define('BLOCK_MOVE_DOWN',   0x08);
   9 define('BLOCK_CONFIGURE',   0x10);
  10
  11 define('BLOCK_POS_LEFT',  'l');
  12 define('BLOCK_POS_RIGHT', 'r');
  13
  14 define('BLOCKS_PINNED_TRUE',0);
  15 define('BLOCKS_PINNED_FALSE',1);
  16 define('BLOCKS_PINNED_BOTH',2);
  17
  18 require_once($CFG->libdir.'/pagelib.php');
  19 require_once($CFG->dirroot.'/course/lib.php'); // needed to solve all those: Call to undefined function: print_recent_activity() when adding Recent Activity
  20
  21 // Returns false if this block is incompatible with the current version of Moodle.
  22 function block_is_compatible($blockname) {
  23     global $CFG;
  24
  25     $file = @file($CFG->dirroot.'/blocks/'.$blockname.'/block_'.$blockname.'.php'); // ignore errors when file does not exist
  26     if(empty($file)) {
  27         return NULL;
  28     }
  29
  30     foreach($file as $line) {
  31         // If you find MoodleBlock (appearing in the class declaration) it's not compatible
  32         if(strpos($line, 'MoodleBlock')) {
  33             return false;
  34         }
  35         // But if we find a { it means the class declaration is over, so it's compatible
  36         else if(strpos($line, '{')) {
  37             return true;
  38         }
  39     }
  40
  41     return NULL;
  42 }
  43
  44 // Returns the case-sensitive name of the class' constructor function. This includes both
  45 // PHP5- and PHP4-style constructors. If no appropriate constructor can be found, returns NULL.
  46 // If there is no such class, returns boolean false.
  47 function get_class_constructor($classname) {
  48     // Caching
  49     static $constructors = array();
  50
  51     if(!class_exists($classname)) {
  52         return false;
  53     }
  54
  55     // Tests indicate this doesn't hurt even in PHP5.
  56     $classname = strtolower($classname);
  57
  58     // Return cached value, if exists
  59     if(isset($constructors[$classname])) {
  60         return $constructors[$classname];
  61     }
  62
  63     // Get a list of methods. After examining several different ways of
  64     // doing the check, (is_callable, method_exists, function_exists etc)
  65     // it seems that this is the most reliable one.
  66     $methods = get_class_methods($classname);
  67
  68     // PHP5 constructor?
  69     if(phpversion() >= '5') {
  70         if(in_array('__construct', $methods)) {
  71             return $constructors[$classname] = '__construct';
  72         }
  73     }
  74
  75     // If we have PHP5 but no magic constructor, we have to lowercase the methods
  76     $methods = array_map('strtolower', $methods);
  77
  78     if(in_array($classname, $methods)) {
  79         return $constructors[$classname] = $classname;
  80     }
  81
  82     return $constructors[$classname] = NULL;
  83 }
  84
  85 //This function retrieves a method-defined property of a class WITHOUT instantiating an object
  86 function block_method_result($blockname, $method, $param = NULL) {
  87     if(!block_load_class($blockname)) {
  88         return NULL;
  89     }
  90     return call_user_func(array('block_'.$blockname, $method), $param);
  91 }
  92
  93 //This function creates a new object of the specified block class
  94 function block_instance($blockname, $instance = NULL) {
  95     if(!block_load_class($blockname)) {
  96         return false;
  97     }
  98     $classname = 'block_'.$blockname;
  99     $retval = new $classname;
 100     if($instance !== NULL) {
 101         $retval->_load_instance($instance);
 102     }
 103     return $retval;
 104 }
 105
 106 //This function loads the necessary class files for a block
 107 //Whenever you want to load a block, use this first
 108 function block_load_class($blockname) {
 109     global $CFG;
 110
 111     if(empty($blockname)) {
 112         return false;
 113     }
 114
 115     $classname = 'block_'.$blockname;
 116
 117     if(class_exists($classname)) {
 118         return true;
 119     }
 120
 121     require_once($CFG->dirroot.'/blocks/moodleblock.class.php');
 122     @include_once($CFG->dirroot.'/blocks/'.$blockname.'/block_'.$blockname.'.php'); // do not throw errors if block code not present
 123
 124     return class_exists($classname);
 125 }
 126
 127 // This function returns an array with the IDs of any blocks that you can add to your page.
 128 // Parameters are passed by reference for speed; they are not modified at all.
 129 function blocks_get_missing(&$page, &$pageblocks) {
 130
 131     $missingblocks = array();
 132     $allblocks = blocks_get_record();
 133     $pageformat = $page->get_format_name();
 134
 135     if(!empty($allblocks)) {
 136         foreach($allblocks as $block) {
 137             if($block->visible && (!blocks_find_block($block->id, $pageblocks) || $block->multiple)) {
 138                 // And if it's applicable for display in this format...
 139                 if(blocks_name_allowed_in_format($block->name, $pageformat)) {
 140                     // ...add it to the missing blocks
 141                     $missingblocks[] = $block->id;
 142                 }
 143             }
 144         }
 145     }
 146     return $missingblocks;
 147 }
 148
 149 function blocks_remove_inappropriate($page) {
 150     $pageblocks = blocks_get_by_page($page);
 151
 152     if(empty($pageblocks)) {
 153         return;
 154     }
 155
 156     if(($pageformat = $page->get_format_name()) == NULL) {
 157         return;
 158     }
 159
 160     foreach($pageblocks as $position) {
 161         foreach($position as $instance) {
 162             $block = blocks_get_record($instance->blockid);
 163             if(!blocks_name_allowed_in_format($block->name, $pageformat)) {
 164                blocks_delete_instance($instance);
 165             }
 166         }
 167     }
 168 }
 169
 170 function blocks_name_allowed_in_format($name, $pageformat) {
 171
 172     $accept  = NULL;
 173     $depth   = -1;
 174     if ($formats = block_method_result($name, 'applicable_formats')) {
 175         foreach($formats as $format => $allowed) {
 176             $thisformat = '^'.str_replace('*', '[^-]*', $format).'.*$';
 177             if(ereg($thisformat, $pageformat)) {
 178                 if(($scount = substr_count($format, '-')) > $depth) {
 179                     $depth  = $scount;
 180                     $accept = $allowed;
 181                 }
 182             }
 183         }
 184     }
 185     if($accept === NULL) {
 186         $accept = !empty($formats['all']);
 187     }
 188     return $accept;
 189 }
 190
 191 function blocks_delete_instance($instance,$pinned=false) {
 192     global $CFG;
 193
 194     // Get the block object and call instance_delete() if possible
 195     if($record = blocks_get_record($instance->blockid)) {
 196         if($obj = block_instance($record->name, $instance)) {
 197             // Return value ignored
 198             $obj->instance_delete();
 199         }
 200     }
 201
 202     if (!empty($pinned)) {
 203          delete_records('block_pinned', 'id', $instance->id);
 204         // And now, decrement the weight of all blocks after this one
 205         execute_sql('UPDATE '.$CFG->prefix.'block_pinned SET weight = weight - 1 WHERE pagetype = \''.$instance->pagetype.
 206                     '\' AND position = \''.$instance->position.
 207                     '\' AND weight > '.$instance->weight, false);
 208     } else {
 209         // Now kill the db record;
 210         delete_records('block_instance', 'id', $instance->id);
 211         // And now, decrement the weight of all blocks after this one
 212         execute_sql('UPDATE '.$CFG->prefix.'block_instance SET weight = weight - 1 WHERE pagetype = \''.$instance->pagetype.
 213                     '\' AND pageid = '.$instance->pageid.' AND position = \''.$instance->position.
 214                     '\' AND weight > '.$instance->weight, false);
 215     }
 216     return true;
 217 }
 218
 219 // Accepts an array of block instances and checks to see if any of them have content to display
 220 // (causing them to calculate their content in the process). Returns true or false. Parameter passed
 221 // by reference for speed; the array is actually not modified.
 222 function blocks_have_content(&$pageblocks, $position) {
 223
 224     if (empty($pageblocks) || !is_array($pageblocks) || !array_key_exists($position,$pageblocks)) {
 225         return false;
 226     }
 227     // use a for() loop to get references to the array elements
 228     // foreach() cannot fetch references in PHP v4.x
 229     for ($n=0; $n<count($pageblocks[$position]);$n++) {
 230         $instance = &$pageblocks[$position][$n];
 231         if(!$instance->visible) {
 232             continue;
 233         }
 234         if(!$record = blocks_get_record($instance->blockid)) {
 235             continue;
 236         }
 237         if(!$obj = block_instance($record->name, $instance)) {
 238             continue;
 239         }
 240         if(!$obj->is_empty()) {
 241             // cache rec and obj
 242             // for blocks_print_group()
 243             $instance->rec = $record;
 244             $instance->obj = $obj;
 245             return true;
 246         }
 247     }
 248
 249     return false;
 250 }
 251
 252 // This function prints one group of blocks in a page
 253 // Parameters passed by reference for speed; they are not modified.
 254 function blocks_print_group(&$page, &$pageblocks, $position) {
 255     global $COURSE;
 256
 257     if(empty($pageblocks[$position])) {
 258         $pageblocks[$position] = array();
 259         $maxweight = 0;
 260     }
 261     else {
 262         $maxweight = max(array_keys($pageblocks[$position]));
 263     }
 264
 265     foreach ($pageblocks[$position] as $instance) {
 266         if (!empty($instance->pinned)) {
 267             $maxweight--;
 268         }
 269     }
 270
 271     $isediting = $page->user_is_editing();
 272     foreach($pageblocks[$position] as $instance) {
 273
 274         // $instance may have ->rec and ->obj
 275         // cached from when we walked $pageblocks
 276         // in blocks_have_content()
 277         if (empty($instance->rec)) {
 278             $block = blocks_get_record($instance->blockid);
 279         } else {
 280             $block = $instance->rec;
 281         }
 282
 283         if (empty($block)) {
 284             // Block doesn't exist! We should delete this instance!
 285             continue;
 286         }
 287
 288         if(!$block->visible) {
 289             // Disabled by the admin
 290             continue;
 291         }
 292
 293         if (empty($instance->obj)) {
 294             if (!$obj = block_instance($block->name, $instance)) {
 295                 // Invalid block
 296                 continue;
 297             }
 298         } else {
 299             $obj = $instance->obj;
 300         }
 301
 302         $editalways = $page->edit_always();
 303
 304         if (($isediting  && empty($instance->pinned)) || !empty($editalways)) {
 305             $options = 0;
 306             // The block can be moved up if it's NOT the first one in its position. If it is, we look at the OR clause:
 307             // the first block might still be able to move up if the page says so (i.e., it will change position)
 308             $options |= BLOCK_MOVE_UP    * ($instance->weight != 0          || ($page->blocks_move_position($instance, BLOCK_MOVE_UP)   != $instance->position));
 309             // Same thing for downward movement
 310             $options |= BLOCK_MOVE_DOWN  * ($instance->weight != $maxweight || ($page->blocks_move_position($instance, BLOCK_MOVE_DOWN) != $instance->position));
 311             // For left and right movements, it's up to the page to tell us whether they are allowed
 312             $options |= BLOCK_MOVE_RIGHT * ($page->blocks_move_position($instance, BLOCK_MOVE_RIGHT) != $instance->position);
 313             $options |= BLOCK_MOVE_LEFT  * ($page->blocks_move_position($instance, BLOCK_MOVE_LEFT ) != $instance->position);
 314             // Finally, the block can be configured if the block class either allows multiple instances, or if it specifically
 315             // allows instance configuration (multiple instances override that one). It doesn't have anything to do with what the
 316             // administrator has allowed for this block in the site admin options.
 317             $options |= BLOCK_CONFIGURE * ( $obj->instance_allow_multiple() || $obj->instance_allow_config() );
 318             $obj->_add_edit_controls($options);
 319         }
 320
 321         if (!$instance->visible && empty($COURSE->javascriptportal)) {
 322             if ($isediting) {
 323                 $obj->_print_shadow();
 324             }
 325         } else {
 326             global $COURSE;
 327             if(!empty($COURSE->javascriptportal)) {
 328                  $COURSE->javascriptportal->currentblocksection = $position;
 329             }
 330             $obj->_print_block();
 331         }
 332         if (!empty($COURSE->javascriptportal)
 333                     && (empty($instance->pinned) || !$instance->pinned)) {
 334             $COURSE->javascriptportal->block_add('inst'.$instance->id, !$instance->visible);
 335         }
 336     } // End foreach
 337
 338
 339     //  Check if
 340     //    we are on the default position/side AND
 341     //    we're editing the page AND
 342     //    (
 343     //      we have the capability to manage blocks OR
 344     //      we are in myMoodle page AND have the capibility to manage myMoodle blocks
 345     //    )
 346     if ($page->blocks_default_position() == $position && $page->user_is_editing() && (has_capability('moodle/site:manageblocks', get_context_instance(CONTEXT_COURSE, $COURSE->id)) || ($page->type == PAGE_MY_MOODLE && has_capability('moodle/my:manageblocks', get_context_instance(CONTEXT_COURSE, $COURSE->id)))) ) {
 347         blocks_print_adminblock($page, $pageblocks);
 348     }
 349 }
 350
 351 // This iterates over an array of blocks and calculates the preferred width
 352 // Parameter passed by reference for speed; it's not modified.
 353 function blocks_preferred_width(&$instances) {
 354     $width = 0;
 355
 356     if(empty($instances) || !is_array($instances)) {
 357         return 0;
 358     }
 359
 360     $blocks = blocks_get_record();
 361
 362     foreach($instances as $instance) {
 363         if(!$instance->visible) {
 364             continue;
 365         }
 366
 367         if (!array_key_exists($instance->blockid, $blocks)) {
 368             // Block doesn't exist! We should delete this instance!
 369             continue;
 370         }
 371
 372         if(!$blocks[$instance->blockid]->visible) {
 373             continue;
 374         }
 375         $pref = block_method_result($blocks[$instance->blockid]->name, 'preferred_width');
 376         if($pref === NULL) {
 377             continue;
 378         }
 379         if($pref > $width) {
 380             $width = $pref;
 381         }
 382     }
 383     return $width;
 384 }
 385
 386 function blocks_get_record($blockid = NULL, $invalidate = false) {
 387     static $cache = NULL;
 388
 389     if($invalidate || empty($cache)) {
 390         $cache = get_records('block');
 391     }
 392
 393     if($blockid === NULL) {
 394         return $cache;
 395     }
 396
 397     return (isset($cache[$blockid])? $cache[$blockid] : false);
 398 }
 399
 400 function blocks_find_block($blockid, $blocksarray) {
 401     if (empty($blocksarray)) {
 402         return false;
 403     }
 404     foreach($blocksarray as $blockgroup) {
 405         if (empty($blockgroup)) {
 406             continue;
 407         }
 408         foreach($blockgroup as $instance) {
 409             if($instance->blockid == $blockid) {
 410                 return $instance;
 411             }
 412         }
 413     }
 414     return false;
 415 }
 416
 417 function blocks_find_instance($instanceid, $blocksarray) {
 418     foreach($blocksarray as $subarray) {
 419         foreach($subarray as $instance) {
 420             if($instance->id == $instanceid) {
 421                 return $instance;
 422             }
 423         }
 424     }
 425     return false;
 426 }
 427
 428 // Simple entry point for anyone that wants to use blocks
 429 function blocks_setup(&$PAGE,$pinned=BLOCKS_PINNED_FALSE) {
 430     switch ($pinned) {
 431     case BLOCKS_PINNED_TRUE:
 432         $pageblocks = blocks_get_pinned($PAGE);
 433         break;
 434     case BLOCKS_PINNED_BOTH:
 435         $pageblocks = blocks_get_by_page_pinned($PAGE);
 436         break;
 437     case BLOCKS_PINNED_FALSE:
 438     default:
 439         $pageblocks = blocks_get_by_page($PAGE);
 440         break;
 441     }
 442     blocks_execute_url_action($PAGE, $pageblocks,($pinned==BLOCKS_PINNED_TRUE));
 443     return $pageblocks;
 444 }
 445
 446 function blocks_execute_action($page, &$pageblocks, $blockaction, $instanceorid, $pinned=false, $redirect=true) {
 447     global $CFG;
 448
 449     if (is_int($instanceorid)) {
 450         $blockid = $instanceorid;
 451     } else if (is_object($instanceorid)) {
 452         $instance = $instanceorid;
 453     }
 454
 455     switch($blockaction) {
 456         case 'config':
 457             global $USER;
 458             $block = blocks_get_record($instance->blockid);
 459             // Hacky hacky tricky stuff to get the original human readable block title,
 460             // even if the block has configured its title to be something else.
 461             // Create the object WITHOUT instance data.
 462             $blockobject = block_instance($block->name);
 463             if ($blockobject === false) {
 464                 break;
 465             }
 466
 467             // First of all check to see if the block wants to be edited
 468             if(!$blockobject->user_can_edit()) {
 469                 break;
 470             }
 471
 472             // Now get the title and AFTER that load up the instance
 473             $blocktitle = $blockobject->get_title();
 474             $blockobject->_load_instance($instance);
 475
 476             optional_param('submitted', 0, PARAM_INT);
 477
 478             // Define the data we're going to silently include in the instance config form here,
 479             // so we can strip them from the submitted data BEFORE serializing it.
 480             $hiddendata = array(
 481                 'sesskey' => $USER->sesskey,
 482                 'instanceid' => $instance->id,
 483                 'blockaction' => 'config'
 484             );
 485
 486             // To this data, add anything the page itself needs to display
 487             $hiddendata = array_merge($hiddendata, $page->url_get_parameters());
 488
 489             if($data = data_submitted()) {
 490                 $remove = array_keys($hiddendata);
 491                 foreach($remove as $item) {
 492                     unset($data->$item);
 493                 }
 494                 if(!$blockobject->instance_config_save($data,$pinned)) {
 495                     error('Error saving block configuration');
 496                 }
 497                 // And nothing more, continue with displaying the page
 498             }
 499             else {
 500                 // We need to show the config screen, so we highjack the display logic and then die
 501                 $strheading = get_string('blockconfiga', 'moodle', $blocktitle);
 502                 $page->print_header(get_string('pageheaderconfigablock', 'moodle'), array($strheading => ''));
 503
 504                 echo '<div class="block-config" id="'.$block->name.'">';   /// Make CSS easier
 505
 506                 print_heading($strheading);
 507                 echo '<form method="post" action="'. $page->url_get_path() .'">';
 508                 echo '<p>';
 509                 foreach($hiddendata as $name => $val) {
 510                     echo '<input type="hidden" name="'. $name .'" value="'. $val .'" />';
 511                 }
 512                 echo '</p>';
 513                 $blockobject->instance_config_print();
 514                 echo '</form>';
 515
 516                 echo '</div>';
 517                 $CFG->pagepath = 'blocks/' . $block->name;
 518                 print_footer();
 519                 die(); // Do not go on with the other page-related stuff
 520             }
 521         break;
 522         case 'toggle':
 523             if(empty($instance))  {
 524                 error('Invalid block instance for '.$blockaction);
 525             }
 526             $instance->visible = ($instance->visible) ? 0 : 1;
 527             if (!empty($pinned)) {
 528                 update_record('block_pinned', $instance);
 529             } else {
 530                 update_record('block_instance', $instance);
 531             }
 532         break;
 533         case 'delete':
 534             if(empty($instance))  {
 535                 error('Invalid block instance for '. $blockaction);
 536             }
 537             blocks_delete_instance($instance, $pinned);
 538         break;
 539         case 'moveup':
 540             if(empty($instance))  {
 541                 error('Invalid block instance for '. $blockaction);
 542             }
 543
 544             if($instance->weight == 0) {
 545                 // The block is the first one, so a move "up" probably means it changes position
 546                 // Where is the instance going to be moved?
 547                 $newpos = $page->blocks_move_position($instance, BLOCK_MOVE_UP);
 548                 $newweight = (empty($pageblocks[$newpos]) ? 0 : max(array_keys($pageblocks[$newpos])) + 1);
 549
 550                 blocks_execute_repositioning($instance, $newpos, $newweight, $pinned);
 551             }
 552             else {
 553                 // The block is just moving upwards in the same position.
 554                 // This configuration will make sure that even if somehow the weights
 555                 // become not continuous, block move operations will eventually bring
 556                 // the situation back to normal without printing any warnings.
 557                 if(!empty($pageblocks[$instance->position][$instance->weight - 1])) {
 558                     $other = $pageblocks[$instance->position][$instance->weight - 1];
 559                 }
 560                 if(!empty($other)) {
 561                     ++$other->weight;
 562                     if (!empty($pinned)) {
 563                         update_record('block_pinned', $other);
 564                     } else {
 565                         update_record('block_instance', $other);
 566                     }
 567                 }
 568                 --$instance->weight;
 569                 if (!empty($pinned)) {
 570                     update_record('block_pinned', $instance);
 571                 } else {
 572                     update_record('block_instance', $instance);
 573                 }
 574             }
 575         break;
 576         case 'movedown':
 577             if(empty($instance))  {
 578                 error('Invalid block instance for '. $blockaction);
 579             }
 580
 581             if($instance->weight == max(array_keys($pageblocks[$instance->position]))) {
 582                 // The block is the last one, so a move "down" probably means it changes position
 583                 // Where is the instance going to be moved?
 584                 $newpos = $page->blocks_move_position($instance, BLOCK_MOVE_DOWN);
 585                 $newweight = (empty($pageblocks[$newpos]) ? 0 : max(array_keys($pageblocks[$newpos])) + 1);
 586
 587                 blocks_execute_repositioning($instance, $newpos, $newweight, $pinned);
 588             }
 589             else {
 590                 // The block is just moving downwards in the same position.
 591                 // This configuration will make sure that even if somehow the weights
 592                 // become not continuous, block move operations will eventually bring
 593                 // the situation back to normal without printing any warnings.
 594                 if(!empty($pageblocks[$instance->position][$instance->weight + 1])) {
 595                     $other = $pageblocks[$instance->position][$instance->weight + 1];
 596                 }
 597                 if(!empty($other)) {
 598                     --$other->weight;
 599                     if (!empty($pinned)) {
 600                         update_record('block_pinned', $other);
 601                     } else {
 602                         update_record('block_instance', $other);
 603                     }
 604                 }
 605                 ++$instance->weight;
 606                 if (!empty($pinned)) {
 607                     update_record('block_pinned', $instance);
 608                 } else {
 609                     update_record('block_instance', $instance);
 610                 }
 611             }
 612         break;
 613         case 'moveleft':
 614             if(empty($instance))  {
 615                 error('Invalid block instance for '. $blockaction);
 616             }
 617
 618             // Where is the instance going to be moved?
 619             $newpos = $page->blocks_move_position($instance, BLOCK_MOVE_LEFT);
 620             $newweight = (empty($pageblocks[$newpos]) ? 0 : max(array_keys($pageblocks[$newpos])) + 1);
 621
 622             blocks_execute_repositioning($instance, $newpos, $newweight, $pinned);
 623         break;
 624         case 'moveright':
 625             if(empty($instance))  {
 626                 error('Invalid block instance for '. $blockaction);
 627             }
 628
 629             // Where is the instance going to be moved?
 630             $newpos    = $page->blocks_move_position($instance, BLOCK_MOVE_RIGHT);
 631             $newweight = (empty($pageblocks[$newpos]) ? 0 : max(array_keys($pageblocks[$newpos])) + 1);
 632
 633             blocks_execute_repositioning($instance, $newpos, $newweight, $pinned);
 634         break;
 635         case 'add':
 636             // Add a new instance of this block, if allowed
 637             $block = blocks_get_record($blockid);
 638
 639             if(empty($block) || !$block->visible) {
 640                 // Only allow adding if the block exists and is enabled
 641                 break;
 642             }
 643
 644             if(!$block->multiple && blocks_find_block($blockid, $pageblocks) !== false) {
 645                 // If no multiples are allowed and we already have one, return now
 646                 break;
 647             }
 648
 649             if(!block_method_result($block->name, 'user_can_addto', $page)) {
 650                 // If the block doesn't want to be added...
 651                 break;
 652             }
 653
 654             $newpos = $page->blocks_default_position();
 655             if (!empty($pinned)) {
 656                 $sql = 'SELECT 1, max(weight) + 1 AS nextfree FROM '. $CFG->prefix .'block_pinned WHERE '
 657                     .' pagetype = \''. $page->get_type() .'\' AND position = \''. $newpos .'\'';
 658             } else {
 659                 $sql = 'SELECT 1, max(weight) + 1 AS nextfree FROM '. $CFG->prefix .'block_instance WHERE pageid = '. $page->get_id()
 660                     .' AND pagetype = \''. $page->get_type() .'\' AND position = \''. $newpos .'\'';
 661             }
 662             $weight = get_record_sql($sql);
 663
 664             $newinstance = new stdClass;
 665             $newinstance->blockid    = $blockid;
 666             if (empty($pinned)) {
 667                 $newinstance->pageid = $page->get_id();
 668             }
 669             $newinstance->pagetype   = $page->get_type();
 670             $newinstance->position   = $newpos;
 671             $newinstance->weight     = empty($weight->nextfree) ? 0 : $weight->nextfree;
 672             $newinstance->visible    = 1;
 673             $newinstance->configdata = '';
 674             if (!empty($pinned)) {
 675                 $newinstance->id = insert_record('block_pinned', $newinstance);
 676             } else {
 677                 $newinstance->id = insert_record('block_instance', $newinstance);
 678             }
 679
 680             // If the new instance was created, allow it to do additional setup
 681             if($newinstance && ($obj = block_instance($block->name, $newinstance))) {
 682                 // Return value ignored
 683                 $obj->instance_create();
 684             }
 685
 686         break;
 687     }
 688
 689     if ($redirect) {
 690         // In order to prevent accidental duplicate actions, redirect to a page with a clean url
 691         redirect($page->url_get_full());
 692     }
 693 }
 694
 695 // You can use this to get the blocks to respond to URL actions without much hassle
 696 function blocks_execute_url_action(&$PAGE, &$pageblocks,$pinned=false) {
 697     $blockaction = optional_param('blockaction', '', PARAM_ALPHA);
 698
 699     if (empty($blockaction) || !$PAGE->user_allowed_editing() || !confirm_sesskey()) {
 700         return;
 701     }
 702
 703     $instanceid  = optional_param('instanceid', 0, PARAM_INT);
 704     $blockid     = optional_param('blockid',    0, PARAM_INT);
 705
 706     if (!empty($blockid)) {
 707         blocks_execute_action($PAGE, $pageblocks, strtolower($blockaction), $blockid, $pinned);
 708
 709     }
 710     else if (!empty($instanceid)) {
 711         $instance = blocks_find_instance($instanceid, $pageblocks);
 712         blocks_execute_action($PAGE, $pageblocks, strtolower($blockaction), $instance, $pinned);
 713     }
 714 }
 715
 716 // This shouldn't be used externally at all, it's here for use by blocks_execute_action()
 717 // in order to reduce code repetition.
 718 function blocks_execute_repositioning(&$instance, $newpos, $newweight, $pinned=false) {
 719     global $CFG;
 720
 721     // If it's staying where it is, don't do anything, unless overridden
 722     if ($newpos == $instance->position) {
 723         return;
 724     }
 725
 726     // Close the weight gap we 'll leave behind
 727     if (!empty($pinned)) {
 728         $sql = 'UPDATE '. $CFG->prefix .'block_instance SET weight = weight - 1 '.
 729                         'WHERE pagetype = \''. $instance->pagetype.
 730                         '\' AND position = \'' .$instance->position.
 731                         '\' AND weight > '. $instance->weight;
 732     } else {
 733         $sql = 'UPDATE '. $CFG->prefix .'block_instance SET weight = weight - 1 '.
 734                         'WHERE pagetype = \''. $instance->pagetype.
 735                         '\' AND pageid = '. $instance->pageid .
 736                         ' AND position = \'' .$instance->position.
 737                         '\' AND weight > '. $instance->weight;
 738     }
 739     execute_sql($sql,false);
 740
 741     $instance->position = $newpos;
 742     $instance->weight   = $newweight;
 743
 744     if (!empty($pinned)) {
 745         update_record('block_pinned', $instance);
 746     } else {
 747         update_record('block_instance', $instance);
 748     }
 749 }
 750
 751
 752 /**
 753  * Moves a block to the new position (column) and weight (sort order).
 754  * @param $instance - The block instance to be moved.
 755  * @param $destpos - BLOCK_POS_LEFT or BLOCK_POS_RIGHT. The destination column.
 756  * @param $destweight - The destination sort order. If NULL, we add to the end
 757  *                      of the destination column.
 758  * @param $pinned - Are we moving pinned blocks? We can only move pinned blocks
 759  *                  to a new position withing the pinned list. Likewise, we
 760  *                  can only moved non-pinned blocks to a new position within
 761  *                  the non-pinned list.
 762  * @return boolean (success or failure).
 763  */
 764 function blocks_move_block($page, &$instance, $destpos, $destweight=NULL, $pinned=false) {
 765     global $CFG;
 766
 767     if ($pinned) {
 768         $blocklist = blocks_get_pinned($page);
 769     } else {
 770         $blocklist = blocks_get_by_page($page);
 771     }
 772
 773     if ($blocklist[$instance->position][$instance->weight]->id != $instance->id) {
 774         // The source block instance is not where we think it is.
 775         return false;
 776     }
 777
 778     // First we close the gap that will be left behind when we take out the
 779     // block from it's current column.
 780     if ($pinned) {
 781         $closegapsql = "UPDATE {$CFG->prefix}block_instance
 782                            SET weight = weight - 1
 783                          WHERE weight > '$instance->weight'
 784                            AND position = '$instance->position'
 785                            AND pagetype = '$instance->pagetype'";
 786     } else {
 787         $closegapsql = "UPDATE {$CFG->prefix}block_instance
 788                            SET weight = weight - 1
 789                          WHERE weight > '$instance->weight'
 790                            AND position = '$instance->position'
 791                            AND pagetype = '$instance->pagetype'
 792                            AND pageid = '$instance->pageid'";
 793     }
 794     if (!execute_sql($closegapsql, false)) {
 795         return false;
 796     }
 797
 798     // Now let's make space for the block being moved.
 799     if ($pinned) {
 800         $opengapsql = "UPDATE {$CFG->prefix}block_instance
 801                            SET weight = weight + 1
 802                          WHERE weight >= '$destweight'
 803                            AND position = '$destpos'
 804                            AND pagetype = '$instance->pagetype'";
 805     } else {
 806         $opengapsql = "UPDATE {$CFG->prefix}block_instance
 807                            SET weight = weight + 1
 808                          WHERE weight >= '$destweight'
 809                            AND position = '$destpos'
 810                            AND pagetype = '$instance->pagetype'
 811                            AND pageid = '$instance->pageid'";
 812     }
 813     if (!execute_sql($opengapsql, false)) {
 814         return false;
 815     }
 816
 817     // Move the block.
 818     $instance->position = $destpos;
 819     $instance->weight   = $destweight;
 820
 821     if ($pinned) {
 822         $table = 'block_pinned';
 823     } else {
 824         $table = 'block_instance';
 825     }
 826     return update_record($table, $instance);
 827 }
 828
 829
 830 /**
 831  * Returns an array consisting of 2 arrays:
 832  * 1) Array of pinned blocks for position BLOCK_POS_LEFT
 833  * 2) Array of pinned blocks for position BLOCK_POS_RIGHT
 834  */
 835 function blocks_get_pinned($page) {
 836
 837     $visible = true;
 838
 839     if (method_exists($page,'edit_always')) {
 840         if ($page->edit_always()) {
 841             $visible = false;
 842         }
 843     }
 844
 845     $blocks = get_records_select('block_pinned', 'pagetype = \''. $page->get_type() .
 846                     '\''.(($visible) ? 'AND visible = 1' : ''), 'position, weight');
 847
 848     $positions = $page->blocks_get_positions();
 849     $arr = array();
 850
 851     foreach($positions as $key => $position) {
 852         $arr[$position] = array();
 853     }
 854
 855     if(empty($blocks)) {
 856         return $arr;
 857     }
 858
 859     foreach($blocks as $block) {
 860         $block->pinned = true; // so we know we can't move it.
 861         // make up an instanceid if we can..
 862         $block->pageid = $page->get_id();
 863         $arr[$block->position][$block->weight] = $block;
 864     }
 865
 866     return $arr;
 867 }
 868
 869
 870 /**
 871  * Similar to blocks_get_by_page(), except that, the array returned includes
 872  * pinned blocks as well. Pinned blocks are always appended before normal
 873  * block instances.
 874  */
 875 function blocks_get_by_page_pinned($page) {
 876     $pinned = blocks_get_pinned($page);
 877     $user = blocks_get_by_page($page);
 878
 879     $weights = array();
 880
 881     foreach ($pinned as $pos => $arr) {
 882         $weights[$pos] = count($arr);
 883     }
 884
 885     foreach ($user as $pos => $blocks) {
 886         if (!array_key_exists($pos,$pinned)) {
 887              $pinned[$pos] = array();
 888         }
 889         if (!array_key_exists($pos,$weights)) {
 890             $weights[$pos] = 0;
 891         }
 892         foreach ($blocks as $block) {
 893             $pinned[$pos][$weights[$pos]] = $block;
 894             $weights[$pos]++;
 895         }
 896     }
 897     return $pinned;
 898 }
 899
 900
 901 /**
 902  * Returns an array of blocks for the page. Pinned blocks are excluded.
 903  */
 904 function blocks_get_by_page($page) {
 905     $blocks = get_records_select('block_instance', "pageid = '". $page->get_id() .
 906                 "' AND pagetype = '". $page->get_type() ."'", 'position, weight');
 907
 908     $positions = $page->blocks_get_positions();
 909     $arr = array();
 910     foreach($positions as $key => $position) {
 911         $arr[$position] = array();
 912     }
 913
 914     if(empty($blocks)) {
 915         return $arr;
 916     }
 917
 918     foreach($blocks as $block) {
 919         $arr[$block->position][$block->weight] = $block;
 920     }
 921     return $arr;
 922 }
 923
 924
 925 //This function prints the block to admin blocks as necessary
 926 function blocks_print_adminblock(&$page, &$pageblocks) {
 927     global $USER;
 928
 929     $missingblocks = blocks_get_missing($page, $pageblocks);
 930
 931     if (!empty($missingblocks)) {
 932         $strblocks = get_string('blocks');
 933         $stradd    = get_string('add');
 934         foreach ($missingblocks as $blockid) {
 935             $block = blocks_get_record($blockid);
 936             $blockobject = block_instance($block->name);
 937             if ($blockobject === false) {
 938                 continue;
 939             }
 940             if(!$blockobject->user_can_addto($page)) {
 941                 continue;
 942             }
 943             $menu[$block->id] = $blockobject->get_title();
 944         }
 945         asort($menu);
 946
 947         $target = $page->url_get_full(array('sesskey' => $USER->sesskey, 'blockaction' => 'add'));
 948         $content = popup_form($target.'&amp;blockid=', $menu, 'add_block', '', $stradd .'...', '', '', true);
 949         print_side_block($strblocks, $content, NULL, NULL, NULL, array('class' => 'block_adminblock'));
 950     }
 951 }
 952
 953 function blocks_repopulate_page($page) {
 954     global $CFG;
 955
 956     $allblocks = blocks_get_record();
 957
 958     if(empty($allblocks)) {
 959         error('Could not retrieve blocks from the database');
 960     }
 961
 962     // Assemble the information to correlate block names to ids
 963     $idforname = array();
 964     foreach($allblocks as $block) {
 965         $idforname[$block->name] = $block->id;
 966     }
 967
 968     /// If the site override has been defined, it is the only valid one.
 969     if (!empty($CFG->defaultblocks_override)) {
 970         $blocknames = $CFG->defaultblocks_override;
 971     }
 972     else {
 973         $blocknames = $page->blocks_get_default();
 974     }
 975
 976     $positions = $page->blocks_get_positions();
 977     $posblocks = explode(':', $blocknames);
 978
 979     // Now one array holds the names of the positions, and the other one holds the blocks
 980     // that are going to go in each position. Luckily for us, both arrays are numerically
 981     // indexed and the indexes match, so we can work straight away... but CAREFULLY!
 982
 983     // Ready to start creating block instances, but first drop any existing ones
 984     delete_records('block_instance', 'pageid', $page->get_id(), 'pagetype', $page->get_type());
 985
 986     // Here we slyly count $posblocks and NOT $positions. This can actually make a difference
 987     // if the textual representation has undefined slots in the end. So we only work with as many
 988     // positions were retrieved, not with all the page says it has available.
 989     $numpositions = count($posblocks);
 990     for($i = 0; $i < $numpositions; ++$i) {
 991         $position = $positions[$i];
 992         $blocknames = explode(',', $posblocks[$i]);
 993         $weight = 0;
 994         foreach($blocknames as $blockname) {
 995             $newinstance = new stdClass;
 996             $newinstance->blockid    = $idforname[$blockname];
 997             $newinstance->pageid     = $page->get_id();
 998             $newinstance->pagetype   = $page->get_type();
 999             $newinstance->position   = $position;
1000             $newinstance->weight     = $weight;
1001             $newinstance->visible    = 1;
1002             $newinstance->configdata = '';
1003
1004             if(!empty($newinstance->blockid)) {
1005                 // Only add block if it was recognized
1006                 insert_record('block_instance', $newinstance);
1007                 ++$weight;
1008             }
1009         }
1010     }
1011
1012     return true;
1013 }
1014
1015 function upgrade_blocks_db($continueto) {
1016 /// This function upgrades the blocks tables, if necessary
1017 /// It's called from admin/index.php
1018
1019     global $CFG, $db;
1020
1021     require_once ($CFG->dirroot .'/blocks/version.php');  // Get code versions
1022
1023     if (empty($CFG->blocks_version)) {                  // Blocks have never been installed.
1024         $strdatabaseupgrades = get_string('databaseupgrades');
1025         print_header($strdatabaseupgrades, $strdatabaseupgrades, $strdatabaseupgrades, '',
1026                 upgrade_get_javascript(), false, '&nbsp;', '&nbsp;');
1027
1028         upgrade_log_start();
1029         print_heading('blocks');
1030         $db->debug=true;
1031
1032     /// Both old .sql files and new install.xml are supported
1033     /// but we priorize install.xml (XMLDB) if present
1034         $status = false;
1035         if (file_exists($CFG->dirroot . '/blocks/db/install.xml')) {
1036             $status = install_from_xmldb_file($CFG->dirroot . '/blocks/db/install.xml'); //New method
1037         } else if (file_exists($CFG->dirroot . '/blocks/db/' . $CFG->dbtype . '.sql')) {
1038             $status = modify_database($CFG->dirroot . '/blocks/db/' . $CFG->dbtype . '.sql'); //Old method
1039         }
1040
1041         $db->debug = false;
1042         if ($status) {
1043             if (set_config('blocks_version', $blocks_version)) {
1044                 notify(get_string('databasesuccess'), 'notifysuccess');
1045                 notify(get_string('databaseupgradeblocks', '', $blocks_version), 'notifysuccess');
1046                 print_continue($continueto);
1047                 print_footer('none');
1048                 exit;
1049             } else {
1050                 error('Upgrade of blocks system failed! (Could not update version in config table)');
1051             }
1052         } else {
1053             error('Blocks tables could NOT be set up successfully!');
1054         }
1055     }
1056
1057 /// Upgrading code starts here
1058     $oldupgrade = false;
1059     $newupgrade = false;
1060     if (is_readable($CFG->dirroot . '/blocks/db/' . $CFG->dbtype . '.php')) {
1061         include_once($CFG->dirroot . '/blocks/db/' . $CFG->dbtype . '.php');  // defines old upgrading function
1062         $oldupgrade = true;
1063     }
1064     if (is_readable($CFG->dirroot . '/blocks/db/upgrade.php')) {
1065         include_once($CFG->dirroot . '/blocks/db/upgrade.php');  // defines new upgrading function
1066         $newupgrade = true;
1067     }
1068
1069     if ($blocks_version > $CFG->blocks_version) {       // Upgrade tables
1070         $strdatabaseupgrades = get_string('databaseupgrades');
1071         print_header($strdatabaseupgrades, $strdatabaseupgrades, $strdatabaseupgrades, '', upgrade_get_javascript());
1072
1073         upgrade_log_start();
1074         print_heading('blocks');
1075
1076     /// Run de old and new upgrade functions for the module
1077         $oldupgrade_function = 'blocks_upgrade';
1078         $newupgrade_function = 'xmldb_blocks_upgrade';
1079
1080     /// First, the old function if exists
1081         $oldupgrade_status = true;
1082         if ($oldupgrade && function_exists($oldupgrade_function)) {
1083             $db->debug = true;
1084             $oldupgrade_status = $oldupgrade_function($CFG->blocks_version);
1085         } else if ($oldupgrade) {
1086             notify ('Upgrade function ' . $oldupgrade_function . ' was not available in ' .
1087                      '/blocks/db/' . $CFG->dbtype . '.php');
1088         }
1089
1090     /// Then, the new function if exists and the old one was ok
1091         $newupgrade_status = true;
1092         if ($newupgrade && function_exists($newupgrade_function) && $oldupgrade_status) {
1093             $db->debug = true;
1094             $newupgrade_status = $newupgrade_function($CFG->blocks_version);
1095         } else if ($newupgrade) {
1096             notify ('Upgrade function ' . $newupgrade_function . ' was not available in ' .
1097                      '/blocks/db/upgrade.php');
1098         }
1099
1100         $db->debug=false;
1101     /// Now analyze upgrade results
1102         if ($oldupgrade_status && $newupgrade_status) {    // No upgrading failed
1103             if (set_config('blocks_version', $blocks_version)) {
1104                 notify(get_string('databasesuccess'), 'notifysuccess');
1105                 notify(get_string('databaseupgradeblocks', '', $blocks_version), 'notifysuccess');
1106                 print_continue($continueto);
1107                 print_footer('none');
1108                 exit;
1109             } else {
1110                 error('Upgrade of blocks system failed! (Could not update version in config table)');
1111             }
1112         } else {
1113             error('Upgrade failed!  See blocks/version.php');
1114         }
1115
1116     } else if ($blocks_version < $CFG->blocks_version) {
1117         upgrade_log_start();
1118         notify('WARNING!!!  The Blocks version you are using is OLDER than the version that made these databases!');
1119     }
1120     upgrade_log_finish();
1121 }
1122
1123 //This function finds all available blocks and install them
1124 //into blocks table or do all the upgrade process if newer
1125 function upgrade_blocks_plugins($continueto) {
1126
1127     global $CFG, $db;
1128
1129     $blocktitles = array();
1130     $invalidblocks = array();
1131     $validblocks = array();
1132     $notices = array();
1133
1134     //Count the number of blocks in db
1135     $blockcount = count_records('block');
1136     //If there isn't records. This is the first install, so I remember it
1137     if ($blockcount == 0) {
1138         $first_install = true;
1139     } else {
1140         $first_install = false;
1141     }
1142
1143     $site = get_site();
1144
1145     if (!$blocks = get_list_of_plugins('blocks', 'db') ) {
1146         error('No blocks installed!');
1147     }
1148
1149     include_once($CFG->dirroot .'/blocks/moodleblock.class.php');
1150     if(!class_exists('block_base')) {
1151         error('Class block_base is not defined or file not found for /blocks/moodleblock.class.php');
1152     }
1153
1154     foreach ($blocks as $blockname) {
1155
1156         if ($blockname == 'NEWBLOCK') {   // Someone has unzipped the template, ignore it
1157             continue;
1158         }
1159
1160         if(!block_is_compatible($blockname)) {
1161             // This is an old-style block
1162             //$notices[] = 'Block '. $blockname .' is not compatible with the current version of Mooodle and needs to be updated by a programmer.';
1163             $invalidblocks[] = $blockname;
1164             continue;
1165         }
1166
1167         $fullblock = $CFG->dirroot .'/blocks/'. $blockname;
1168
1169         if ( is_readable($fullblock.'/block_'.$blockname.'.php')) {
1170             include_once($fullblock.'/block_'.$blockname.'.php');
1171         } else {
1172             $notices[] = 'Block '. $blockname .': '. $fullblock .'/block_'. $blockname .'.php was not readable';
1173             continue;
1174         }
1175
1176         $oldupgrade = false;
1177         $newupgrade = false;
1178         if ( @is_dir($fullblock .'/db/')) {
1179             if ( @is_readable($fullblock .'/db/'. $CFG->dbtype .'.php')) {
1180                 include_once($fullblock .'/db/'. $CFG->dbtype .'.php');  // defines old upgrading function
1181                 $oldupgrade = true;
1182             }
1183             if ( @is_readable($fullblock .'/db/upgrade.php')) {
1184                 include_once($fullblock .'/db/upgrade.php');  // defines new upgrading function
1185                 $newupgrade = true;
1186             }
1187         }
1188
1189         $classname = 'block_'.$blockname;
1190         if(!class_exists($classname)) {
1191             $notices[] = 'Block '. $blockname .': '. $classname .' not implemented';
1192             continue;
1193         }
1194
1195         // Here is the place to see if the block implements a constructor (old style),
1196         // an init() function (new style) or nothing at all (error time).
1197
1198         $constructor = get_class_constructor($classname);
1199         if(empty($constructor)) {
1200             // No constructor
1201             $notices[] = 'Block '. $blockname .': class does not have a constructor';
1202             $invalidblocks[] = $blockname;
1203             continue;
1204         }
1205
1206         $block    = new stdClass;     // This may be used to update the db below
1207         $blockobj = new $classname;   // This is what we 'll be testing
1208
1209         // Inherits from block_base?
1210         if(!is_subclass_of($blockobj, 'block_base')) {
1211             $notices[] = 'Block '. $blockname .': class does not inherit from block_base';
1212             continue;
1213         }
1214
1215         // OK, it's as we all hoped. For further tests, the object will do them itself.
1216         if(!$blockobj->_self_test()) {
1217             $notices[] = 'Block '. $blockname .': self test failed';
1218             continue;
1219         }
1220         $block->version = $blockobj->get_version();
1221
1222         if (!isset($block->version)) {
1223             $notices[] = 'Block '. $blockname .': has no version support. It must be updated by a programmer.';
1224             continue;
1225         }
1226
1227         $block->name = $blockname;   // The name MUST match the directory
1228         $blocktitle = $blockobj->get_title();
1229
1230         if ($currblock = get_record('block', 'name', $block->name)) {
1231             if ($currblock->version == $block->version) {
1232                 // do nothing
1233             } else if ($currblock->version < $block->version) {
1234                 if (empty($updated_blocks)) {
1235                     $strblocksetup    = get_string('blocksetup');
1236                     print_header($strblocksetup, $strblocksetup, $strblocksetup, '',
1237                             upgrade_get_javascript(), false, '&nbsp;', '&nbsp;');
1238                 }
1239                 $updated_blocks = true;
1240                 upgrade_log_start();
1241                 print_heading('New version of '.$blocktitle.' ('.$block->name.') exists');
1242                 @set_time_limit(0);  // To allow slow databases to complete the long SQL
1243
1244             /// Run de old and new upgrade functions for the module
1245                 $oldupgrade_function = $block->name .'_upgrade';
1246                 $newupgrade_function = 'xmldb_block_' . $block->name .'_upgrade';
1247
1248             /// First, the old function if exists
1249                 $oldupgrade_status = true;
1250                 if ($oldupgrade && function_exists($oldupgrade_function)) {
1251                     $db->debug = true;
1252                     $oldupgrade_status = $oldupgrade_function($currblock->version, $block);
1253                 } else if ($oldupgrade) {
1254                     notify ('Upgrade function ' . $oldupgrade_function . ' was not available in ' .
1255                              $fullblock . '/db/' . $CFG->dbtype . '.php');
1256                 }
1257
1258             /// Then, the new function if exists and the old one was ok
1259                 $newupgrade_status = true;
1260                 if ($newupgrade && function_exists($newupgrade_function) && $oldupgrade_status) {
1261                     $db->debug = true;
1262                     $newupgrade_status = $newupgrade_function($currblock->version, $block);
1263                 } else if ($newupgrade) {
1264                     notify ('Upgrade function ' . $newupgrade_function . ' was not available in ' .
1265                              $fullblock . '/db/upgrade.php');
1266                 }
1267
1268                 $db->debug=false;
1269             /// Now analyze upgrade results
1270                 if ($oldupgrade_status && $newupgrade_status) {    // No upgrading failed
1271                     // OK so far, now update the block record
1272                     $block->id = $currblock->id;
1273                     if (! update_record('block', $block)) {
1274                         error('Could not update block '. $block->name .' record in block table!');
1275                     }
1276                     $component = 'block/'.$block->name;
1277                     if (!update_capabilities($component)) {
1278                         error('Could not update '.$block->name.' capabilities!');
1279                     }
1280
1281                     events_update_definition($component);
1282                     notify(get_string('blocksuccess', '', $blocktitle), 'notifysuccess');
1283                 } else {
1284                     notify('Upgrading block '. $block->name .' from '. $currblock->version .' to '. $block->version .' FAILED!');
1285                 }
1286                 echo '<hr />';
1287             } else {
1288                 upgrade_log_start();
1289                 error('Version mismatch: block '. $block->name .' can\'t downgrade '. $currblock->version .' -> '. $block->version .'!');
1290             }
1291
1292         } else {    // block not installed yet, so install it
1293
1294             // If it allows multiples, start with it enabled
1295             $block->multiple = $blockobj->instance_allow_multiple();
1296             if (!empty($blockobj->cron)) {
1297                 $block->cron = $blockobj->cron;
1298             }
1299
1300             // [pj] Normally this would be inline in the if, but we need to
1301             //      check for NULL (necessary for 4.0.5 <= PHP < 4.2.0)
1302             $conflictblock = array_search($blocktitle, $blocktitles);
1303             if($conflictblock !== false && $conflictblock !== NULL) {
1304                 // Duplicate block titles are not allowed, they confuse people
1305                 // AND PHP's associative arrays ;)
1306                 error('<strong>Naming conflict</strong>: block <strong>'.$block->name.'</strong> has the same title with an existing block, <strong>'.$conflictblock.'</strong>!');
1307             }
1308             if (empty($updated_blocks)) {
1309                 $strblocksetup    = get_string('blocksetup');
1310                 print_header($strblocksetup, $strblocksetup, $strblocksetup, '',
1311                         upgrade_get_javascript(), false, '&nbsp;', '&nbsp;');
1312             }
1313             $updated_blocks = true;
1314             upgrade_log_start();
1315             print_heading($block->name);
1316             $db->debug = true;
1317             @set_time_limit(0);  // To allow slow databases to complete the long SQL
1318
1319         /// Both old .sql files and new install.xml are supported
1320         /// but we priorize install.xml (XMLDB) if present
1321             $status = false;
1322             if (file_exists($fullblock . '/db/install.xml')) {
1323                 $status = install_from_xmldb_file($fullblock . '/db/install.xml'); //New method
1324             } else if (file_exists($fullblock .'/db/'. $CFG->dbtype .'.sql')) {
1325                 $status = modify_database($fullblock .'/db/'. $CFG->dbtype .'.sql'); //Old method
1326             } else {
1327                 $status = true;
1328             }
1329
1330             $db->debug = false;
1331             if ($status) {
1332                 if ($block->id = insert_record('block', $block)) {
1333                     $blockobj->after_install();
1334                     $component = 'block/'.$block->name;
1335                     if (!update_capabilities($component)) {
1336                         notify('Could not set up '.$block->name.' capabilities!');
1337                     }
1338
1339                     events_update_definition($component);
1340                     notify(get_string('blocksuccess', '', $blocktitle), 'notifysuccess');
1341                     echo '<hr />';
1342                 } else {
1343                     error($block->name .' block could not be added to the block list!');
1344                 }
1345             } else {
1346                 error('Block '. $block->name .' tables could NOT be set up successfully!');
1347             }
1348         }
1349
1350         $blocktitles[$block->name] = $blocktitle;
1351     }
1352
1353     if(!empty($notices)) {
1354         upgrade_log_start();
1355         foreach($notices as $notice) {
1356             notify($notice);
1357         }
1358     }
1359
1360     // Finally, if we are in the first_install of BLOCKS (this means that we are
1361     // upgrading from Moodle < 1.3), put blocks in all existing courses.
1362     if ($first_install) {
1363         upgrade_log_start();
1364         //Iterate over each course
1365         if ($courses = get_records('course')) {
1366             foreach ($courses as $course) {
1367                 $page = page_create_object(PAGE_COURSE_VIEW, $course->id);
1368                 blocks_repopulate_page($page);
1369             }
1370         }
1371     }
1372
1373     if (!empty($CFG->siteblocksadded)) {     /// This is a once-off hack to make a proper upgrade
1374         upgrade_log_start();
1375         $page = page_create_object(PAGE_COURSE_VIEW, SITEID);
1376         blocks_repopulate_page($page);
1377         delete_records('config', 'name', 'siteblocksadded');
1378     }
1379
1380     upgrade_log_finish();
1381
1382     if (!empty($updated_blocks)) {
1383         print_continue($continueto);
1384         print_footer('none');
1385         die;
1386     }
1387 }
1388
1389 ?>