interface/main/calendar/includes/pnMod.php

   1 <?php
   2 // $Id$
   3 // ----------------------------------------------------------------------
   4 // POST-NUKE Content Management System
   5 // Copyright (C) 2001 by the Post-Nuke Development Team.
   6 // http://www.postnuke.com/
   7 // ----------------------------------------------------------------------
   8 // Based on:
   9 // PHP-NUKE Web Portal System - http://phpnuke.org/
  10 // Thatware - http://thatware.org/
  11 // ----------------------------------------------------------------------
  12 // LICENSE
  13 //
  14 // This program is free software; you can redistribute it and/or
  15 // modify it under the terms of the GNU General Public License (GPL)
  16 // as published by the Free Software Foundation; either version 2
  17 // of the License, or (at your option) any later version.
  18 //
  19 // This program is distributed in the hope that it will be useful,
  20 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  21 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22 // GNU General Public License for more details.
  23 //
  24 // To read the license please visit http://www.gnu.org/copyleft/gpl.html
  25 // ----------------------------------------------------------------------
  26 // Original Author of file: Jim McDonald
  27 // Purpose of file: Module variable handling
  28 // ----------------------------------------------------------------------
  29
  30 /*
  31  * pnModGetVar - get a module variable
  32  * Takes two parameters:
  33  * - the name of the module
  34  * - the name of the variable
  35  */
  36 function pnModGetVar($modname, $name)
  37 {
  38     if ((empty($modname)) || (empty($name))) {
  39         return false;
  40     }
  41
  42     global $pnmodvar;
  43     if (isset($pnmodvar[$modname][$name])) {
  44         return $pnmodvar[$modname][$name];
  45     }
  46
  47     list($dbconn) = pnDBGetConn();
  48     $pntable = pnDBGetTables();
  49
  50     $modulevarstable = $pntable['module_vars'];
  51     $modulevarscolumn = &$pntable['module_vars_column'];
  52     $query = "SELECT $modulevarscolumn[value]
  53               FROM $modulevarstable
  54               WHERE $modulevarscolumn[modname] = '" . pnVarPrepForStore($modname) . "'
  55               AND $modulevarscolumn[name] = '" . pnVarPrepForStore($name) . "'";
  56     $result = $dbconn->Execute($query);
  57
  58     if($dbconn->ErrorNo() != 0) {
  59         return;
  60     }
  61
  62     if ($result->EOF) {
  63         $pnmodvar[$modname][$name] = false;
  64         return;
  65     }
  66
  67     list($value) = $result->fields;
  68     $result->Close();
  69
  70     $pnmodvar[$modname][$name] = $value;
  71     return $value;
  72 }
  73
  74 /*
  75  * pnModSetVar - set a module variable
  76  * Takes three parameters:
  77  * - the name of the module
  78  * - the name of the variable
  79  * - the value of the variable
  80  */
  81 function pnModSetVar($modname, $name, $value)
  82 {
  83     if ((empty($modname)) || (empty($name))) {
  84         return false;
  85     }
  86
  87     list($dbconn) = pnDBGetConn();
  88     $pntable = pnDBGetTables();
  89
  90     $curvar = pnModGetVar($modname, $name);
  91
  92     $modulevarstable = $pntable['module_vars'];
  93     $modulevarscolumn = &$pntable['module_vars_column'];
  94     if (!isset($curvar)) {
  95         $query = "INSERT INTO $modulevarstable
  96                      ($modulevarscolumn[modname],
  97                       $modulevarscolumn[name],
  98                       $modulevarscolumn[value])
  99                   VALUES
 100                      ('" . pnVarPrepForStore($modname) . "',
 101                       '" . pnVarPrepForStore($name) . "',
 102                       '" . pnVarPrepForStore($value) . "');";
 103     } else {
 104         $query = "UPDATE $modulevarstable
 105                   SET $modulevarscolumn[value] = '" . pnVarPrepForStore($value) . "'
 106                   WHERE $modulevarscolumn[modname] = '" . pnVarPrepForStore($modname) . "'
 107                   AND $modulevarscolumn[name] = '" . pnVarPrepForStore($name) . "'";
 108     }
 109
 110     $dbconn->Execute($query);
 111
 112     if($dbconn->ErrorNo() != 0) {
 113         return;
 114     }
 115
 116     global $pnmodvar;
 117     $pnmodvar[$modname][$name] = $value;
 118     return true;
 119 }
 120
 121
 122 /*
 123  * pnModDelVar - delete a module variable
 124  * Takes two parameters:
 125  * - the name of the module
 126  * - the name of the variable
 127  */
 128 function pnModDelVar($modname, $name)
 129 {
 130     if ((empty($modname)) || (empty($name))) {
 131         return false;
 132     }
 133
 134     list($dbconn) = pnDBGetConn();
 135     $pntable = pnDBGetTables();
 136
 137     $modulevarstable = $pntable['module_vars'];
 138     $modulevarscolumn = &$pntable['module_vars_column'];
 139     $query = "DELETE FROM $modulevarstable
 140               WHERE $modulevarscolumn[modname] = '" . pnVarPrepForStore($modname) . "'
 141               AND $modulevarscolumn[name] = '" . pnVarPrepForStore($name) . "'";
 142     $dbconn->Execute($query);
 143
 144     if($dbconn->ErrorNo() != 0) {
 145         return;
 146     }
 147
 148     global $pnmodvar;
 149     if (isset($pnmodvar[$modname][$name])) {
 150         unset($pnmodvar[$modname][$name]);
 151     }
 152     return true;
 153 }
 154
 155 /*
 156  * pnModGetIDFromName - get module ID given its name
 157  * Takes one parameter:
 158  * - the name of the module
 159  */
 160 function pnModGetIDFromName($module)
 161 {
 162     if (empty($module)) {
 163         return false;
 164     }
 165
 166     static $modid = array();
 167     if (isset($modid[$module])) {
 168         return $modid[$module];
 169     }
 170
 171     list($dbconn) = pnDBGetConn();
 172     $pntable = pnDBGetTables();
 173
 174     $modulestable = $pntable['modules'];
 175     $modulescolumn = &$pntable['modules_column'];
 176     $query = "SELECT $modulescolumn[id]
 177               FROM $modulestable
 178               WHERE $modulescolumn[name] = '" . pnVarPrepForStore($module) . "'";
 179     $result = $dbconn->Execute($query);
 180
 181     if($dbconn->ErrorNo() != 0) {
 182         return;
 183     }
 184
 185     if ($result->EOF) {
 186         $modid[$module] = false;
 187         return false;
 188     }
 189
 190     list($id) = $result->fields;
 191     $result->Close();
 192
 193     $modid[$module] = $id;
 194     return $id;
 195 }
 196
 197 /**
 198  * get information on module
 199  * @param id
 200  * @returns array
 201  * @ return array of module information or false if core ( id = 0 )
 202  */
 203 function pnModGetInfo($modid)
 204 {
 205     // a $modid of 0 is associated with core ( pn_blocks.mid, ... ).
 206     if ( $modid == 0 ) {
 207         return false;
 208     }
 209
 210     static $modinfo = array();
 211     if (isset($modinfo[$modid])) {
 212         return $modinfo[$modid];
 213     }
 214
 215     list($dbconn) = pnDBGetConn();
 216     $pntable = pnDBGetTables();
 217
 218     $modulestable = $pntable['modules'];
 219     $modulescolumn = &$pntable['modules_column'];
 220     $query = "SELECT $modulescolumn[name],
 221                      $modulescolumn[type],
 222                      $modulescolumn[directory],
 223                      $modulescolumn[regid],
 224                      $modulescolumn[displayname],
 225                      $modulescolumn[description],
 226                      $modulescolumn[version]
 227               FROM $modulestable
 228               WHERE $modulescolumn[id] = " . pnVarPrepForStore($modid);
 229     $result = $dbconn->Execute($query);
 230
 231     if($dbconn->ErrorNo() != 0) {
 232         return;
 233     }
 234
 235     if ($result->EOF) {
 236         $modinfo[$modid] = false;
 237         return false;
 238     }
 239
 240     list($resarray['name'],
 241          $resarray['type'],
 242          $resarray['directory'],
 243          $resarray['regid'],
 244          $resarray['displayname'],
 245          $resarray['description'],
 246          $resarray['version']) = $result->fields;
 247     $result->Close();
 248
 249     $modinfo[$modid] = $resarray;
 250     return $resarray;
 251 }
 252
 253 /**
 254  * get list of user modules
 255  * @returns array
 256  * @return array of module information arrays
 257  */
 258 function pnModGetUserMods()
 259 {
 260     list($dbconn) = pnDBGetConn();
 261     $pntable = pnDBGetTables();
 262
 263     $modulestable = $pntable['modules'];
 264     $modulescolumn = &$pntable['modules_column'];
 265     $query = "SELECT $modulescolumn[name],
 266                      $modulescolumn[type],
 267                      $modulescolumn[directory],
 268                      $modulescolumn[regid],
 269                      $modulescolumn[displayname],
 270                      $modulescolumn[description],
 271                      $modulescolumn[version]
 272               FROM $modulestable
 273               WHERE $modulescolumn[state] = " . _PNMODULE_STATE_ACTIVE . "
 274               AND $modulescolumn[user_capable] = 1
 275               ORDER BY $modulescolumn[name]";
 276     $result = $dbconn->Execute($query);
 277
 278     if($dbconn->ErrorNo() != 0) {
 279         return;
 280     }
 281
 282     if ($result->EOF) {
 283         return false;
 284     }
 285
 286     $resarray = array();
 287     while(list($name,
 288                $modtype,
 289                $directory,
 290                $regid,
 291                $displayname,
 292                $description,
 293                $version) = $result->fields) {
 294         $result->MoveNext();
 295
 296         $tmparray = array('name' => $name,
 297                           'type' => $modtype,
 298                           'directory' => $directory,
 299                           'regid' => $regid,
 300                           'displayname' => $displayname,
 301                           'description' => $description,
 302                           'version' => $version);
 303
 304         array_push($resarray, $tmparray);
 305     }
 306     $result->Close();
 307
 308     return $resarray;
 309 }
 310
 311 /**
 312  * get list of administration modules
 313  * @returns array
 314  * @return array of module information arrays
 315  */
 316 function pnModGetAdminMods()
 317 {
 318     list($dbconn) = pnDBGetConn();
 319     $pntable = pnDBGetTables();
 320
 321     $modulestable = $pntable['modules'];
 322     $modulescolumn = &$pntable['modules_column'];
 323
 324     $query = "SELECT $modulescolumn[name],
 325                      $modulescolumn[type],
 326                      $modulescolumn[directory],
 327                      $modulescolumn[regid],
 328                      $modulescolumn[displayname],
 329                      $modulescolumn[description],
 330                      $modulescolumn[version]
 331               FROM $modulestable
 332               WHERE $modulescolumn[state] = " . _PNMODULE_STATE_ACTIVE . "
 333               AND $modulescolumn[admin_capable] = 1
 334               AND $modulescolumn[directory] != 'NS-Admin'
 335               ORDER BY $modulescolumn[name]";
 336
 337     $result = $dbconn->Execute($query);
 338
 339     if($dbconn->ErrorNo() != 0) {
 340         return;
 341     }
 342
 343     if ($result->EOF) {
 344         return false;
 345     }
 346
 347     $resarray = array();
 348     while(list($name,
 349                $modtype,
 350                $directory,
 351                $regid,
 352                $displayname,
 353                $description,
 354                $version) = $result->fields) {
 355         $result->MoveNext();
 356
 357         $tmparray = array('name' => $name,
 358                           'type' => $modtype,
 359                           'directory' => $directory,
 360                           'regid' => $regid,
 361                           'displayname' => $displayname,
 362                           'description' => $description,
 363                           'version' => $version);
 364
 365         array_push($resarray, $tmparray);
 366     }
 367     $result->Close();
 368
 369     return $resarray;
 370 }
 371
 372 /**
 373  * load an API for a module
 374  * @param modname - registered name of the module
 375  * @param type - type of functions to load
 376  * @returns bool
 377  * @return true on success, false on failure
 378  */
 379 function pnModAPILoad($modname, $type='user')
 380 {
 381     static $loaded = array();
 382
 383     if (empty($modname)) {
 384         return false;
 385     }
 386
 387     list($dbconn) = pnDBGetConn();
 388     $pntable = pnDBGetTables();
 389
 390     if (!empty($loaded["$modname$type"])) {
 391         // Already loaded from somewhere else
 392         return true;
 393     }
 394
 395     $modulestable = $pntable['modules'];
 396     $modulescolumn = &$pntable['modules_column'];
 397     $query = "SELECT $modulescolumn[name],
 398                      $modulescolumn[directory],
 399                      $modulescolumn[state]
 400               FROM $modulestable
 401               WHERE $modulescolumn[name] = '" . pnVarPrepForStore($modname) . "'";
 402     $result = $dbconn->Execute($query);
 403
 404     if($dbconn->ErrorNo() != 0) {
 405         return;
 406     }
 407
 408     if ($result->EOF) {
 409         pnSessionSetVar('errmsg', "Unknown module $modname");
 410         return false;
 411     }
 412
 413     list($name, $directory, $state) = $result->fields;
 414     $result->Close();
 415
 416     list($osdirectory, $ostype) = pnVarPrepForOS($directory, $type);
 417
 418     $osfile = "modules/$osdirectory/pn{$ostype}api.php";
 419     if (!file_exists($osfile)) {
 420         // File does not exist
 421         return false;
 422     }
 423
 424     // Load the file
 425     include $osfile;
 426     $loaded["$modname$type"] = 1;
 427
 428     // Load the module language files
 429     $currentlang = pnUserGetLang();
 430     $defaultlang = pnConfigGetVar('language');
 431     if (empty($defaultlang)) {
 432         $defaultlang = 'eng';
 433     }
 434
 435     list($oscurrentlang, $osdefaultlang) = pnVarPrepForOS($currentlang, $defaultlang);
 436     if (file_exists("modules/$osdirectory/pnlang/$oscurrentlang/{$ostype}api.php")) {
 437         include "modules/$osdirectory/pnlang/$oscurrentlang/{$ostype}api.php";
 438     } elseif (file_exists("modules/$osdirectory/pnlang/$osdefaultlang/{$ostype}api.php")) {
 439         include "modules/$osdirectory/pnlang/$osdefaultlang/{$ostype}api.php";
 440     }
 441
 442     // Load datbase info
 443     pnModDBInfoLoad($modname, $directory);
 444
 445     return true;
 446 }
 447
 448 /**
 449  * load datbase definition for a module
 450  * @param name - name of module to load database definition for
 451  * @param directory - directory that module is in (if known)
 452  * @returns bool
 453  */
 454 function pnModDBInfoLoad($modname, $directory='')
 455 {
 456     static $loaded = array();
 457
 458     // Check to ensure we aren't doing this twice
 459     if (isset($loaded[$modname])) {
 460         return true;
 461     }
 462
 463     // Get the directory if we don't already have it
 464     if (empty($directory)) {
 465         list($dbconn) = pnDBGetConn();
 466         $pntable = pnDBGetTables();
 467         $modulestable = $pntable['modules'];
 468         $modulescolumn = &$pntable['modules_column'];
 469         $sql = "SELECT $modulescolumn[directory]
 470                 FROM $modulestable
 471                 WHERE $modulescolumn[name] = '" . pnVarPrepForStore($modname) . "'";
 472         $result = $dbconn->Execute($sql);
 473         if($dbconn->ErrorNo() != 0) {
 474             return;
 475         }
 476
 477         if ($result->EOF) {
 478             return false;
 479         }
 480
 481         $directory = $result->fields[0];
 482         $result->Close();
 483     }
 484
 485     // Load the database definition if required
 486     $ospntablefile = 'modules/' . pnVarPrepForOS($directory) . '/pntables.php';
 487     // Ignore errors for this, if it fails we'll find out and handle
 488     // it when we look for the function itself
 489     @include_once $ospntablefile;
 490     $tablefunc = $modname . '_' . 'pntables';
 491     if (function_exists($tablefunc)) {
 492         global $pntable;
 493         $pntable = array_merge($pntable, $tablefunc());
 494     }
 495     $loaded[$modname] = true;
 496
 497     return true;
 498 }
 499
 500 /**
 501  * load a module
 502  * @param name - name of module to load
 503  * @param type - type of functions to load
 504  * @returns string
 505  * @return name of module loaded, or false on failure
 506  */
 507 function pnModLoad($modname, $type='user')
 508 {
 509     static $loaded = array();
 510
 511     if (empty($modname)) {
 512         return false;
 513     }
 514
 515     list($dbconn) = pnDBGetConn();
 516     $pntable = pnDBGetTables();
 517
 518     $modulestable = $pntable['modules'];
 519     $modulescolumn = &$pntable['modules_column'];
 520
 521     if (!empty($loaded["$modname$type"])) {
 522         // Already loaded from somewhere else
 523         return $modname;
 524     }
 525
 526     $query = "SELECT $modulescolumn[directory],
 527                      $modulescolumn[state]
 528               FROM $modulestable
 529               WHERE $modulescolumn[name] = '" . pnVarPrepForStore($modname) . "'";
 530     $result = $dbconn->Execute($query);
 531
 532     if($dbconn->ErrorNo() != 0) {
 533         return;
 534     }
 535
 536     if ($result->EOF) {
 537         return false;
 538     }
 539
 540     list($directory, $state) = $result->fields;
 541     $result->Close();
 542
 543     // Load the module and module language files
 544     list($osdirectory, $ostype) = pnVarPrepForOS($directory, $type);
 545     $osfile = "modules/$osdirectory/pn$ostype.php";
 546
 547     if (!file_exists($osfile)) {
 548         // File does not exist
 549         return false;
 550     }
 551
 552     // Load file
 553     include $osfile;
 554     $loaded["$modname$type"] = 1;
 555
 556     $defaultlang = pnConfigGetVar('language');
 557     if (empty($defaultlang)) {
 558         $defaultlang = 'eng';
 559     }
 560
 561     $currentlang = pnUserGetLang();
 562     if (file_exists("modules/$osdirectory/pnlang/$currentlang/$ostype.php")) {
 563         include "modules/$osdirectory/pnlang/" . pnVarPrepForOS($currentlang) . "/$ostype.php";
 564     } elseif (file_exists("modules/$directory/pnlang/$defaultlang/$ostype.php")) {
 565         include "modules/$osdirectory/pnlang/" . pnVarPrepForOS($defaultlang) . "/$ostype.php";
 566     }
 567
 568     // Load datbase info
 569     pnModDBInfoLoad($modname, $directory);
 570
 571     // Return the module name
 572     return $modname;
 573 }
 574
 575 /**
 576  * run a module API function
 577  * @param modname - registered name of module
 578  * @param type - type of function to run
 579  * @param func - specific function to run
 580  * @param args - arguments to pass to the function
 581  * @returns mixed
 582  */
 583 function pnModAPIFunc($modname, $type='user', $func='main', $args=array())
 584 {
 585
 586     if (empty($modname)) {
 587         return false;
 588     }
 589
 590     if (empty($type)) {
 591         $func = 'user';
 592     }
 593     if (empty($func)) {
 594         $func = 'main';
 595     }
 596
 597     // Build function name and call function
 598     $modapifunc = "{$modname}_{$type}api_{$func}";
 599     if (function_exists($modapifunc)) {
 600         return $modapifunc($args);
 601     }
 602
 603     return false;
 604 }
 605
 606 /**
 607  * run a module function
 608  * @param modname - registered name of module
 609  * @param type - type of function to run
 610  * @param func - specific function to run
 611  * @param args - argument array
 612  * @returns mixed
 613  */
 614 function pnModFunc($modname, $type='user', $func='main', $args=array())
 615 {
 616
 617     if (empty($modname)) {
 618         return false;
 619     }
 620
 621     if (empty($type)) {
 622         $func = 'user';
 623     }
 624     if (empty($func)) {
 625         $func = 'main';
 626     }
 627
 628     // Build function name and call function
 629     $modfunc = "{$modname}_{$type}_{$func}";
 630     if (function_exists($modfunc)) {
 631         return $modfunc($args);
 632     }
 633
 634     return false;
 635 }
 636
 637 /**
 638  * generate a module function URL
 639  * @param modname - registered name of module
 640  * @param type - type of function
 641  * @param func - module function
 642  * @param args - array of arguments to put on the URL
 643  * @returns string
 644  * @return absolute URL for call
 645  */
 646 function pnModURL($modname, $type='user', $func='main', $args=array(), $path = '')
 647 {
 648     if (empty($modname)) {
 649         return false;
 650     }
 651
 652     global $HTTP_SERVER_VARS;
 653
 654     // Hostname
 655     $host = $HTTP_SERVER_VARS['HTTP_HOST'];
 656     if (empty($host)) {
 657         $host = getenv('HTTP_HOST');
 658         if (empty($host)) {
 659             return false;
 660         }
 661     }
 662
 663     // The arguments
 664     $urlargs[] = "module=$modname";
 665     if ((!empty($type)) && ($type != 'user')) {
 666         $urlargs[] = "type=$type";
 667     }
 668     if ((!empty($func)) && ($func != 'main')) {
 669         $urlargs[] = "func=$func";
 670     }
 671     $urlargs = join('&', $urlargs);
 672     $url = "index.php?$urlargs";
 673
 674
 675     // <rabbitt> added array check on args
 676     // April 11, 2003
 677     if (!is_array($args)) {
 678         return false;
 679     } else {
 680         foreach ($args as $k=>$v) {
 681             if (is_array($v)) {
 682                 foreach($v as $l=>$w) {
 683                     $url .= "&$k" . "[$l]=$w";
 684                 }
 685             } else {
 686                 $url .= "&$k=$v";
 687             }
 688         }
 689     }
 690         //remove characters not belonging in a path, prevent possible injection
 691         //this may break windows path accesses?
 692         $path = preg_replace("/[^\.\/a-zA-Z0-9]/","",$path)
 693 ;
 694     // The URL
 695         $final_url = pnGetBaseURL() . $path . $url;
 696     return $final_url;
 697 }
 698
 699 /**
 700  * see if a module is available
 701  * @returns bool
 702  * @return true if the module is available, false if not
 703  */
 704 function pnModAvailable($modname)
 705 {
 706     if (empty($modname)) {
 707         return false;
 708     }
 709
 710     static $modstate = array();
 711     if (isset($modstate[$modname])) {
 712         if ($modstate[$modname] == _PNMODULE_STATE_ACTIVE) {
 713             return true;
 714         } else {
 715             return false;
 716         }
 717     }
 718
 719     list($dbconn) = pnDBGetConn();
 720     $pntable = pnDBGetTables();
 721
 722     $modulestable = $pntable['modules'];
 723     $modulescolumn = &$pntable['modules_column'];
 724     $query = "SELECT $modulescolumn[state]
 725               FROM $modulestable
 726               WHERE $modulescolumn[name] = '" . pnVarPrepForStore($modname) . "'";
 727     $result = $dbconn->Execute($query);
 728
 729     if($dbconn->ErrorNo() != 0) {
 730         return;
 731     }
 732
 733     if ($result->EOF) {
 734         $modstate[$modname] = _PNMODULE_STATE_MISSING;
 735         return false;
 736     }
 737
 738     list($state) = $result->fields;
 739     $result->Close();
 740
 741     $modstate[$modname] = $state;
 742     if ($state == _PNMODULE_STATE_ACTIVE) {
 743         return true;
 744     } else {
 745         return false;
 746     }
 747 }
 748
 749 /**
 750  * get name of current top-level module
 751  * @returns string
 752  * @return the name of the current top-level module, false if not in a module
 753  */
 754 function pnModGetName() {
 755     $modname = pnVarCleanFromInput('module');
 756     if (empty($modname)) {
 757         $name = pnVarCleanFromInput('name');
 758         if (empty($name)) {
 759             global $ModName;
 760             if (empty($ModName)) {
 761                 return false;
 762             }
 763             $modname = preg_replace('/^NS-/', '', $ModName);
 764             return $modname;
 765         }
 766         return $name;
 767     } else {
 768         $modname = preg_replace('/^NS-/', '', $modname);
 769         return $modname;
 770     }
 771 }
 772
 773 /**
 774  * register a hook function
 775  * @param hookobject the hook object
 776  * @param hookaction the hook action
 777  * @param hookarea the area of the hook (either 'GUI' or 'API')
 778  * @param hookmodule name of the hook module
 779  * @param hooktype name of the hook type
 780  * @param hookfunc name of the hook function
 781  */
 782 function pnModRegisterHook($hookobject,
 783                            $hookaction,
 784                            $hookarea,
 785                            $hookmodule,
 786                            $hooktype,
 787                            $hookfunc)
 788 {
 789
 790     // Get database info
 791     list($dbconn) = pnDBGetConn();
 792     $pntable = pnDBGetTables();
 793     $hookstable = $pntable['hooks'];
 794     $hookscolumn = &$pntable['hooks_column'];
 795
 796     // Insert hook
 797     $sql = "INSERT INTO $hookstable (
 798               $hookscolumn[id],
 799               $hookscolumn[object],
 800               $hookscolumn[action],
 801               $hookscolumn[tarea],
 802               $hookscolumn[tmodule],
 803               $hookscolumn[ttype],
 804               $hookscolumn[tfunc])
 805             VALUES (
 806               " . pnVarPrepForStore($dbconn->GenId($hookstable)) . ",
 807               '" . pnVarPrepForStore($hookobject) . "',
 808               '" . pnVarPrepForStore($hookaction) . "',
 809               '" . pnVarPrepForStore($hookarea) . "',
 810               '" . pnVarPrepForStore($hookmodule) . "',
 811               '" . pnVarPrepForStore($hooktype) . "',
 812               '" . pnVarPrepForStore($hookfunc) . "')";
 813     $dbconn->Execute($sql);
 814
 815     if($dbconn->ErrorNo() != 0) {
 816         return false;
 817     }
 818
 819     return true;
 820 }
 821
 822 /**
 823  * unregister a hook function
 824  * @param hookobject the hook object
 825  * @param hookaction the hook action
 826  * @param hookarea the area of the hook (either 'GUI' or 'API')
 827  * @param hookmodule name of the hook module
 828  * @param hooktype name of the hook type
 829  * @param hookfunc name of the hook function
 830  */
 831 function pnModUnregisterHook($hookobject,
 832                              $hookaction,
 833                              $hookarea,
 834                              $hookmodule,
 835                              $hooktype,
 836                              $hookfunc)
 837 {
 838
 839     // Get database info
 840     list($dbconn) = pnDBGetConn();
 841     $pntable = pnDBGetTables();
 842     $hookstable = $pntable['hooks'];
 843     $hookscolumn = &$pntable['hooks_column'];
 844
 845     // Remove hook
 846     $sql = "DELETE FROM $hookstable
 847             WHERE $hookscolumn[object] = '" . pnVarPrepForStore($hookobject) . "'
 848              AND $hookscolumn[action] = '" . pnVarPrepForStore($hookaction) . "'
 849              AND $hookscolumn[tarea] = '" . pnVarPrepForStore($hookarea) . "'
 850              AND $hookscolumn[tmodule] = '" . pnVarPrepForStore($hookmodule) . "'
 851              AND $hookscolumn[ttype] = '" . pnVarPrepForStore($hooktype) . "'
 852              AND $hookscolumn[tfunc] = '" . pnVarPrepForStore($hookfunc) . "'";
 853     $dbconn->Execute($sql);
 854
 855     if($dbconn->ErrorNo() != 0) {
 856         return false;
 857     }
 858
 859     return true;
 860 }
 861
 862 /**
 863  * carry out hook operations for module
 864  * @param hookobject the object the hook is called for - either 'item' or 'category'
 865  * @param hookaction the action the hook is called for - one of 'create', 'delete', 'transform', or 'display'
 866  * @param hookid the id of the object the hook is called for (module-specific)
 867  * @param extrainfo extra information for the hook, dependent on hookaction
 868  * @returns string
 869  * @return output from hooks
 870  */
 871 function pnModCallHooks($hookobject, $hookaction, $hookid, $extrainfo) {
 872
 873     // Get database info
 874     list($dbconn) = pnDBGetConn();
 875     $pntable = pnDBGetTables();
 876     $hookstable = $pntable['hooks'];
 877     $hookscolumn = &$pntable['hooks_column'];
 878
 879     // Get applicable hooks
 880     $sql = "SELECT $hookscolumn[tarea],
 881                    $hookscolumn[tmodule],
 882                    $hookscolumn[ttype],
 883                    $hookscolumn[tfunc]
 884             FROM $hookstable
 885             WHERE $hookscolumn[smodule] = '" . pnVarPrepForStore(pnModGetName()) . "'
 886             AND $hookscolumn[object] = '" . pnVarPrepForStore($hookobject) . "'
 887             AND $hookscolumn[action] = '" . pnVarPrepForStore($hookaction) . "'";
 888     $result = $dbconn->Execute($sql);
 889
 890     if($dbconn->ErrorNo() != 0) {
 891         return null;
 892     }
 893
 894     $output = '';
 895
 896     // Call each hook
 897     for (; !$result->EOF; $result->MoveNext()) {
 898         list($hookarea, $hookmodule, $hooktype, $hookfunc) = $result->fields;
 899         if ($hookarea == 'GUI') {
 900             if (pnModAvailable($hookmodule, $hooktype) &&
 901                 pnModLoad($hookmodule, $hooktype)) {
 902                 $output .= pnModFunc($hookmodule,
 903                                      $hooktype,
 904                                      $hookfunc,
 905                                      array('objectid' => $hookid,
 906                                            'extrainfo' => $extrainfo));
 907             }
 908         } else {
 909             if (pnModAvailable($hookmodule, $hooktype) &&
 910                 pnModAPILoad($hookmodule, $hooktype)) {
 911                 $extrainfo = pnModAPIFunc($hookmodule,
 912                                           $hooktype,
 913                                           $hookfunc,
 914                                           array('objectid' => $hookid,
 915                                                 'extrainfo' => $extrainfo));
 916             }
 917         }
 918     }
 919
 920     if ($hookaction == 'display') {
 921         return $output;
 922     } else {
 923         return $extrainfo;
 924     }
 925 }
 926
 927 ?>