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