nucleus/libs/PLUGIN.php

   1 <?php
   2 /*
   3  * Nucleus: PHP/MySQL Weblog CMS (http://nucleuscms.org/)
   4  * Copyright (C) 2002-2009 The Nucleus Group
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  * (see nucleus/documentation/index.html#license for more info)
  11  */
  12 /**
  13  * This is an (abstract) class of which all Nucleus Plugins must inherit
  14  *
  15  * for more information on plugins and how to write your own, see the
  16  * plugins.html file that is included with the Nucleus documenation
  17  *
  18  * @license http://nucleuscms.org/license.txt GNU General Public License
  19  * @copyright Copyright (C) 2002-2009 The Nucleus Group
  20  * @version $Id: PLUGIN.php 1629 2012-01-28 09:52:25Z sakamocchi $
  21  */
  22 class NucleusPlugin
  23 {
  24         // these functions _have_ to be redefined in your plugin
  25         function getName()
  26         {
  27                 return 'Undefined';
  28         }
  29
  30         function getAuthor()
  31         {
  32                 return 'Undefined';
  33         }
  34
  35         function getURL()
  36         {
  37                 return 'Undefined';
  38         }
  39
  40         function getVersion()
  41         {
  42                 return '0.0';
  43         }
  44
  45         function getDescription()
  46         {
  47                 return 'Undefined';
  48         }
  49
  50         // these function _may_ be redefined in your plugin
  51
  52         function getMinNucleusVersion()
  53         {
  54                 return 150;
  55         }
  56
  57         function getMinNucleusPatchLevel()
  58         {
  59                 return 0;
  60         }
  61
  62         function getEventList()
  63         {
  64                 return array();
  65         }
  66
  67         function getTableList()
  68         {
  69                 return array();
  70         }
  71
  72         function hasAdminArea()
  73         {
  74                 return 0;
  75         }
  76
  77         function install()
  78         {
  79         }
  80
  81         function unInstall()
  82         {
  83         }
  84
  85         function init()
  86         {
  87         }
  88
  89         function doSkinVar($skinType)
  90         {
  91         }
  92
  93         function doTemplateVar(&$item)
  94         {
  95                 $args = func_get_args();
  96                 array_shift($args);
  97                 array_unshift($args, 'template');
  98                 call_user_func_array(array(&$this,'doSkinVar'),$args);
  99         }
 100
 101         function doTemplateCommentsVar(&$item, &$comment)
 102         {
 103                 $args = func_get_args();
 104                 array_shift($args);
 105                 array_shift($args);
 106                 array_unshift($args, 'template');
 107                 call_user_func_array(array(&$this,'doSkinVar'),$args);
 108         }
 109
 110         function doAction($type)
 111         {
 112                 return _ERROR_PLUGIN_NOSUCHACTION;
 113         }
 114
 115         function doIf($key,$value)
 116         {
 117                 return false;
 118         }
 119
 120         function doItemVar (&$item)
 121         {
 122         }
 123
 124         /**
 125          * Checks if a plugin supports a certain feature.
 126          *
 127          * @returns 1 if the feature is reported, 0 if not
 128          * @param $feature
 129          *              Name of the feature. See plugin documentation for more info
 130          *                      'SqlTablePrefix' -> if the plugin uses the sql_table() method to get table names
 131          *                      'HelpPage' -> if the plugin provides a helppage
 132          *                      'SqlApi' -> if the plugin uses the complete sql_* api (must also require nucleuscms 3.5)
 133          */
 134         function supportsFeature($feature)
 135         {
 136                 return 0;
 137         }
 138
 139         /**
 140          * Report a list of plugin that is required to function
 141          *
 142          * @returns an array of names of plugin, an empty array indicates no dependency
 143          */
 144         function getPluginDep()
 145         {
 146                 return array();
 147         }
 148
 149         // these helper functions should not be redefined in your plugin
 150
 151         /**
 152          * Creates a new option for this plugin
 153          *
 154          * @param name
 155          *              A string uniquely identifying your option. (max. length is 20 characters)
 156          * @param description
 157          *              A description that will show up in the nucleus admin area (max. length: 255 characters)
 158          * @param type
 159          *              Either 'text', 'yesno' or 'password'
 160          *              This info is used when showing 'edit plugin options' screens
 161          * @param value
 162          *              Initial value for the option (max. value length is 128 characters)
 163          */
 164         function createOption($name, $desc, $type, $defValue = '', $typeExtras = '')
 165         {
 166                 return $this->_createOption('global', $name, $desc, $type, $defValue, $typeExtras);
 167         }
 168
 169         function createBlogOption($name, $desc, $type, $defValue = '', $typeExtras = '')
 170         {
 171                 return $this->_createOption('blog', $name, $desc, $type, $defValue, $typeExtras);
 172         }
 173
 174         function createMemberOption($name, $desc, $type, $defValue = '', $typeExtras = '')
 175         {
 176                 return $this->_createOption('member', $name, $desc, $type, $defValue, $typeExtras);
 177         }
 178
 179         function createCategoryOption($name, $desc, $type, $defValue = '', $typeExtras = '')
 180         {
 181                 return $this->_createOption('category', $name, $desc, $type, $defValue, $typeExtras);
 182         }
 183
 184         function createItemOption($name, $desc, $type, $defValue = '', $typeExtras = '')
 185         {
 186                 return $this->_createOption('item', $name, $desc, $type, $defValue, $typeExtras);
 187         }
 188
 189         /**
 190          * Removes the option from the database
 191          *
 192          * Note: Options get erased automatically on plugin uninstall
 193          */
 194         function deleteOption($name)
 195         {
 196                 return $this->_deleteOption('global', $name);
 197         }
 198
 199         function deleteBlogOption($name)
 200         {
 201                 return $this->_deleteOption('blog', $name);
 202         }
 203
 204         function deleteMemberOption($name)
 205         {
 206                 return $this->_deleteOption('member', $name);
 207         }
 208
 209         function deleteCategoryOption($name)
 210         {
 211                 return $this->_deleteOption('category', $name);
 212         }
 213
 214         function deleteItemOption($name)
 215         {
 216                 return $this->_deleteOption('item', $name);
 217         }
 218
 219         /**
 220          * Sets the value of an option to something new
 221          */
 222         function setOption($name, $value)
 223         {
 224                 return $this->_setOption('global', 0, $name, $value);
 225         }
 226
 227         function setBlogOption($blogid, $name, $value)
 228         {
 229                 return $this->_setOption('blog', $blogid, $name, $value);
 230         }
 231
 232         function setMemberOption($memberid, $name, $value)
 233         {
 234                 return $this->_setOption('member', $memberid, $name, $value);
 235         }
 236
 237         function setCategoryOption($catid, $name, $value)
 238         {
 239                 return $this->_setOption('category', $catid, $name, $value);
 240         }
 241
 242         function setItemOption($itemid, $name, $value) {
 243                 return $this->_setOption('item', $itemid, $name, $value);
 244         }
 245
 246         /**
 247          * Retrieves the current value for an option
 248          */
 249         function getOption($name)
 250         {
 251                 // only request the options the very first time. On subsequent requests
 252                 // the static collection is used to save SQL queries.
 253                 if ( $this->plugin_options == 0 )
 254                 {
 255                         $this->plugin_options = array();
 256                         $query = sql_query(
 257                                  'SELECT d.oname as name, o.ovalue as value '.
 258                                  'FROM '.
 259                                  sql_table('plugin_option').' o, '.
 260                                  sql_table('plugin_option_desc').' d '.
 261                                  'WHERE d.opid='. intval($this->getID()).' AND d.oid=o.oid'
 262                         );
 263                         while ( $row = sql_fetch_object($query) )
 264                         {
 265                                 $this->plugin_options[strtolower($row->name)] = $row->value;
 266                         }
 267                 }
 268                 if ( isset($this->plugin_options[strtolower($name)]) )
 269                 {
 270                         return $this->plugin_options[strtolower($name)];
 271                 }
 272                 else
 273                 {
 274                         return $this->_getOption('global', 0, $name);
 275                 }
 276         }
 277
 278         function getBlogOption($blogid, $name)
 279         {
 280                 return $this->_getOption('blog', $blogid, $name);
 281         }
 282
 283         function getMemberOption($memberid, $name)
 284         {
 285                 return $this->_getOption('member', $memberid, $name);
 286         }
 287
 288         function getCategoryOption($catid, $name)
 289         {
 290                 return $this->_getOption('category', $catid, $name);
 291         }
 292
 293         function getItemOption($itemid, $name)
 294         {
 295                 return $this->_getOption('item', $itemid, $name);
 296         }
 297
 298         /**
 299          * Retrieves an associative array with the option value for each
 300          * context id
 301          */
 302         function getAllBlogOptions($name)
 303         {
 304                 return $this->_getAllOptions('blog', $name);
 305         }
 306
 307         function getAllMemberOptions($name)
 308         {
 309                 return $this->_getAllOptions('member', $name);
 310         }
 311
 312         function getAllCategoryOptions($name)
 313         {
 314                 return $this->_getAllOptions('category', $name);
 315         }
 316
 317         function getAllItemOptions($name)
 318         {
 319                 return $this->_getAllOptions('item', $name);
 320         }
 321
 322         /**
 323          * Retrieves an indexed array with the top (or bottom) of an option
 324          * (delegates to _getOptionTop())
 325          */
 326         function getBlogOptionTop($name, $amount = 10, $sort = 'desc')
 327         {
 328                 return $this->_getOptionTop('blog', $name, $amount, $sort);
 329         }
 330
 331         function getMemberOptionTop($name, $amount = 10, $sort = 'desc')
 332         {
 333                 return $this->_getOptionTop('member', $name, $amount, $sort);
 334         }
 335
 336         function getCategoryOptionTop($name, $amount = 10, $sort = 'desc')
 337         {
 338                 return $this->_getOptionTop('category', $name, $amount, $sort);
 339         }
 340
 341         function getItemOptionTop($name, $amount = 10, $sort = 'desc')
 342         {
 343                 return $this->_getOptionTop('item', $name, $amount, $sort);
 344         }
 345
 346         /**
 347          * Returns the plugin ID
 348          *
 349          * public
 350          */
 351         function getID()
 352         {
 353                 return $this->plugid;
 354         }
 355
 356         /**
 357          * Returns the URL of the admin area for this plugin (in case there's
 358          * no such area, the returned information is invalid)
 359          *
 360          * public
 361          */
 362         function getAdminURL()
 363         {
 364                 global $CONF;
 365                 return $CONF['PluginURL'] . $this->getShortName() . '/';
 366         }
 367
 368         /**
 369          * Returns the directory where the admin directory is located and
 370          * where the plugin can maintain his extra files
 371          *
 372          * public
 373          */
 374         function getDirectory()
 375         {
 376                 global $DIR_PLUGINS;
 377                 return $DIR_PLUGINS . $this->getShortName() . '/';
 378         }
 379
 380         /**
 381          * Derives the short name for the plugin from the classname (all
 382          * lowercase)
 383          *
 384          * public
 385          */
 386         function getShortName()
 387         {
 388                 return str_replace('np_','',strtolower(get_class($this)));
 389         }
 390
 391         /**
 392          *      Clears the option value cache which saves the option values during
 393          *      the plugin execution. This function is usefull if the options has
 394          *      changed during the plugin execution (especially in association with
 395          *      the PrePluginOptionsUpdate and the PostPluginOptionsUpdate events)
 396          *
 397          *  public
 398          **/
 399         function clearOptionValueCache()
 400         {
 401                 $this->_aOptionValues = array();
 402                 $this->plugin_options = 0;
 403         }
 404
 405         // internal functions of the class starts here
 406
 407         var $_aOptionValues;    // oid_contextid => value
 408         var $_aOptionToInfo;    // context_name => array('oid' => ..., 'default' => ...)
 409         var $plugin_options;    // see getOption()
 410         var $plugid;                    // plugin id
 411
 412         /**
 413          * Class constructor: Initializes some internal data
 414          */
 415         function NucleusPlugin()
 416         {
 417                 $this->_aOptionValues = array();        // oid_contextid => value
 418                 $this->_aOptionToInfo = array();        // context_name => array('oid' => ..., 'default' => ...)
 419                 $this->plugin_options = 0;
 420         }
 421
 422         /**
 423          * Retrieves an array of the top (or bottom) of an option from a plugin.
 424          * @author TeRanEX
 425          * @param  string $context the context for the option: item, blog, member,...
 426          * @param  string $name    the name of the option
 427          * @param  int    $amount  how many rows must be returned
 428          * @param  string $sort    desc or asc
 429          * @return array           array with both values and contextid's
 430          * @access private
 431          */
 432         function _getOptionTop($context, $name, $amount = 10, $sort = 'desc')
 433         {
 434                 if ( ($sort != 'desc') && ($sort != 'asc') )
 435                 {
 436                         $sort= 'desc';
 437                 }
 438
 439                 $oid = $this->_getOID($context, $name);
 440
 441                 // retrieve the data and return
 442                 $q = 'SELECT otype, oextra FROM '.sql_table('plugin_option_desc').' WHERE oid = '.$oid;
 443                 $query = sql_query($q);
 444
 445                 $o = sql_fetch_array($query);
 446
 447                 if ( ($this->optionCanBeNumeric($o['otype'])) && ($o['oextra'] == 'number' ) )
 448                 {
 449                         $orderby = 'CAST(ovalue AS SIGNED)';
 450                 }
 451                 else
 452                 {
 453                         $orderby = 'ovalue';
 454                 }
 455                 $q = 'SELECT ovalue value, ocontextid id FROM '.sql_table('plugin_option').' WHERE oid = '.$oid.' ORDER BY '.$orderby.' '.$sort.' LIMIT 0,'.intval($amount);
 456                 $query = sql_query($q);
 457
 458                 // create the array
 459                 $i = 0;
 460                 $top = array();
 461                 while( $row = sql_fetch_array($query) )
 462                 {
 463                         $top[$i++] = $row;
 464                 }
 465
 466                 // return the array (duh!)
 467                 return $top;
 468         }
 469
 470         /**
 471          * Creates an option in the database table plugin_option_desc
 472          *
 473          * private
 474          */
 475         function _createOption($context, $name, $desc, $type, $defValue, $typeExtras = '')
 476         {
 477                 // create in plugin_option_desc
 478                 $query = 'INSERT INTO ' . sql_table('plugin_option_desc')
 479                                 .' (opid, oname, ocontext, odesc, otype, odef, oextra)'
 480                                 .' VALUES ('.intval($this->plugid)
 481                                         .', \''.sql_real_escape_string($name).'\''
 482                                         .', \''.sql_real_escape_string($context).'\''
 483                                         .', \''.sql_real_escape_string($desc).'\''
 484                                         .', \''.sql_real_escape_string($type).'\''
 485                                         .', \''.sql_real_escape_string($defValue).'\''
 486                                         .', \''.sql_real_escape_string($typeExtras).'\')';
 487                 sql_query($query);
 488                 $oid = sql_insert_id();
 489
 490                 $key = $context . '_' . $name;
 491                 $this->_aOptionToInfo[$key] = array('oid' => $oid, 'default' => $defValue);
 492                 return 1;
 493         }
 494
 495         /**
 496          * Deletes an option from the database tables
 497          * plugin_option and plugin_option_desc
 498          *
 499          * private
 500          */
 501         function _deleteOption($context, $name)
 502         {
 503                 $oid = $this->_getOID($context, $name);
 504                 if ( !$oid )
 505                 {
 506                         return 0; // no such option
 507                 }
 508
 509                 // delete all things from plugin_option
 510                 sql_query('DELETE FROM ' . sql_table('plugin_option') . ' WHERE oid=' . $oid);
 511
 512                 // delete entry from plugin_option_desc
 513                 sql_query('DELETE FROM ' . sql_table('plugin_option_desc') . ' WHERE oid=' . $oid);
 514
 515                 // clear from cache
 516                 unset($this->_aOptionToInfo[$context . '_' . $name]);
 517                 $this->_aOptionValues = array();
 518                 return 1;
 519         }
 520
 521         /**
 522          * Update an option in the database table plugin_option
 523          *
 524          * returns: 1 on success, 0 on failure
 525          * private
 526          */
 527         function _setOption($context, $contextid, $name, $value)
 528         {
 529                 global $manager;
 530
 531                 $oid = $this->_getOID($context, $name);
 532                 if ( !$oid )
 533                 {
 534                         return 0;
 535                 }
 536
 537                 // check if context id exists
 538                 switch ( $context )
 539                 {
 540                         case 'member':
 541                                 if ( !MEMBER::existsID($contextid) )
 542                                 {
 543                                         return 0;
 544                                 }
 545                                 break;
 546                         case 'blog':
 547                                 if ( !$manager->existsBlogID($contextid) )
 548                                 {
 549                                         return 0;
 550                                 }
 551                                 break;
 552                         case 'category':
 553                                 if ( !$manager->existsCategory($contextid) )
 554                                 {
 555                                         return 0;
 556                                 }
 557                                 break;
 558                         case 'item':
 559                                 if ( !$manager->existsItem($contextid, true, true) )
 560                                 {
 561                                         return 0;
 562                                 }
 563                                 break;
 564                         case 'global':
 565                                 if ( $contextid != 0 )
 566                                 {
 567                                         return 0;
 568                                 }
 569                                 break;
 570                 }
 571
 572                 // update plugin_option
 573                 sql_query('DELETE FROM ' . sql_table('plugin_option') . ' WHERE oid='.intval($oid) . ' and ocontextid='. intval($contextid));
 574                 sql_query('INSERT INTO ' . sql_table('plugin_option') . ' (ovalue, oid, ocontextid) VALUES (\''.sql_real_escape_string($value).'\', '. intval($oid) . ', ' . intval($contextid) . ')');
 575
 576                 // update cache
 577                 $this->_aOptionValues[$oid . '_' . $contextid] = $value;
 578                 if ( $context == 'global' )
 579                 {
 580                         $this->plugin_options[strtolower($name)] = $value;
 581                 }
 582
 583                 return 1;
 584         }
 585
 586         /**
 587          * Get an option from Cache or database
 588          *       - if not in the option Cache read it from the database
 589          *   - if not in the database write default values into the database
 590          *
 591          * private
 592          */
 593         function _getOption($context, $contextid, $name)
 594         {
 595                 $oid = $this->_getOID($context, $name);
 596                 if ( !$oid )
 597                 {
 598                         return '';
 599                 }
 600
 601                 $key = $oid . '_' . $contextid;
 602
 603                 if ( isset($this->_aOptionValues[$key]) )
 604                 {
 605                         return $this->_aOptionValues[$key];
 606                 }
 607
 608                 // get from DB
 609                 $res = sql_query('SELECT ovalue FROM ' . sql_table('plugin_option') . ' WHERE oid='.intval($oid).' and ocontextid=' . intval($contextid));
 610
 611                 if ( !$res || (sql_num_rows($res) == 0) )
 612                 {
 613                         $defVal = $this->_getDefVal($context, $name);
 614                         $this->_aOptionValues[$key] = $defVal;
 615
 616                         // fill DB with default value
 617                         $query = 'INSERT INTO ' . sql_table('plugin_option') . ' (oid,ocontextid,ovalue)'
 618                                         .' VALUES ('.intval($oid).', '.intval($contextid).', \''.sql_real_escape_string($defVal).'\')';
 619                         sql_query($query);
 620                 }
 621                 else
 622                 {
 623                         $o = sql_fetch_object($res);
 624                         $this->_aOptionValues[$key] = $o->ovalue;
 625                 }
 626
 627                 return $this->_aOptionValues[$key];
 628         }
 629
 630         /**
 631          * Returns assoc array with all values for a given option
 632          * (one option per possible context id)
 633          *
 634          * private
 635          */
 636         function _getAllOptions($context, $name)
 637         {
 638                 $oid = $this->_getOID($context, $name);
 639                 if ( !$oid )
 640                 {
 641                         return array();
 642                 }
 643                 $defVal = $this->_getDefVal($context, $name);
 644
 645                 $aOptions = array();
 646                 switch ( $context )
 647                 {
 648                         case 'blog':
 649                                 $r = sql_query('SELECT bnumber as contextid FROM ' . sql_table('blog'));
 650                                 break;
 651                         case 'category':
 652                                 $r = sql_query('SELECT catid as contextid FROM ' . sql_table('category'));
 653                                 break;
 654                         case 'member':
 655                                 $r = sql_query('SELECT mnumber as contextid FROM ' . sql_table('member'));
 656                                 break;
 657                         case 'item':
 658                                 $r = sql_query('SELECT inumber as contextid FROM ' . sql_table('item'));
 659                                 break;
 660                 }
 661                 if ( $r )
 662                 {
 663                         while ( $o = sql_fetch_object($r) )
 664                         {
 665                                 $aOptions[$o->contextid] = $defVal;
 666                         }
 667                 }
 668
 669                 $res = sql_query('SELECT ocontextid, ovalue FROM ' . sql_table('plugin_option') . ' WHERE oid=' . $oid);
 670                 while ( $o = sql_fetch_object($res) )
 671                 {
 672                         $aOptions[$o->ocontextid] = $o->ovalue;
 673                 }
 674
 675                 return $aOptions;
 676         }
 677
 678         /**
 679          * Gets the 'option identifier' that corresponds to a given option name.
 680          * When this method is called for the first time, all the OIDs for the plugin
 681          * are loaded into memory, to avoid re-doing the same query all over.
 682          */
 683         function _getOID($context, $name)
 684         {
 685                 $key = $context . '_' . $name;
 686                 $info = $this->_aOptionToInfo[$key];
 687                 if ( is_array($info) )
 688                 {
 689                         return $info['oid'];
 690                 }
 691
 692                 // load all OIDs for this plugin from the database
 693                 $this->_aOptionToInfo = array();
 694                 $query = 'SELECT oid, oname, ocontext, odef FROM ' . sql_table('plugin_option_desc') . ' WHERE opid=' . intval($this->plugid);
 695                 $res = sql_query($query);
 696                 while ( $o = sql_fetch_object($res) )
 697                 {
 698                         $k = $o->ocontext . '_' . $o->oname;
 699                         $this->_aOptionToInfo[$k] = array('oid' => $o->oid, 'default' => $o->odef);
 700                 }
 701                 sql_free_result($res);
 702
 703                 return $this->_aOptionToInfo[$key]['oid'];
 704         }
 705         function _getDefVal($context, $name)
 706         {
 707                 $key = $context . '_' . $name;
 708                 $info = $this->_aOptionToInfo[$key];
 709                 if ( is_array($info) )
 710                 {
 711                         return $info['default'];
 712                 }
 713         }
 714
 715         /**
 716          * Deletes all option values for a given context and contextid
 717          * (used when e.g. a blog, member or category is deleted)
 718          *
 719          * (static method)
 720          */
 721         function _deleteOptionValues($context, $contextid)
 722         {
 723                 // delete all associated plugin options
 724                 $aOIDs = array();
 725                 // find ids
 726                 $query = 'SELECT oid FROM '.sql_table('plugin_option_desc') . ' WHERE ocontext=\''.sql_real_escape_string($context).'\'';
 727                 $res = sql_query($query);
 728                 while ( $o = sql_fetch_object($res) )
 729                 {
 730                         array_push($aOIDs, $o->oid);
 731                 }
 732                 sql_free_result($res);
 733                 // delete those options. go go go
 734                 if ( count($aOIDs) > 0 )
 735                 {
 736                         $query = 'DELETE FROM ' . sql_table('plugin_option') . ' WHERE oid in ('.implode(',',$aOIDs).') and ocontextid=' . intval($contextid);
 737                         sql_query($query);
 738                 }
 739         }
 740
 741         /**
 742          * splits the option's typeextra field (at ;'s) to split the meta collection
 743          * @param string $typeExtra the value of the typeExtra field of an option
 744          * @return array array of the meta-key/value-pairs
 745          * @author TeRanEX
 746          * @static
 747          */
 748         function getOptionMeta($typeExtra)
 749         {
 750                 $tmpMeta = i18n::explode(';', $typeExtra);
 751                 $meta = array();
 752                 for ( $i = 0; $i < count($tmpMeta); $i++ )
 753                 {
 754                         if ( ($i == 0) && (!strstr($tmpMeta[0], '=')) )
 755                         {
 756                                 // we have the select-list
 757                                 $meta['select'] = $tmpMeta[0];
 758                         }
 759                         else
 760                         {
 761                                 $tmp = i18n::explode('=', $tmpMeta[$i]);
 762                                 $meta[$tmp[0]] = $tmp[1];
 763                         }
 764                 }
 765                 return $meta;
 766         }
 767
 768         /**
 769          * filters the selectlists out of the meta collection
 770          * @param string $typeExtra the value of the typeExtra field of an option
 771          * @return string the selectlist
 772          * @author TeRanEX
 773          */
 774         function getOptionSelectValues($typeExtra)
 775         {
 776                 $meta = NucleusPlugin::getOptionMeta($typeExtra);
 777                 //the select list must always be the first part
 778                 return $meta['select'];
 779         }
 780
 781         /**
 782          * checks if the eventlist in the database is up-to-date
 783          * @return bool if it is up-to-date it return true, else false
 784          * @author TeRanEX
 785          */
 786         function subscribtionListIsUptodate()
 787         {
 788                 $res = sql_query('SELECT event FROM '.sql_table('plugin_event').' WHERE pid = '.$this->getID());
 789                 $ev = array();
 790                 while( $a = sql_fetch_array($res) )
 791                 {
 792                         array_push($ev, $a['event']);
 793                 }
 794                 if ( count($ev) != count($this->getEventList()) )
 795                 {
 796                         return false;
 797                 }
 798                 $d = array_diff($ev, $this->getEventList());
 799                 if ( count($d) > 0 )
 800                 {
 801                         // there are differences so the db is not up-to-date
 802                         return false;
 803                 }
 804                 return true;
 805         }
 806
 807         /**
 808          * @param $aOptions: array ( 'oid' => array( 'contextid' => 'value'))
 809          *        (taken from request using requestVar())
 810          * @param $newContextid: integer (accepts a contextid when it is for a new
 811          *        contextid there was no id available at the moment of writing the
 812          *        formcontrols into the page (by ex: itemOptions for new item)
 813          * @static
 814          */
 815         function _applyPluginOptions(&$aOptions, $newContextid = 0)
 816         {
 817                 global $manager;
 818                 if ( !is_array($aOptions) )
 819                 {
 820                         return;
 821                 }
 822
 823                 foreach ( $aOptions as $oid => $values )
 824                 {
 825
 826                         // get option type info
 827                         $query = 'SELECT opid, oname, ocontext, otype, oextra, odef FROM ' . sql_table('plugin_option_desc') . ' WHERE oid=' . intval($oid);
 828                         $res = sql_query($query);
 829                         if ( $o = sql_fetch_object($res) )
 830                         {
 831                                 foreach ( $values as $key => $value )
 832                                 {
 833                                         // avoid overriding the key used by foreach statement
 834                                         $contextid=$key;
 835
 836                                         // retreive any metadata
 837                                         $meta = NucleusPlugin::getOptionMeta($o->oextra);
 838
 839                                         // if the option is readonly or hidden it may not be saved
 840                                         if ( ($meta['access'] != 'readonly') && ($meta['access'] != 'hidden') )
 841                                         {
 842
 843                                                 $value = undoMagic($value);     // value comes from request
 844
 845                                                 switch ( $o->otype )
 846                                                 {
 847                                                         case 'yesno':
 848                                                                 if ( ($value != 'yes') && ($value != 'no') )
 849                                                                 {
 850                                                                         $value = 'no';
 851                                                                 }
 852                                                                 break;
 853                                                         default:
 854                                                                 break;
 855                                                 }
 856
 857                                                 // check the validity of numerical options
 858                                                 if ( ($meta['datatype'] == 'numerical') && (!is_numeric($value)) )
 859                                                 {
 860                                                         //the option must be numeric, but the it isn't
 861                                                         //use the default for this option
 862                                                         $value = $o->odef;
 863                                                 }
 864
 865                                                 // decide wether we are using the contextid of newContextid
 866                                                 if ( $newContextid != 0 )
 867                                                 {
 868                                                         $contextid = $newContextid;
 869                                                 }
 870
 871                                                 //trigger event PrePluginOptionsUpdate to give the plugin the
 872                                                 //possibility to change/validate the new value for the option
 873                                                 $manager->notify('PrePluginOptionsUpdate',array('context' => $o->ocontext, 'plugid' => $o->opid, 'optionname' => $o->oname, 'contextid' => $contextid, 'value' => &$value));
 874
 875                                                 // delete the old value for the option
 876                                                 sql_query('DELETE FROM '.sql_table('plugin_option').' WHERE oid='.intval($oid).' AND ocontextid='.intval($contextid));
 877                                                 sql_query('INSERT INTO '.sql_table('plugin_option')." (oid, ocontextid, ovalue) VALUES (".intval($oid).",".intval($contextid).",'" . sql_real_escape_string($value) . "')");
 878                                         }
 879                                 }
 880                         }
 881                         // clear option value cache if the plugin object is already loaded
 882                         if ( is_object($o) )
 883                         {
 884                                 $plugin=& $manager->pidLoaded($o->opid);
 885                                 if ( $plugin )
 886                                 {
 887                                         $plugin->clearOptionValueCache();
 888                                 }
 889                         }
 890                 }
 891         }
 892 }