nucleus/libs/AdminActions.php

   1 <?php
   2 if ( !class_exists('BaseActions') )
   3 {
   4         include $DIR_LIBS . 'BaseActions.php';
   5 }
   6
   7
   8 class AdminActions extends BaseActions
   9 {
  10         // reference to the skin object for which a part is being parsed
  11         private $skin;
  12
  13         private $skintype;
  14
  15         /* NOTE: list of whole available action names for tags
  16                 'actionloglist',
  17                 'activationmessage',
  18                 'addtickettourl',
  19                 'adminbanlist',
  20                 'adminbatchaction',
  21                 'adminbatchlist',
  22                 'adminbloglink',
  23                 'adminerrormesg',
  24                 'adminskineditallowedlist',
  25                 'adminskinielist',
  26                 'adminskinoverview',
  27                 'adminskinselectoptions',
  28                 'adminspecialskinlist',
  29                 'admintemplateoverview',
  30                 'allowedadminskinactions',
  31                 'allowedskinactions',
  32                 'banlistdeletedlist',
  33                 'batchdeletelist',
  34                 'batchdeletetype',
  35                 'batchmovebtn',
  36                 'batchmovelist',
  37                 'batchmovetitle',
  38                 'batchmovetype',
  39                 'blogcatlist',
  40                 'blognotifysetting',
  41                 'blogselectbox',
  42                 'blogsetting',
  43                 'blogsettingyesno',
  44                 'blogteamlist',
  45                 'blogteammembers',
  46                 'blogtime',
  47                 'bookmarkletadmin',
  48                 'category',
  49                 'categorysetting',
  50                 'codename',
  51                 'commentnavlist',
  52                 'configsettingsedit',
  53                 'configsettingsyesno',
  54                 'customhelplink',
  55                 'date',
  56                 'defaultadminskintypes',
  57                 'defblogselect',
  58                 'defcatselect',
  59                 'defskinselect',
  60                 'deletecomment',
  61                 'deleteitembody',
  62                 'deleteitemid',
  63                 'deleteitemtitle',
  64                 'editadminskin',
  65                 'editadminskintype',
  66                 'editadmintemplateinfo',
  67                 'editcomment',
  68                 'editdesturl',
  69                 'editmember',
  70                 'editmemberlist',
  71                 'editpluginfo',
  72                 'editplugoptionslist',
  73                 'editskin',
  74                 'editskintype',
  75                 'edittemplateinfo',
  76                 'eventformextra',
  77                 'extrahead',
  78                 'getblogsetting',
  79                 'geteditpluginfo',
  80                 'getmember',
  81                 'headmessage',
  82                 'helplink',
  83                 'helpplugname',
  84                 'ilistaddnew',
  85                 'importskininfo',
  86                 'inputyesno',
  87                 'insertpluginfo',
  88                 'insertpluginoptions',
  89                 'insplugoptcontent',
  90                 'iprangeinput',
  91                 'itemnavlist',
  92                 'jstoolbaroptions',
  93                 'listplugplugoptionrow',
  94                 'localeselectoptions',
  95                 'mediadirwarning',
  96                 'movedistselect',
  97                 'moveitemid',
  98                 'newestcompare',
  99                 'newmemberselect',
 100                 'newpluginlist',
 101                 'outputspecialdirs',
 102                 'passrequestvars',
 103                 'pluginextras',
 104                 'pluginhelp',
 105                 'pluginlistlist',
 106                 'pluginoptions',
 107                 'qmenuaddselect',
 108                 'quickmenu',
 109                 'requestblogid',
 110                 'requestiprange',
 111                 'selectlocaladminskinfiles',
 112                 'selectlocalskinfiles',
 113                 'skineditallowedlist',
 114                 'skinfile',
 115                 'skinielist',
 116                 'skinoverview',
 117                 'skintypehelp',
 118                 'specialskinlist',
 119                 'sprinttext',
 120                 'systemsettings',
 121                 'templateoverview',
 122                 'text',
 123                 'ticket',
 124                 'versioncheckurl',
 125                 'yrbloglist'
 126         );
 127          */
 128
 129         /**
 130          * AdminActions::$default_actions
 131          * list of whole action names with which this class can deal
 132          */
 133         static private $default_actions = array(
 134                 'addtickettourl',
 135                 'adminurl',
 136                 'customhelplink',
 137                 'headmessage',
 138                 'helplink',
 139                 'sprinttext',
 140                 'ticket'
 141         );
 142
 143         /**
 144          * AdminActions::$skin_type_friendly_names
 145          * friendly name for wrapped page types
 146          */
 147         static private $default_skin_types = array(
 148                 'actionlog'                             => _ADM_SKPRT_ACTIONLOG,
 149                 'activate'                              => _ADM_SKPRT_ACTIVATE,
 150                 'activatesetpwd'                => _ADM_SKPRT_ACTIVATESETPWD,
 151                 'addnewlog'                             => _ADM_SKPRT_ADDNEWLOG,
 152                 'adminerrorpage'                => _ADM_SKPRT_ADMINERRORPAGE,
 153                 'adminskindelete'               => _ADM_SKPRT_ADMINSKINDELETE,
 154                 'adminskinedit'                 => _ADM_SKPRT_ADMINSKINEDIT,
 155                 'adminskinedittype'             => _ADM_SKPRT_ADMINSKINEDITTYPE,
 156                 'adminskiniedoimport'   => _ADM_SKPRT_ADMINSKINIEDOIMPORT,
 157                 'adminskinieimport'             => _ADM_SKPRT_ADMINSKINIEIMPORT,
 158                 'adminskinieoverview'   => _ADM_SKPRT_ADMINSKINIEOVERVIEW,
 159                 'adminskinoverview'             => _ADM_SKPRT_ADMINSKINOVERVIEW,
 160                 'adminskinremovetype'   => _ADM_SKPRT_ADMINSKINREMOVETYPE,
 161                 'admintemplatedelete'   => _ADM_SKPRT_ADMINTEMPLATEDELETE,
 162                 'admintemplateedit'             => _ADM_SKPRT_ADMINTEMPLATEEDIT,
 163                 'admintemplateoverview' => _ADM_SKPRT_ADMINTEMPLATEOVERVIEW,
 164                 'backupoverview'                => _ADM_SKPRT_BACKUPOVERVIEW,
 165                 'backuprestore'                 => _ADM_SKPRT_BACKUPRESTORE,
 166                 'banlist'                               => _ADM_SKPRT_BANLIST,
 167                 'banlistdelete'                 => _ADM_SKPRT_BANLISTDELETE,
 168                 'banlistdeleteconfirm'  => _ADM_SKPRT_BANLISTDELETECONFIRM,
 169                 'banlistnew'                    => _ADM_SKPRT_BANLISTNEW,
 170                 'batchcategory'                 => _ADM_SKPRT_BATCHCATEGORY,
 171                 'batchcomment'                  => _ADM_SKPRT_BATCHCOMMENT,
 172                 'batchdelete'                   => _ADM_SKPRT_BATCHDELETE,
 173                 'batchitem'                             => _ADM_SKPRT_BATCHITEM,
 174                 'batchmember'                   => _ADM_SKPRT_BATCHMEMBER,
 175                 'batchmove'                             => _ADM_SKPRT_BATCHMOVE,
 176                 'batchmovecat'                  => _ADM_SKPRT_BATCHMOVECAT,
 177                 'batchteam'                             => _ADM_SKPRT_BATCHTEAM,
 178                 'blogcommentlist'               => _ADM_SKPRT_BLOGCOMMENTLIST,
 179                 'blogselectbox'                 => _ADM_SKPRT_BLOGSELECTBOX,
 180                 'blogsettings'                  => _ADM_SKPRT_BLOGSETTINGS,
 181                 'bookmarklet'                   => _ADM_SKPRT_BOOKMARKLET,
 182                 'browseowncomments'             => _ADM_SKPRT_BROWSEOWNCOMMENTS,
 183                 'browseownitems'                => _ADM_SKPRT_BROWSEOWNITEMS,
 184                 'categorydelete'                => _ADM_SKPRT_CATEGORYDELETE,
 185                 'categoryedit'                  => _ADM_SKPRT_CATEGORYEDIT,
 186                 'commentdelete'                 => _ADM_SKPRT_COMMENTDELETE,
 187                 'commentedit'                   => _ADM_SKPRT_COMMENTEDIT,
 188                 'createitem'                    => _ADM_SKPRT_CREATEITEM,
 189                 'createnewlog'                  => _ADM_SKPRT_CREATENEWLOG,
 190                 'deleteblog'                    => _ADM_SKPRT_DELETEBLOG,
 191                 'editmembersettings'    => _ADM_SKPRT_EDITMEMBERSETTINGS,
 192                 'insertpluginoptions'   => _ADM_SKPRT_INSERTPLUGINO,
 193                 'itemcommentlist'               => _ADM_SKPRT_ITEMCOMMENTLIST,
 194                 'itemdelete'                    => _ADM_SKPRT_ITEMDELETE,
 195                 'itemedit'                              => _ADM_SKPRT_ITEMEDIT,
 196                 'itemlist'                              => _ADM_SKPRT_ITEMLIST,
 197                 'itemmove'                              => _ADM_SKPRT_ITEMMOVE,
 198                 'login'                                 => FALSE,       //missing
 199                 'manage'                                => _ADM_SKPRT_MANAGE,
 200                 'manageteam'                    => _ADM_SKPRT_MANAGETEAM,
 201                 'memberdelete'                  => _ADM_SKPRT_MEMBERDELETE,
 202                 'memberedit'                    => FALSE,       //missing
 203                 'overview'                              => _ADM_SKPRT_OVERVIEW,
 204                 'pagefoot'                              => _ADM_SKPRT_PAGEFOOT,
 205                 'pagehead'                              => _ADM_SKPRT_PAGEHEAD,
 206                 'plugindelete'                  => _ADM_SKPRT_PLUGINDELETE,
 207                 'pluginhelp'                    => _ADM_SKPRT_PLUGINHELP,
 208                 'pluginlist'                    => _ADM_SKPRT_PLUGINLIST,
 209                 'pluginoptions'                 => _ADM_SKPRT_PLUGINOPTIONS,
 210                 'settingsedit'                  => _ADM_SKPRT_SETTINGSEDIT,
 211                 'showlogin'                             => _ADM_SKPRT_SHOWLOGIN,
 212                 'skindelete'                    => _ADM_SKPRT_SKINDELETE,
 213                 'skinedit'                              => _ADM_SKPRT_SKINEDIT,
 214                 'skinedittype'                  => _ADM_SKPRT_SKINEDITTYPE,
 215                 'skiniedoimport'                => _ADM_SKPRT_SKINIEDOIMPORT,
 216                 'skinieimport'                  => _ADM_SKPRT_SKINIEIMPORT,
 217                 'skinieoverview'                => _ADM_SKPRT_SKINIEOVERVIEW,
 218                 'skinoverview'                  => _ADM_SKPRT_SKINOVERVIEW,
 219                 'skinremovetype'                => _ADM_SKPRT_SKINREMOVETYPE,
 220                 'systemoverview'                => _ADM_SKPRT_SYSTEMOVERVIEW,
 221                 'teamdelete'                    => _ADM_SKPRT_TEAMDELETE,
 222                 'templatedelete'                => _ADM_SKPRT_TEMPLATEDELETE,
 223                 'templateedit'                  => _ADM_SKPRT_TEMPLATEEDIT,
 224                 'templateoverview'              => _ADM_SKPRT_TEMPLATEOVERVIEW,
 225                 'usermanagement'                => _ADM_SKPRT_USERMANAGEMENT,
 226         );
 227
 228         /**
 229          * AdminActions::getAvailableSkinTypes()
 230          *
 231          * @static
 232          * @param       void
 233          * @return      array   list of friendly names for page actions
 234          */
 235         static public function getAvailableSkinTypes()
 236         {
 237                 return self::$default_skin_types;
 238         }
 239
 240         /**
 241          * AdminActions::getDefaultTypes()
 242          *
 243          * @static
 244          * @param       void
 245          * @return      array   list of friendly names for page actions
 246          */
 247         static public function getDefaultTypes()
 248         {
 249                 return self::$default_skin_types;
 250         }
 251
 252         /**
 253          * AdminActions::__construct()
 254          * Constructor for a new Actions object
 255          *
 256          * @param       string  $type
 257          * @return      void
 258          */
 259         public function __construct($type)
 260         {
 261                 // call constructor of superclass first
 262                 parent::__construct();
 263                 $this->skintype = $type;
 264                 if ( !class_exists('Navlist') || !class_exists('Batch') )
 265                 {
 266                         global $DIR_LIBS;
 267                         include $DIR_LIBS . 'ENCAPSULATE.php';
 268                 }
 269                 return;
 270         }
 271
 272         /**
 273          * AdminActions::getAvailableActions()
 274          *
 275          * @param       void
 276          * @return      array   allowed actions for the page type
 277          */
 278         public function getAvailableActions()
 279         {
 280                 $extra_actions = array();
 281
 282                 switch ( $this->skintype )
 283                 {
 284                         case 'actionlog':
 285                                 $extra_actions = array(
 286                                         'actionloglist',
 287                                 );
 288                                 break;
 289                         case 'activate':
 290                                 $extra_actions = array(
 291                                         'activationmessage',
 292                                         'eventformextra',
 293                                 );
 294                                 break;
 295                         case 'activatesetpwd':
 296                                 $extra_actions = array(
 297                                 );
 298                                 break;
 299                         case 'addnewlog':
 300                                 $extra_actions = array(
 301                                         'getblogsetting',
 302                                         'blogsetting',
 303                                         'requestblogid',
 304                                         );
 305                                 break;
 306                         case 'adminerrorpage':
 307                                 $extra_actions = array(
 308                                 );
 309                                 break;
 310                         case 'adminskindelete':
 311                                 $extra_actions = array(
 312                                         'editadminskintype',
 313                                 );
 314                                 break;
 315                         case 'adminskinedit':
 316                                 $extra_actions = array(
 317                                         'editadminskin',
 318                                         'defaultadminskintypes',
 319                                         'adminspecialskinlist',
 320                                 );
 321                                 break;
 322                         case 'adminskinedittype':
 323                                 $extra_actions = array(
 324                                         'editadminskintype',
 325                                         'skintypehelp',
 326                                         'allowedadminskinactions',
 327                                         'adminskineditallowedlist',
 328                                 );
 329                                 break;
 330                         case 'adminskiniedoimport':
 331                                 $extra_actions = array(
 332                                         'importskininfo',
 333                                 );
 334                                 break;
 335                         case 'adminskinieimport':
 336                                 $extra_actions = array(
 337                                         'importskininfo',
 338                                 );
 339                                 break;
 340                         case 'adminskinieoverview':
 341                                 $extra_actions = array(
 342                                         'selectlocaladminskinfiles',
 343                                         'adminskinielist',
 344                                 );
 345                                 break;
 346                         case 'adminskinoverview':
 347                                 $extra_actions = array(
 348                                         'adminskinoverview',
 349                                 );
 350                                 break;
 351                         case 'adminskinremovetype':
 352                                 $extra_actions = array(
 353                                         'editadminskintype',
 354                                 );
 355                                 break;
 356                         case 'admintemplatedelete':
 357                                 $extra_actions = array(
 358                                         'editadmintemplateinfo',
 359                                 );
 360                         case 'admintemplateedit':
 361                                 $extra_actions = array(
 362                                         'editadmintemplateinfo',
 363                                 );
 364                                 break;
 365                         case 'admntemplateoverview':
 366                                 $extra_actions = array(
 367                                         'admintemplateoverview',
 368                                 );
 369                                 break;
 370                         case 'backupoverview':
 371                                 $extra_actions = array(
 372                                 );
 373                                 break;
 374                         case 'backuprestore':
 375                                 $extra_actions = array(
 376                                 );
 377                                 break;
 378                         case 'banlist':
 379                                 $extra_actions = array(
 380                                         'adminbloglink',
 381                                         'adminbanlist',
 382                                         'requestblogid',
 383                                 );
 384                                 break;
 385                         case 'banlistdelete':
 386                                 $extra_actions = array(
 387                                         'requestiprange',
 388                                         'requestblogid',
 389                                 );
 390                                 break;
 391                         case 'banlistdeleteconfirm':
 392                                 $extra_actions = array(
 393                                         'banlistdeletedlist',
 394                                         'requestblogid',
 395                                 );
 396                                 break;
 397                         case 'banlistnew':
 398                                 $extra_actions = array(
 399                                         'iprangeinput',
 400                                         'requestblogid',
 401                                         'blogsetting',
 402                                 );
 403                                 break;
 404                         case 'batchcategory':
 405                                 $extra_actions = array(
 406                                         'adminbatchaction',
 407                                         'adminbatchlist',
 408                                 );
 409                                 break;
 410                         case 'batchcomment':
 411                                 $extra_actions = array(
 412                                         'adminbatchaction',
 413                                         'adminbatchlist',
 414                                 );
 415                                 break;
 416                         case 'batchdelete':
 417                                 $extra_actions = array(
 418                                         'batchdeletetype',
 419                                         'batchdeletelist',
 420                                 );
 421                                 break;
 422                         case 'batchitem':
 423                                 $extra_actions = array(
 424                                         'adminbatchaction',
 425                                         'adminbatchlist',
 426                                 );
 427                                 break;
 428                         case 'batchmember':
 429                                 $extra_actions = array(
 430                                         'adminbatchaction',
 431                                         'adminbatchlist',
 432                                 );
 433                                 break;
 434                         case 'batchmove':
 435                                 $extra_actions = array(
 436                                         'batchmovetitle',
 437                                         'batchmovetype',
 438                                         'batchmovelist',
 439                                         'movedistselect',
 440                                         'batchmovebtn',
 441                                 );
 442                                 break;
 443                         case 'batchmovecat':
 444                                 $extra_actions = array(
 445                                         'batchmovetitle',
 446                                         'batchmovetype',
 447                                         'batchmovelist',
 448                                         'movedistselect',
 449                                         'batchmovebtn',
 450                                 );
 451                                 break;
 452                         case 'batchteam':
 453                                 $extra_actions = array(
 454                                         'requestblogid',
 455                                         'adminbatchaction',
 456                                         'adminbatchlist',
 457                                 );
 458                                 break;
 459                         case 'blogcommentlist':
 460                                 $extra_actions = array(
 461                                         'adminbloglink',
 462                                         'commentnavlist',
 463                                         'adminbatchlist',
 464                                 );
 465                                 break;
 466                         case 'blogselectbox':
 467                                 $extra_actions = array(
 468                                         'blogselectbox',
 469                                 );
 470                                 break;
 471                         case 'blogsettings':
 472                                 $extra_actions = array(
 473                                         'adminbloglink',
 474                                         'blogcatlist',
 475                                         'blognotifysetting',
 476                                         'blogsetting',
 477                                         'blogsettingyesno',
 478                                         'blogteammembers',
 479                                         'blogtime',
 480                                         'defcatselect',
 481                                         'defskinselect',
 482                                         'pluginextras',
 483                                         'pluginoptions',
 484                                         'requestblogid',
 485                                 );
 486                                 break;
 487                         case 'bookmarklet':
 488                                 $extra_actions = array(
 489                                         'bookmarkletadmin',
 490                                 );
 491                                 break;
 492                         case 'browseowncomments':
 493                                 $extra_actions = array(
 494                                         'commentnavlist',
 495                                 );
 496                                 break;
 497                         case 'browseownitems':
 498                                 $extra_actions = array(
 499                                         'itemnavlist',
 500                                 );
 501                                 break;
 502                         case 'categorydelete':
 503                                 $extra_actions = array(
 504                                         'categorysetting',
 505                                         'requestblogid',
 506                                 );
 507                                 break;
 508                         case 'categoryedit':
 509                                 $extra_actions = array(
 510                                         'requestblogid',
 511                                         'categorysetting',
 512                                         'editdesturl',
 513                                         'pluginoptions'
 514                                 );
 515                                 break;
 516                         case 'commentdelete':
 517                                 $extra_actions = array(
 518                                         'deletecomment',
 519                                 );
 520                                 break;
 521                         case 'commentedit':
 522                                 $extra_actions = array(
 523                                         'editcomment',
 524                                 );
 525                                 break;
 526                         case 'createitem':
 527                                 $extra_actions = array(
 528                                         'adminbloglink',
 529                                         'blogid',
 530                                         'contents',
 531                                         'categories',
 532                                         'currenttime',
 533                                         'init',
 534                                         'itemoptions',
 535                                         'pluginextras'
 536                                 );
 537                                 break;
 538                         case 'createnewlog':
 539                                 $extra_actions = array(
 540                                         'defskinselect',
 541                                         'blogtime',
 542                                 );
 543                                 break;
 544                         case 'deleteblog':
 545                                 $extra_actions = array(
 546                                         'blogsetting',
 547                                         'requestblogid',
 548                                 );
 549                                 break;
 550                         case 'editmembersettings':
 551                                 $extra_actions = array(
 552                                         'adminskinselectoptions',
 553                                         'editmember',
 554                                         'localeselectoptions',
 555                                         'pluginoptions',
 556                                 );
 557                                 break;
 558                         case 'insertpluginoptions':
 559                                 $extra_actions = array(
 560                                         'insertpluginoptions',
 561                                 );
 562                                 break;
 563                         case 'itemcommentlist':
 564                                 $extra_actions = array(
 565                                         'requestblogid',
 566                                         'commentnavlist',
 567                                 );
 568                                 break;
 569                         case 'itemdelete':
 570                                 $extra_actions = array(
 571                                         'deleteitemtitle',
 572                                         'deleteitembody',
 573                                         'deleteitemid',
 574                                 );
 575                                 break;
 576                         case 'itemedit':
 577                                 $extra_actions = array(
 578                                         'init',
 579                                         'contents',
 580                                         'checkedonval',
 581                                         'categories',
 582                                         'currenttime',
 583                                         'itemtime',
 584                                         'pluginextras',
 585                                         'itemoptions'
 586                                 );
 587                                 break;
 588                         case 'itemlist':
 589                                 $extra_actions = array(
 590                                         'adminbloglink',
 591                                         'ilistaddnew',
 592                                         'itemnavlist',
 593                                 );
 594                                 break;
 595                         case 'itemmove':
 596                                 $extra_actions = array(
 597                                         'moveitemid',
 598                                         'movedistselect',
 599                                 );
 600                                 break;
 601                         case 'manage':
 602                                 $extra_actions = array(
 603                                 );
 604                                 break;
 605                         case 'manageteam':
 606                                 $extra_actions = array(
 607                                         'requestblogid',
 608                                         'blogsetting',
 609                                         'blogteamlist',
 610                                         'newmemberselect',
 611                                         'inputyesno',
 612                                 );
 613                                 break;
 614                         case 'memberdelete':
 615                                 $extra_actions = array(
 616                                         'editmember',
 617                                 );
 618                                 break;
 619                         case 'overview':
 620                                 $extra_actions = array(
 621                                         'yrbloglist',
 622                                 );
 623                                 break;
 624                         case 'pagefoot':
 625                                 $extra_actions = array(
 626                                         'date',
 627                                         'qmenuaddselect',
 628                                         'member',
 629                                         'quickmenu',
 630                                 );
 631                                 break;
 632                         case 'pagehead':
 633                                 $extra_actions = array(
 634                                         'charset',
 635                                         'sitevar',
 636                                         'adminurl',
 637                                         'extrahead',
 638                                         'member',
 639                                         'versioncheckurl',
 640                                         'version',
 641                                         'codename',
 642                                         'newestcompare',
 643                                 );
 644                                 break;
 645                         case 'plugindelete':
 646                                 $extra_actions = array(
 647                                         'editpluginfo',
 648                                 );
 649                                 break;
 650                         case 'pluginhelp':
 651                                 $extra_actions = array(
 652                                         'helpplugname',
 653                                         'pluginhelp',
 654                                 );
 655                                 break;
 656                         case 'pluginlist':
 657                                 $extra_actions = array(
 658                                         'pluginlistlist',
 659                                         'newpluginlist',
 660                                 );
 661                                 break;
 662                         case 'pluginoptions':
 663                                 $extra_actions = array(
 664                                         'editpluginfo',
 665                                         'editplugoptionslist',
 666                                 );
 667                                 break;
 668                         case 'settingsedit':
 669                                 $extra_actions = array(
 670                                         'defblogselect',
 671                                         'defskinselect',
 672                                         'configsettingsedit',
 673                                         'configsettingsyesno',
 674                                         'outputspecialdirs',
 675                                         'jstoolbaroptions',
 676                                         'localeselectoptions',
 677                                         'mediadirwarning',
 678                                         'pluginextras',
 679                                 );
 680                                 break;
 681                         case 'showlogin':
 682                                 $extra_actions = array(
 683                                         'passrequestvars',
 684                                 );
 685                                 break;
 686                         case 'skindelete':
 687                                 $extra_actions = array(
 688                                         'editskintype',
 689                                 );
 690                                 break;
 691                         case 'skinedit':
 692                                 $extra_actions = array(
 693                                         'editskin',
 694                                         'specialskinlist',
 695                                 );
 696                                 break;
 697                         case 'skinedittype':
 698                                 $extra_actions = array(
 699                                         'editskintype',
 700                                         'skintypehelp',
 701                                         'allowedskinactions',
 702                                         'skineditallowedlist',
 703                                         'skineditallowedlist',
 704                                 );
 705                                 break;
 706                         case 'skiniedoimport':
 707                                 $extra_actions = array(
 708                                         'importskininfo',
 709                                 );
 710                                 break;
 711                         case 'skinieimport':
 712                                 $extra_actions = array(
 713                                         'importskininfo',
 714                                 );
 715                                 break;
 716                         case 'skinieoverview':
 717                                 $extra_actions = array(
 718                                         'selectlocalskinfiles',
 719                                         'skinielist',
 720                                 );
 721                                 break;
 722                         case 'skinoverview':
 723                                 $extra_actions = array(
 724                                         'skinoverview',
 725                                 );
 726                                 break;
 727                         case 'skinremovetype':
 728                                 $extra_actions = array(
 729                                         'editskintype',
 730                                 );
 731                                 break;
 732                         case 'systemoverview':
 733                                 $extra_actions = array(
 734                                         'systemsettings',
 735                                 );
 736                                 break;
 737                         case 'teamdelete':
 738                                 $extra_actions = array(
 739                                         'editmember',
 740                                         'blogsetting',
 741                                         'requestblogid',
 742                                 );
 743                                 break;
 744                         case 'templatedelete':
 745                                 $extra_actions = array(
 746                                         'edittemplateinfo',
 747                                 );
 748                                 break;
 749                         case 'templateedit':
 750                                 $extra_actions = array(
 751                                         'edittemplateinfo',
 752                                 );
 753                                 break;
 754                         case 'templateoverview':
 755                                 $extra_actions = array(
 756                                         'templateoverview',
 757                                 );
 758                                 break;
 759                         case 'usermanagement':
 760                                 $extra_actions = array(
 761                                         'editmemberlist',
 762                                         'inputyesno',
 763                                 );
 764                                 break;
 765                         case 'importAdmin':
 766                                 $extra_actions = array(
 767                                         'charset',
 768                                         'sitevar',
 769                                         'adminurl',
 770                                         'extrahead',
 771                                         'member',
 772                                         'versioncheckurl',
 773                                         'version',
 774                                         'codename',
 775                                         'newestcompare',
 776                                         'selectlocaladminskinfiles',
 777                                         'adminskinielist',
 778                                 );
 779                                 break;
 780                         default:
 781                                 break;
 782                 }
 783
 784                 $defined_actions = array_merge(self::$default_actions, $extra_actions);
 785
 786                 return array_merge($defined_actions, parent::getAvailableActions());
 787         }
 788
 789         /**
 790          * AdminActions::setSkin()
 791          * Set the skin
 792          * @param       object  $skin   an instance of Skin class
 793          * @return      void
 794          */
 795         public function setSkin(&$skin)
 796         {
 797                 $this->skin =& $skin;
 798                 return;
 799         }
 800
 801         /**
 802          * AdminActions::parse_actionloglist()
 803          * Parse skinvar actionloglist
 804          *
 805          * @param       string  $templateName   name of template to use
 806          * @return      void
 807          */
 808         public function parse_actionloglist($templateName = '')
 809         {
 810                 $query = "SELECT * FROM %s ORDER BY timestamp DESC";
 811                 $query = sprintf($query, sql_table('actionlog'));
 812
 813                 $template['content'] = 'actionlist';
 814                 $amount = showlist($query, 'table', $template, $templateName);
 815                 return;
 816         }
 817
 818
 819         /**
 820          * AdminActions::parse_activationmessage()
 821          * Parse skinvar activationmessage
 822          *
 823          * @param       string  $type                   type of message
 824          * @param       string  $templateName   name of template to use
 825          * @return      void
 826          */
 827         public function parse_activationmessage($type, $templateName = '')
 828         {
 829                 global $CONF, $manager;
 830
 831                 $template = array();
 832
 833                 if ( !empty($templateName))
 834                 {
 835                         $template = Template::read($templateName);
 836                 }
 837
 838                 $key = postVar('ackey');
 839                 if ( !$key )
 840                 {
 841                         Admin::error(_ERROR_ACTIVATE);
 842                 }
 843
 844                 $info = MEMBER::getActivationInfo($key);
 845                 if ( !$info )
 846                 {
 847                         Admin::error(_ERROR_ACTIVATE);
 848                 }
 849
 850                 $mem  = MEMBER::createFromId($info->vmember);
 851                 if ( !$mem )
 852                 {
 853                         Admin::error(_ERROR_ACTIVATE);
 854                 }
 855                 switch ( $info->vtype )
 856                 {
 857                         case 'forgot':
 858                                 if ( array_key_exists('ACTIVATE_FORGOT_TITLE', $template) && !empty($template['ACTIVATE_FORGOT_TITLE']) )
 859                                 {
 860                                         $title = $template['ACTIVATE_FORGOT_TITLE'];
 861                                 }
 862                                 else
 863                                 {
 864                                         $title = _ACTIVATE_FORGOT_TITLE;
 865                                 }
 866                                 if ( array_key_exists('ACTIVATE_FORGOT_TEXT', $template) && !empty($template['ACTIVATE_FORGOT_TEXT']) )
 867                                 {
 868                                         $text = $template['ACTIVATE_FORGOT_TEXT'];
 869                                 }
 870                                 else
 871                                 {
 872                                         $text = _ACTIVATE_FORGOT_TEXT;
 873                                 }
 874                                 break;
 875                         case 'register':
 876                                 if ( array_key_exists('ACTIVATE_REGISTER_TITLE', $template) && !empty($template['ACTIVATE_REGISTER_TITLE']) )
 877                                 {
 878                                         $title = $template['ACTIVATE_REGISTER_TITLE'];
 879                                 }
 880                                 else
 881                                 {
 882                                         $title = _ACTIVATE_REGISTER_TITLE;
 883                                 }
 884                                 if ( array_key_exists('ACTIVATE_REGISTER_TEXT', $template) && !empty($template['ACTIVATE_REGISTER_TEXT']) )
 885                                 {
 886                                         $text = $template['ACTIVATE_REGISTER_TEXT'];
 887                                 }
 888                                 else
 889                                 {
 890                                         $text = _ACTIVATE_REGISTER_TEXT;
 891                                 }
 892                                 break;
 893                         case 'addresschange':
 894                                 if ( array_key_exists('ACTIVATE_CHANGE_TITLE', $template) && !empty($template['ACTIVATE_CHANGE_TITLE']) )
 895                                 {
 896                                         $title = $template['ACTIVATE_CHANGE_TITLE'];
 897                                 }
 898                                 else
 899                                 {
 900                                         $title = _ACTIVATE_CHANGE_TITLE;
 901                                 }
 902                                 if (array_key_exists('ACTIVATE_CHANGE_TEXT', $template) && !empty($template['ACTIVATE_CHANGE_TEXT']))
 903                                 {
 904                                         $text = $template['ACTIVATE_CHANGE_TEXT'];
 905                                 }
 906                                 else
 907                                 {
 908                                         $text = _ACTIVATE_CHANGE_TEXT;
 909                                 }
 910                                 break;
 911                 }
 912                 $aVars = array(
 913                         'memberName'    => Entity::hsc($mem->getDisplayName()),
 914                         'realName'              => Entity::hsc($mem->getRealName()),
 915                 );
 916                 switch ( $type )
 917                 {
 918                         case 'title':
 919                                 echo Template::fill($title, $aVars);
 920                                 break;
 921                         case 'text':
 922                                 echo Template::fill($text,  $aVars);
 923                                 break;
 924                         case 'ackey':
 925                                 echo Entity::hsc($key);
 926                                 break;
 927                 }
 928                 return;
 929         }
 930
 931         /**
 932          * AdminActions::parse_addtickettourl()
 933          * Parse skinvar addtickettourl
 934          *
 935          * @param       string  $url    URI for ticket
 936          * @return      void
 937          */
 938         public function parse_addtickettourl($url)
 939         {
 940                 global $manager;
 941                 $url = $manager->addTicketToUrl($url);
 942                 echo Entity::hsc($url);
 943                 return;
 944         }
 945
 946         /**
 947          * AdminActions::parse_adminbanlist()
 948          * Parse skinvar adminbanlist
 949          *
 950          * @param       string  $templateName   name of template to use
 951          * @return      void
 952          */
 953         public function parse_adminbanlist($templateName = '')
 954         {
 955                 $blogid = intRequestVar('blogid');
 956
 957                 $query = "SELECT * FROM %s WHERE blogid=%d ORDER BY iprange;";
 958                 $query = sprintf($query, sql_table('ban'), (integer) $blogid);
 959
 960                 $template['content'] = 'banlist';
 961
 962                 $amount = Showlist($query, 'table', $template, $templateName);
 963
 964                 if ( $amount == 0 )
 965                 {
 966                         echo _BAN_NONE;
 967                 }
 968                 return;
 969         }
 970
 971         /**
 972          * AdminActions::parse_adminbatchaction()
 973          * Parse skinvar adminbatchaction
 974          *
 975          * @param       void
 976          * @return      void
 977          */
 978         public function parse_adminbatchaction()
 979         {
 980                 echo Entity::hsc(requestVar('batchaction'));
 981                 return;
 982         }
 983
 984         /**
 985          * AdminActions::parse_adminbatchlist()
 986          * Parse skinvar adminbatchlist
 987          *
 988          * @param       string  $templateName   name of template to use
 989          * @return      void
 990          */
 991         public function parse_adminbatchlist($templateName = '')
 992         {
 993                 global $manager;
 994                 $templates = array();
 995
 996                 if ( !empty($templateName) )
 997                 {
 998                         $templates = Template::read($templateName);
 999                 }
1000
1001                 if ( !array_key_exists('ADMIN_BATCHLIST', $templates) || empty($templates['ADMIN_BATCHLIST']) )
1002                 {
1003                         $template = '<li><%text(_BATCH_EXECUTING)%>'
1004                                   . '<b><%adminbatchaction%></b>'
1005                                   . '<%batchlisttype%>'
1006                                   . '<b><%batchid%></b>...'
1007                                   . '<b><%batchlistmsg%></b>'
1008                                   . '</li>' . "\n";
1009                 }
1010                 else
1011                 {
1012                         $template = $templates['ADMIN_BATCHLIST'];
1013                 }
1014
1015                 $selected = requestIntArray('batch');
1016                 $action   = requestVar('batchaction');
1017
1018                 switch ( $this->skintype )
1019                 {
1020                         case 'batchitem':
1021                                 $batchlisttype  = _BATCH_ONITEM;
1022                                 $deleteaction   = 'deleteOneItem';
1023                                 $moveaction             = 'moveOneItem';
1024                                 $destid                 = intRequestVar('destcatid');
1025                                 break;
1026                         case 'batchcomment':
1027                                 $batchlisttype  = _BATCH_ONCOMMENT;
1028                                 $deleteaction   = 'deleteOneComment';
1029                                 break;
1030                         case 'batchmember':
1031                                 $batchlisttype  = _BATCH_ONMEMBER;
1032                                 $deleteaction   = 'deleteOneMember';
1033                                 $setadminsql    = sql_table('member') . ' SET madmin = 1 WHERE mnumber = ';
1034                                 $unsetchksql    = 'SELECT * FROM ' . sql_table('member') . ' WHERE madmin = 1 AND mcanlogin = 1';
1035                                 $unsetupsql             = sql_table('member') . ' SET madmin = 0 WHERE mnumber = ';
1036                                 $unseterrmsg    = _ERROR_ATLEASTONEADMIN;
1037                                 break;
1038                         case 'batchteam':
1039                                 $blogid                 = intRequestVar('blogid');
1040                                 $batchlisttype  = _BATCH_ONTEAM;
1041                                 $deleteaction   = 'deleteOneTeamMember';
1042                                 $setadminsql    = sql_table('team') . ' SET tadmin = 1 WHERE tblog = ' . $blogid . ' AND tmember = ';
1043                                 $unsetchksql    = 'SELECT * FROM ' . sql_table('team') . ' WHERE tadmin = 1 AND tblog = ' . $blogid;
1044                                 $unseterrmsg    = _ERROR_ATLEASTONEBLOGADMIN;
1045                                 $unsetupsql             = sql_table('team') . ' SET tadmin = 0 WHERE tblog = ' . $blogid . ' AND tmember = ';
1046                                 break;
1047                         case 'batchcategory':
1048                                 $batchlisttype  = _BATCH_ONCATEGORY;
1049                                 $deleteaction   = 'deleteOneCategory';
1050                                 $moveaction             = 'moveOneCategory';
1051                                 $destid                 = intRequestVar('destblogid');
1052                                 break;
1053                 }
1054
1055                 // walk over all selectedids and perform action
1056                 foreach ( $selected as $selectedid )
1057                 {
1058                         $error = '';
1059                         $selectedid = intval($selectedid);
1060
1061                         switch ( $action )
1062                         {
1063                                 case 'delete':
1064                                         if ( $this->skintype != 'batchteam' )
1065                                         {
1066                                                 $error = Admin::deleteaction($selectedid);
1067                                         }
1068                                         else
1069                                         {
1070                                                 $error  = Admin::deleteOneTeamMember($blogid, $selectedid);
1071                                         }
1072                                         break;
1073                                 case 'move':
1074                                         $error = Admin::moveaction($selectedid, $destid);
1075                                         break;
1076                                 case 'setadmin':
1077                                         // always succeeds
1078                                         sql_query("UPDATE {$setadminsql} {$selectedid};");
1079                                         $error = '';
1080                                         break;
1081                                 case 'unsetadmin':
1082                                         // there should always remain at least one super-admin
1083                                         $r = sql_query($unsetchksql);
1084                                         if ( sql_num_rows($r) < 2 )
1085                                         {
1086                                                 $error = $unseterrmsg;
1087                                         }
1088                                         else
1089                                         {
1090                                                 sql_query("UPDATE {$setadminsql} {$selectedid};");
1091                                         }
1092                                         break;
1093                                 default:
1094                                         $error = _BATCH_UNKNOWN . Entity::hsc($action);
1095                         }
1096
1097                         $data = array(
1098                                 'batchid'                       => $selectedid,
1099                                 'batchlisttype'         => Entity::hsc($batchlisttype),
1100                                 'adminbatchaction'      => Entity::hsc($action),
1101                                 'batchlistmsg'          => $error ? $error : _BATCH_SUCCESS,
1102                         );
1103
1104                         $handler = new AdminActions('template');
1105                         $parser = new Parser($handler);
1106
1107                         ob_start();
1108                         $parser->parse($template);
1109                         $template = ob_get_contents();
1110                         ob_end_clean();
1111
1112                         echo Template::fill($template, $data);
1113                         return;
1114                 }
1115         }
1116
1117         /**
1118          * AdminActions::parse_adminbloglink()
1119          * Parse skinvar adminbloglink
1120          *
1121          * @param       string  $templateName   name of template to use
1122          * @return      void
1123          */
1124         public function parse_adminbloglink($templateName = '')
1125         {
1126                 global $manager;
1127                 $blogid =  intRequestVar('blogid');
1128                 $blog   =& $manager->getBlog($blogid);
1129                 $templates = array();
1130
1131                 if ( !empty($templateName) )
1132                 {
1133                         $templates = Template::read($templateName);
1134                 }
1135
1136                 if ( !array_key_exists('ADMIN_BLOGLINK', $templates) || empty($templates['ADMIN_BLOGLINK']) )
1137                 {
1138                         $template = '<a href="<%url%>" title="<%adminbloglinktitle%>"><%blogname%></a>';
1139                 }
1140                 else
1141                 {
1142                         $template = $templates['ADMIN_BLOGLINK'];
1143                 }
1144
1145                 $data = array(
1146                         'url'                                   => Entity::hsc($blog->getURL()),
1147                         'adminbloglinktitle'    => _BLOGLIST_TT_VISIT,
1148                         'blogname'                              => Entity::hsc($blog->getName())
1149                 );
1150
1151                 echo Template::fill($template, $data);
1152                 return;
1153         }
1154
1155         /**
1156          * AdminActions::parse_adminerrormesg()
1157          * Parse skinvar adminerrormesg
1158          *
1159          * @param       void
1160          * @return      void
1161          */
1162         public function parse_adminerrormesg()
1163         {
1164                 global $CONF;
1165                 $message = '';
1166
1167                 if ( requestVar('errormessage') )
1168                 {
1169                         $message = requestVar('errormessage');
1170                 }
1171                 elseif ( cookieVar($CONF['CookiePrefix'] . 'errormessage') )
1172                 {
1173                         $message = cookieVar($CONF['CookiePrefix'] . 'errormessage');
1174                 }
1175                 elseif ( Admin::sessionVar($CONF['CookiePrefix'] . 'errormessage') )
1176                 {
1177                         $message = Admin::sessionVar($CONF['CookiePrefix'] . 'errormessage');
1178                 }
1179                 echo Entity::hsc($message);
1180                 return;
1181         }
1182
1183         /**
1184          * AdminActions::parse_adminskineditallowedlist()
1185          * Parse skinvar adminskineditallowedlist
1186          *
1187          * @param       string  $type                   template/blog
1188          * @param       string  $templateName   name of template to use
1189          * @return      void
1190          */
1191         public function parse_adminskineditallowedlist($type = 'template', $templateName = '')
1192         {
1193                 switch ( $type )
1194                 {
1195                         /* TODO: blog seems not to be used */
1196                         case 'blog':
1197                                 $query = "SELECT bshortname, bname FROM %s";
1198                                 $query = sprintf($query, sql_table('blog'));
1199                                 $show  = array(
1200                                         'content' => 'shortblognames'
1201                                 );
1202                                 Showlist($query, 'table', $show, $templateName);
1203                                 break;
1204                         case 'template':
1205                                 $query = "SELECT tdname as name, tddesc as description FROM %s WHERE tdname LIKE 'admin/%%'";
1206                                 $query = sprintf($query, sql_table('template_desc'));
1207                                 $show  = array(
1208                                         'content' => 'shortnames'
1209                                 );
1210                                 Showlist($query, 'table', $show, $templateName);
1211                                 break;
1212                 }
1213                 return;
1214         }
1215
1216         /**
1217          * AdminActions::parse_adminskinielist()
1218          * Parse skinvar adminskinielist
1219          *
1220          * @param       string  $type                   skin/template
1221          * @param       string  $templateName   name of template to use
1222          * @return      void
1223          */
1224         public function parse_adminskinielist($type, $templateName = '')
1225         {
1226                 $templates = array();
1227                 if ( $templateName )
1228                 {
1229                         $templates = Template::read($templateName);
1230                 }
1231
1232                 if ( !array_key_exists('SKINIE_EXPORT_LIST', $templates) || empty($templates['SKINIE_EXPORT_LIST']) )
1233                 {
1234                         $template = "<td>"
1235                                   . "<input type=\"checkbox\" name=\"<%typeid%>\"  id=\"<%expid%>\" />\n"
1236                                   . "<label for=\"<%expid%>\"><%expname%></label>"
1237                                   . "</td>\n"
1238                                   . "<td><%expdesc%></td>\n"
1239                                   . "</tr>\n"
1240                                   . "<tr>\n";
1241                 }
1242                 else
1243                 {
1244                         $template = $templates['SKINIE_EXPORT_LIST'];
1245                 }
1246
1247                 switch ( $type )
1248                 {
1249                         case 'skin':
1250                                 $query = "SELECT * FROM %s WHERE sdname LIKE 'admin/%%';";
1251                                 $query = sprintf($query, sql_table('skin_desc'));
1252                                 $res = sql_query($query);
1253
1254                                 while ( $skinObj = sql_fetch_object($res) )
1255                                 {
1256                                         $data = array(
1257                                                 'typeid'        => 'skin[' . $skinObj->sdnumber . ']',
1258                                                 'expid'         => 'skinexp' . $skinObj->sdnumber,
1259                                                 'expname'       => Entity::hsc($skinObj->sdname),
1260                                                 'expdesc'       => Entity::hsc($skinObj->sddesc),
1261                                         );
1262                                         echo Template::fill($template, $data);
1263                                 }
1264                                 break;
1265                         case 'template':
1266                                 $query = "SELECT * FROM %s WHERE tdname LIKE 'admin/%%';";
1267                                 $query = sprintf($query, sql_table('template_desc'));
1268                                 $res = sql_query($query);
1269                                 while ( $templateObj = sql_fetch_object($res) )
1270                                 {
1271                                         $data = array(
1272                                                 'typeid'        => 'template[' . $templateObj->tdnumber . ']',
1273                                                 'expid'         => 'templateexp' . $templateObj->tdnumber,
1274                                                 'expname'       => Entity::hsc($templateObj->tdname),
1275                                                 'expdesc'       => Entity::hsc($templateObj->tddesc),
1276                                         );
1277                                         echo Template::fill($template, $data);
1278                                 }
1279                                 break;
1280                 }
1281                 return;
1282         }
1283
1284         /**
1285          * AdminActions::parse_adminskinoverview()
1286          * Parse skinvar adminskinoverview
1287          *
1288          * @param       string  $templateName   name of template to use
1289          * @return      void
1290          */
1291         public function parse_adminskinoverview($templateName = '')
1292         {
1293                 $query = "SELECT * FROM %s WHERE sdname LIKE 'admin/%%' ORDER BY sdname;";
1294                 $query = sprintf($query, sql_table('skin_desc'));
1295
1296                 $template['content'] = 'adminskinlist';
1297                 $template['tabindex'] = 10;
1298                 $template['friendly_names'] = $this->skin->getAvailableTypes();
1299                 Showlist($query, 'table', $template, $templateName);
1300                 return;
1301         }
1302
1303         /**
1304          * AdminActions::parse_adminskinselectoptions()
1305          * Parse skinvar adminskinselectoptions
1306          *
1307          * @param       void
1308          * @return      void
1309          */
1310         public function parse_adminskinselectoptions()
1311         {
1312                 global $CONF;
1313                 $query = "SELECT sdname as text, sdnumber as value FROM %s WHERE sdname LIKE 'admin/%%';";
1314                 $query = sprintf($query, sql_table('skin_desc'));
1315
1316                 $template['name'] = 'adminskin';
1317                 $template['selected'] = $CONF['DefaultAdminSkin'];
1318                 $template['tabindex'] = 110;
1319                 Showlist($query, 'select', $template, '');
1320                 return;
1321         }
1322
1323         /**
1324          * AdminActions::parse_adminspecialskinlist()
1325          * Parse skinvar adminspecialskinlist
1326          *
1327          * @param       string  $templateName   name of template to use
1328          */
1329         public function parse_adminspecialskinlist($templateName = '')
1330         {
1331                 $templates = array();
1332                 if ( $templateName )
1333                 {
1334                         $templates = Template::read($templateName);
1335                 }
1336
1337                 $nType  = $this->skin->getAvailableTypes();
1338                 $skinid = intRequestVar('skinid');
1339
1340                 $query = "SELECT stype FROM  %s WHERE stype NOT IN (%s) AND sdesc=%d;";
1341                 $query = sprintf($query, sql_table('skin'), "'" . implode("', '", $nType) . "'", (integer) $skinid);
1342
1343                 $res    = sql_query($query);
1344                 if ( $res && sql_num_rows($res) > 0 )
1345                 {
1346                         /* NOTE: set templates for HEAD/BODY/FOOT */
1347                         if ( !array_key_exists('ADMIN_SPECIALSKINLIST_HEAD', $templates) || empty($templates['ADMIN_SPECIALSKINLIST_HEAD']) )
1348                         {
1349                                 $template['head'] = "<ul>\n";
1350                         }
1351                         else
1352                         {
1353                                 $template['head'] = $templates['ADMIN_SPECIALSKINLIST_HEAD'];
1354                         }
1355                         if ( !array_key_exists('ADMIN_SPECIALSKINLIST_BODY', $templates) || empty($templates['ADMIN_SPECIALSKINLIST_BODY']) )
1356                         {
1357                                 $template['body'] = '<li>'
1358                                                   . '<a tabindex="<%tabindex%>" href="index.php?action=adminskinedittype&amp;skinid=<%skinid%>&amp;type=<%skintype%>">'
1359                                                   . '<%skintype%>'
1360                                                   . '</a>'
1361                                                   . '(<a tabindex="<%tabindex%>" href="index.php?action=adminskinremovetype&amp;skinid=<%skinid%>&amp;type=<%skintype%>">'
1362                                                   . 'remove'
1363                                                   . '</a>)'
1364                                                   . "</li>\n";
1365                         }
1366                         else
1367                         {
1368                                 $template['body'] = $templates['ADMIN_SPECIALSKINLIST_BODY'];
1369                         }
1370                         if ( !array_key_exists('ADMIN_SPECIALSKINLIST_FOOT', $templates) || empty($templates['ADMIN_SPECIALSKINLIST_FOOT']) )
1371                         {
1372                                 $template['foot'] = "</ul>\n";
1373                         }
1374                         else
1375                         {
1376                                 $template['foot'] = $templates['ADMIN_SPECIALSKINLIST_FOOT'];
1377                         }
1378
1379                         $tabstart = 120;
1380
1381                         /* NOTE: do echo */
1382                         $data = array();
1383                         echo $template['head'];
1384                         while ( $row = sql_fetch_assoc($res) )
1385                         {
1386                                 $data = array(
1387                                         'tabindex'      => $tabstart++,
1388                                         'skinid'        => $skinid,
1389                                         'skintype'      => Entity::hsc(strtolower($row['stype']))
1390                                 );
1391                                 echo Template::fill($template['body'], $data);
1392                         }
1393                         $data = array();
1394                         echo $template['foot'];
1395                 }
1396                 return;
1397         }
1398
1399         /**
1400          * AdminActions::parse_admintemplateoverview()
1401          * Parse skinvar admintemplateoverview
1402          *
1403          * @param       string  $templateName   name of template to use
1404          * @return      void
1405          */
1406         public function parse_admintemplateoverview($templateName = '')
1407         {
1408                 $query = "SELECT * FROM %s WHERE tdname LIKE 'admin/%%' ORDER BY tdname;";
1409                 $query = sprintf($query, sql_table('template_desc'));
1410
1411                 $template['content'] = 'admintemplatelist';
1412                 $template['tabindex'] = 10;
1413
1414                 Showlist($query, 'table', $template, $templateName);
1415                 return;
1416         }
1417
1418         /**
1419          * AdminActions::parse_allowedadminskinactions()
1420          * Parse skinvar allowedadminskinactions
1421          *
1422          * @param       void
1423          * @return      void
1424          */
1425         public function parse_allowedadminskinactions()
1426         {
1427                 global $DIR_ADMINSKINS;
1428                 $skinType = strtolower(trim(requestVar('type')));
1429                 $actions  = $this->skin->getAllowedActionsForType($skinType);
1430                 sort($actions);
1431
1432                 while ( $current = array_shift($actions) )
1433                 {
1434                         // TODO: remove this
1435                         // skip deprecated vars
1436                         if ($current == 'ifcat' || $current == 'imagetext' || $current == 'vars')
1437                         {
1438                                 continue;
1439                         }
1440
1441                         echo helplink("adminskinvar-{$current}") . "$current</a>\n";
1442
1443                         if ( count($actions) != 0 )
1444                         {
1445                                 echo ", ";
1446                         }
1447                 }
1448                 return;
1449         }
1450
1451         /**
1452          * AdminActions::parse_allowedskinactions()
1453          * Parse skinvar allowedskinactions
1454          *
1455          * @param       void
1456          * @return      void
1457          */
1458         public function parse_allowedskinactions()
1459         {
1460                 $skinType = strtolower(trim(requestVar('type')));
1461                 $skinid = intRequestVar('skinid');
1462
1463                 $skin = new Skin($skinid);
1464                 $actions = $skin->getAllowedActionsForType($skinType);
1465                 sort($actions);
1466
1467                 while ( $current = array_shift($actions) )
1468                 {
1469                         // TODO: remove this
1470                         // skip deprecated vars
1471                         if ( $current == 'ifcat' || $current == 'imagetext' || $current == 'vars' )
1472                         {
1473                                 continue;
1474                         }
1475
1476                         /* TODO: alternative function should be used or not?  */
1477                         echo helplink("skinvar-{$current}") . "$current</a>\n";
1478
1479                         if ( count($actions) != 0 )
1480                         {
1481                                 echo ", ";
1482                         }
1483                 }
1484                 return;
1485         }
1486
1487         /**
1488          * AdminActions::parse_banlistdeletedlist()
1489          * Parse skinvar banlistdeletedlist
1490          *
1491          * @param       string  $templateName   name of template to use
1492          * @return      void
1493          */
1494         public function parse_banlistdeletedlist($templateName = '')
1495         {
1496                 global $manager;
1497                 $templates = array();
1498
1499                 if ( $templateName )
1500                 {
1501                         $templates = Template::read($templateName);
1502                 }
1503                 if ( !array_key_exists('BANLIST_DELETED_LIST', $templates) || empty($templates['BANLIST_DELETED_LIST']) )
1504                 {
1505                         $template = "<li><%blogname%></li>\n";
1506                 }
1507                 else
1508                 {
1509                         $template = $templates['BANLIST_DELETED_LIST'];
1510                 }
1511
1512                 $deleted = requestArray('delblogs');
1513                 foreach ( $deleted as $delblog )
1514                 {
1515                         $blog =& $manager->getBlog($delblog);
1516                         $data =  array(
1517                                 Entity::hsc($blog->getName())
1518                         );
1519                         Template::fill($template, $data);
1520                 }
1521                 return;
1522         }
1523
1524         /**
1525          * AdminActions::parse_batchdeletelist()
1526          * Parse skinvar batchdeletelist
1527          *
1528          * @param       void
1529          * @return      void
1530          */
1531         public function parse_batchdeletelist()
1532         {
1533                 $selected = requestIntArray('batch');
1534                 $index  = 0;
1535
1536                 foreach ( $selected as $select )
1537                 {
1538                         echo '<input type="hidden" name="batch[' . ($index++) . ']" value="' . intval($select) . "\" />\n";
1539                 }
1540                 // add hidden vars for team & comment
1541                 if ( requestVar('action') == 'batchteam' )
1542                 {
1543                         echo '<input type="hidden" name="blogid" value="' . intRequestVar('blogid') . "\" />\n";
1544                 }
1545                 if ( requestVar('action') == 'batchcomment' )
1546                 {
1547                         echo '<input type="hidden" name="itemid" value="' . intRequestVar('itemid') . "\" />\n";
1548                 }
1549                 return;
1550         }
1551
1552         /**
1553          * AdminActions::parse_batchdeletetype()
1554          * Parse skinvar batchdeletetype
1555          *
1556          * @param       void
1557          * @return      void
1558          */
1559         public function parse_batchdeletetype()
1560         {
1561                 echo Entity::hsc(requestVar('action'));
1562                 return;
1563         }
1564
1565         /**
1566          * AdminActions::parse_batchmovebtn()
1567          * Parse skinvar batchmovebtn
1568          *
1569          * @param       void
1570          * @return      void
1571          */
1572         public function parse_batchmovebtn()
1573         {
1574                 $actionType = requestVar('action');
1575                 switch ( $actionType )
1576                 {
1577                         case 'batchitem':
1578                                 echo _MOVE_BTN;
1579                                 break;
1580                         case 'batchcategory':
1581                                 echo _MOVECAT_BTN;
1582                                 break;
1583                 }
1584                 return;
1585         }
1586
1587         /**
1588          * AdminActions::parse_batchmovelist()
1589          * Parse skinvar batchmovelist
1590          *
1591          * @param       void
1592          * @param       void
1593          */
1594         public function parse_batchmovelist()
1595         {
1596                 $selected = requestIntArray('batch');
1597                 foreach ( $selected as $select )
1598                 {
1599                         echo '<input type="hidden" name="batch[' . ($select++) . ']" value="' . intval($select) . "\" />\n";
1600                 }
1601                 return;
1602         }
1603
1604         /**
1605          * AdminActions::parse_batchmovetitle()
1606          * Parse skinvar batchmovetitle
1607          *
1608          * @param       void
1609          * @return      void
1610          */
1611         public function parse_batchmovetitle()
1612         {
1613                 $actionType = requestVar('action');
1614                 switch ( $actionType )
1615                 {
1616                         case 'batchitem':
1617                                 echo _MOVE_TITLE;
1618                                 break;
1619                         case 'batchcategory':
1620                                 echo _MOVECAT_TITLE;
1621                                 break;
1622                 }
1623                 return;
1624         }
1625
1626         /**
1627          * AdminActions::parse_batchmovetype()
1628          * Parse skinvar batchmovetype
1629          *
1630          * @param       void
1631          * @return      void
1632          */
1633         public function parse_batchmovetype()
1634         {
1635                 echo Entity::hsc(requestVar('action'));
1636                 return;
1637         }
1638
1639         /**
1640          * AdminActions::parse_blogcatlist()
1641          * Parse skinvar blogcatlist
1642          *
1643          * @param       void
1644          * @return      void
1645          */
1646         public function parse_blogcatlist()
1647         {
1648                 global $manager;
1649                 $blogid = intRequestVar('blogid');
1650                 $query  = "SELECT * FROM %s WHERE cblog = %d ORDER BY cname;";
1651                 $query = sprintf($query, sql_table('category'), (integer) $blogid);
1652
1653                 $template['content']  = 'categorylist';
1654                 $template['tabindex'] = 200;
1655
1656                 $batch = new Batch('category');
1657                 $batch->showlist($query, 'table', $template);
1658                 return;
1659         }
1660
1661         /**
1662          * AdminActions::parse_blogid()
1663          * Parse skinvar blogid
1664          *
1665          * @param       void
1666          * @return      void
1667          */
1668         function parse_blogid()
1669         {
1670                 echo intRequestVar('blogid');
1671                 return;
1672         }
1673
1674         /**
1675          * AdminActions::parse_blognotifysetting()
1676          * Parse skinvar blognotifysetting
1677          *
1678          * @param       void
1679          * @return      void
1680          */
1681         public function parse_blognotifysetting($type)
1682         {
1683                 global $manager;
1684                 $blogid = intRequestVar('blogid');
1685                 $blog   = $manager->getBlog($blogid);
1686
1687                 switch ( $type )
1688                 {
1689                         case 'comment':
1690                                 if ( !$blog->notifyOnComment() )
1691                                 {
1692                                         return;
1693                                 }
1694                                 break;
1695                         case 'vote':
1696                                 if ( !$blog->notifyOnVote() )
1697                                 {
1698                                         return;
1699                                 }
1700                                 break;
1701                         case 'newitem':
1702                                 if ( !$blog->notifyOnNewItem() )
1703                                 {
1704                                         return;
1705                                 }
1706                                 break;
1707                 }
1708                 echo ' checked="checked"';
1709                 return;
1710         }
1711
1712         /**
1713          * AdminActions::parse_blogselectbox()
1714          * Parse skinvar blogselectbox
1715          *
1716          * @param       void
1717          * @return      void
1718          */
1719         public function parse_blogselectbox()
1720         {
1721                 global $member;
1722
1723                 $selectData     = requestVar('selectData');
1724                 $mode           = $selectData['mode'];
1725                 $name           = Entity::hsc($selectData['name']);
1726                 $tabindex       = Entity::hsc($selectData['tabindex']);
1727                 $aBlogIds       = array_map('intval', $selectData['aBlogIds']);
1728                 $showNewCat     = intval($selectData['showNewCat']);
1729                 $selected       = intval($selectData['selected']);
1730
1731                 echo "<select name=\"{$name}\" tabindex=\"{$tabindex}\">\n";
1732
1733                 // 1. select blogs (we'll create optiongroups)
1734                 // (only select those blogs that have the user on the team)
1735                 $queryBlogs = "SELECT bnumber, bname FROM %s WHERE bnumber in (%s) ORDER BY bname;";
1736                 $queryBlogs = sprintf($queryBlogs, sql_table('blog'), implode(',', $aBlogIds));
1737                 $blogs = sql_query($queryBlogs);
1738
1739                 if ( $mode == 'category' )
1740                 {
1741                         if ( sql_num_rows($blogs) > 1 )
1742                         {
1743                                 $multipleBlogs = 1;
1744                         }
1745                         while ( $oBlog = sql_fetch_object($blogs) )
1746                         {
1747                                 if ( isset($multipleBlogs) && !empty($multipleBlogs) )
1748                                 {
1749                                         echo '<optgroup label="' . Entity::hsc($oBlog->bname) . "\">\n";
1750                                 }
1751
1752                                 // show selection to create new category when allowed/wanted
1753                                 if ( $showNewCat )
1754                                 {
1755                                         // check if allowed to do so
1756                                         if ( $member->blogAdminRights($oBlog->bnumber) )
1757                                         {
1758                                                 echo '<option value="newcat-' . $oBlog->bnumber . '">' . _ADD_NEWCAT . "</option>\n";
1759                                         }
1760                                 }
1761
1762                                 // 2. for each category in that blog
1763                                 $catQuery = "SELECT cname, catid FROM %s WHERE cblog=%d ORDER BY cname ASC;";
1764                                 $catQuery = sprintf($catQuery, sql_table('category'), (integer) $oBlog->bnumber);
1765                                 $categories = sql_query($catQuery);
1766                                 while ( $oCat = sql_fetch_object($categories) )
1767                                 {
1768                                         if ( $oCat->catid == $selected )
1769                                         {
1770                                                 $selectText = ' selected="selected" ';
1771                                         }
1772                                         else
1773                                         {
1774                                                 $selectText = '';
1775                                         }
1776                                         echo '<option value="' . $oCat->catid . '" ' . $selectText . '>' . Entity::hsc($oCat->cname) . "</option>\n";
1777                                 }
1778
1779                                 if ( isset($multipleBlogs) && !empty($multipleBlogs) )
1780                                 {
1781                                         echo '</optgroup>';
1782                                 }
1783                         }
1784                 }
1785                 else
1786                 {
1787                         // blog mode
1788                         while ( $oBlog = sql_fetch_object($blogs) )
1789                         {
1790                                 echo '<option value="' . $oBlog->bnumber . '"';
1791                                 if ( $oBlog->bnumber == $selected )
1792                                 {
1793                                         echo '<option value="' . $oBlog->bnumber . '" selected="selected">' . Entity::hsc($oBlog->bname) . "</option>\n";
1794                                 }
1795                                 else
1796                                 {
1797                                         echo '<option value="' . $oBlog->bnumber . '">' . Entity::hsc($oBlog->bname) . "</option>\n";
1798                                 }
1799                         }
1800                 }
1801                 echo "</select>\n";
1802                 return;
1803         }
1804
1805         /**
1806          * AdminActions::parse_blogsetting()
1807          * Parse skinvar blogsetting
1808          *
1809          * @param       string  $which  name of weblog setting
1810          * @return      void
1811          */
1812         public function parse_blogsetting($which)
1813         {
1814                 echo $this->parse_getblogsetting($which);
1815                 return;
1816         }
1817
1818         /**
1819          * AdminActions::parse_blogsettingyesno()
1820          * Parse skinvar blogsettingyesno
1821          *
1822          * @param       string  $type                   type of weblog setting
1823          * @param       string  $templateName   name of template to use
1824          * @return      void
1825          */
1826         public function parse_blogsettingyesno($type, $templateName = '')
1827         {
1828                 global $manager;
1829
1830                 $blogid = intRequestVar('blogid');
1831                 $blog   = $manager->getBlog($blogid);
1832
1833                 switch ( $type )
1834                 {
1835                         case 'convertbreaks':
1836                                 $checkedval = $blog->convertBreaks();
1837                                 $tabindex   = 55;
1838                                 break;
1839                         case 'allowpastposting':
1840                                 $checkedval = $blog->allowPastPosting();
1841                                 $tabindex   = 57;
1842                                 break;
1843                         case 'comments':
1844                                 $checkedval = $blog->commentsEnabled();
1845                                 $tabindex   = 60;
1846                                 break;
1847                         case 'public':
1848                                 $checkedval = $blog->isPublic();
1849                                 $tabindex   = 70;
1850                                 break;
1851                         case 'reqemail':
1852                                 $checkedval = $blog->emailRequired();
1853                                 $tabindex   = 72;
1854                                 break;
1855                         case 'searchable':
1856                                 $checkedval = $blog->getSearchable();
1857                                 $tabindex   = 122;
1858                                 break;
1859                 }
1860                 $this->parse_inputyesno($type, $checkedval, $tabindex, 1, 0, _YES, _NO, 0, $templateName);
1861                 return;
1862         }
1863
1864         /**
1865          * AdminActions::parse_blogteamlist()
1866          * Parse skinvar blogteamlist
1867          *
1868          * @param       string  $templateName   name of template to use
1869          * @return      void
1870          */
1871         public function parse_blogteamlist($templateName = '')
1872         {
1873                 global $manager;
1874                 $blogid = intRequestVar('blogid');
1875                 $query  = "SELECT tblog, tmember, mname, mrealname, memail, tadmin "
1876                         . "FROM %s, %s "
1877                         . "WHERE tmember=mnumber AND tblog= %d";
1878                 $query = sprintf($query, sql_table('member'), sql_table('team'), (integer) $blogid);
1879
1880                 $template['content']  = 'teamlist';
1881                 $template['tabindex'] = 10;
1882
1883                 $batch = new Batch('team');
1884                 $batch->showlist($query, 'table', $template, _LISTS_NOMORE, $templateName);
1885                 return;
1886         }
1887
1888         /**
1889          * AdminActions::parse_blogteammembers()
1890          * Parse skinvar blogteammembers
1891          *
1892          * @param       void
1893          * @return      void
1894          */
1895         public function parse_blogteammembers()
1896         {
1897                 $blogid = intRequestVar('blogid');
1898                 $query  = "SELECT mname, mrealname "
1899                                 . "FROM %s, %s "
1900                                 . "WHERE mnumber=tmember AND tblog=%d;";
1901                 $query = sprintf($query, sql_table('member'), sql_table('team'), (integer) $blogid);
1902                 $res = sql_query($query);
1903                 $memberNames = array();
1904                 while ( $o = sql_fetch_object($res) )
1905                 {
1906                         $memberNames[] = Entity::hsc($o->mname) . ' (' . Entity::hsc($o->mrealname). ')';
1907                 }
1908                 echo implode(',', $memberNames);
1909         }
1910
1911         /**
1912          * AdminActions::parse_blogtime()
1913          * Parse skinvar blogtime
1914          *
1915          * @param       string  $type   type of time
1916          * @param       string  $format format for time expression
1917          * @param       integer $offset offset of time
1918          * @return      void
1919          */
1920         public function parse_blogtime($type, $format = '%H:%M', $offset = 0)
1921         {
1922                 global $manager;
1923
1924                 if ( $type != 'blogtime' )
1925                 {
1926                         /* return server time */
1927                         $timestamp = time() + $offset;
1928                 }
1929                 else
1930                 {
1931                         $bid = intRequestVar('blogid');
1932                         $b = $manager->getBlog($bid);
1933                         $timestamp = $b->getCorrectTime() + $offset;
1934                 }
1935
1936                 echo i18n::formatted_datetime($format, $timestamp);
1937                 return;
1938         }
1939
1940         /**
1941          * AdminActions::parse_bookmarkletadmin()
1942          * Parse skinvar bookmarkletadmin
1943          *
1944          * @param       void
1945          * @return      void
1946          */
1947         public function parse_bookmarkletadmin()
1948         {
1949                 global $manager;
1950
1951                 $blogid = intRequestVar('blogid');
1952
1953                 echo Entity::hsc('javascript:' . getBookmarklet($blogid));
1954                 return;
1955         }
1956
1957         /**
1958          * AdminActions::parse_categories()
1959          * Parse skinvar categories
1960          *
1961          * create category dropdown box
1962          *
1963          * @param       string  $type   name of setting for category
1964          * @return      void
1965          */
1966         function parse_categories($startidx = 0)
1967         {
1968                 global $manager;
1969
1970                 $item = false;
1971                 $itemid = intRequestVar('itemid');
1972
1973                 $item =& $manager->getItem($itemid, 1, 1);
1974                 $blog =& $manager->getBlog(getBlogIDFromItemID($itemid));
1975
1976                 if ( $item && $blog->convertBreaks() && requestVar('action') == 'itemedit' )
1977                 {
1978                         $item['body'] = removeBreaks($item['body']);
1979                         $item['more'] = removeBreaks($item['more']);
1980                 }
1981
1982                 $contents = array();
1983                 if ( requestVar('action') == 'itemedit' )
1984                 {
1985                         $contents = $item;
1986                 }
1987                 if ( isset($contents['catid']) && $contents['catid'] )
1988                 {
1989                         $catid = $contents['catid'];    // on edit item
1990                 }
1991                 else
1992                 {
1993                         $catid = $blog->getDefaultCategory();   // on add item
1994                 }
1995                 Admin::selectBlogCategory('catid', $catid, $startidx, 1, $blog->getID());
1996                 return;
1997         }
1998
1999         /**
2000          * AdminActions::parse_category()
2001          * Parse skinvar category
2002          *
2003          * @param       string  $type   name of setting for category
2004          * @return      void
2005          */
2006         public function parse_category($type = 'name')
2007         {
2008                 echo $this->parse_getcategory($type);
2009                 return;
2010         }
2011
2012         /**
2013          * AdminActions::parse_categorysetting()
2014          * Parse skinvar categorysetting
2015          *
2016          * @param       string  $type   type in category setting
2017          * @return      void
2018          */
2019         public function parse_categorysetting($type)
2020         {
2021                 $catid  = intRequestVar('catid');
2022                 if ( $type == 'id' )
2023                 {
2024                         echo $catid;
2025                         return;
2026                 }
2027                 $blogid = intRequestVar('blogid');
2028                 $query  = "SELECT * FROM %s WHERE cblog = %d AND catid = %d;";
2029                 $query  = sprintf($query, sql_table('category'), (integer) $blogid, (integer) $catid);
2030                 $res    = sql_query($query);
2031                 $obj    = sql_fetch_object($res);
2032
2033                 if ( $type != 'name' )
2034                 {
2035                         echo Entity::hsc($obj->cdesc);
2036                 }
2037                 else
2038                 {
2039                         echo Entity::hsc($obj->cname);
2040                 }
2041
2042                 return;
2043         }
2044
2045         /**
2046          * AdminActions::parse_codename()
2047          * Parse templatevar codename
2048          *
2049          * @param       $value
2050          * @param       $name
2051          *
2052          */
2053         function parse_checkedonval($value, $name)
2054         {
2055                 global $manager;
2056
2057                 $item = false;
2058                 $itemid = intRequestVar('itemid');
2059                 $item =& $manager->getItem($itemid, 1, 1);
2060
2061                 $blog =& $manager->getBlog(getBlogIDFromItemID($itemid));
2062
2063                 if ( $item && $blog->convertBreaks() && requestVar('action') == 'itemedit' )
2064                 {
2065                         $item['body'] = removeBreaks($item['body']);
2066                         $item['more'] = removeBreaks($item['more']);
2067                 }
2068
2069                 $contents = array();
2070                 if ( requestVar('action') == 'itemedit' )
2071                 {
2072                         $contents = $item;
2073                 }
2074                 if ( !isset($contents[$name]) )
2075                 {
2076                         $contents[$name] = '';
2077                 }
2078                 if ($contents[$name] == $value)
2079                 {
2080                         echo 'checked="checked"';
2081                 }
2082                 return;
2083         }
2084
2085         /**
2086          * AdminActions::parse_codename()
2087          * Parse templatevar codename
2088          *
2089          * @param       void
2090          * @return      void
2091          *
2092          * TODO: is this need???
2093          */
2094         public function parse_codename()
2095         {
2096                 global $nucleus;
2097                 echo $nucleus['codename'];
2098                 return;
2099         }
2100
2101         /**
2102          * AdminActions::parse_commentnavlist()
2103          * Parse skinvar commentnavlist
2104          *
2105          * @param       void
2106          * @return      void
2107          */
2108         public function parse_commentnavlist()
2109         {
2110                 global $CONF, $manager, $member;
2111
2112                 // start index
2113                 if ( postVar('start') )
2114                 {
2115                         $start = intPostVar('start');
2116                 }
2117                 else
2118                 {
2119                         $start = 0;
2120                 }
2121
2122                 // amount of items to show
2123                 if ( postVar('amount') )
2124                 {
2125                         $amount = intPostVar('amount');
2126                 }
2127                 else
2128                 {
2129                         $amount = (integer) $CONF['DefaultListSize'];
2130                         if ( $amount < 1 )
2131                         {
2132                                 $amount = 10;
2133                         }
2134                 }
2135                 $query = 'SELECT cbody, cuser, cmail, cemail, mname, ctime, chost, cnumber, cip, citem '
2136                        . 'FROM %s '
2137                        . 'LEFT OUTER JOIN %s ON  mnumber=cmember '
2138                        . 'WHERE ';
2139                 $query = sprintf($query, sql_table('comment'), sql_table('member'));
2140
2141                 if ( $this->skintype == 'itemcommentlist' )
2142                 {
2143                         $itemid                                 = intRequestVar('itemid');
2144                         $query                                  .= " citem={$itemid}";
2145                         $template['canAddBan']  = $member->blogAdminRights(intRequestVar('blogid'));
2146                         $bid                                    = 0;
2147                         $nonComments                    = _NOCOMMENTS;
2148                 }
2149                 elseif ( $this->skintype == 'browseowncomments' )
2150                 {
2151                         $itemid                                 = 0;
2152                         $query                                  .= ' cmember=' . $member->getID();
2153                         $template['canAddBan']  = 0;
2154                         $bid                                    = 0;
2155                         $nonComments                    = _NOCOMMENTS_YOUR;
2156                 }
2157                 elseif ( $this->skintype == 'blogcommentlist' )
2158                 {
2159                         $itemid                                 = 0;
2160                         $query                                  .= ' cblog=' . intRequestVar('blogid');
2161                         $template['canAddBan']  = $member->blogAdminRights(intRequestVar('blogid'));
2162                         $bid                                    = intRequestVar('blogid');
2163                         $nonComments                    = _NOCOMMENTS_BLOG;
2164                 }
2165
2166                 $search = postVar('search');
2167                 if ( !empty($search) )
2168                 {
2169                         $query .= ' and cbody LIKE "%' . sql_real_escape_string($search) . '%"';
2170                 }
2171
2172                 $query .= " ORDER BY ctime ASC LIMIT {$start},{$amount}";
2173
2174                 $template['content'] = 'commentlist';
2175
2176                 $navList = new Navlist($this->skintype, $start, $amount, 0, 1000, $bid, $search, $itemid);
2177                 $navList->showBatchList('comment', $query, 'table', $template, $nonComments);
2178                 return;
2179         }
2180
2181         /**
2182          * AdminActions::parse_configsettingsedit()
2183          * Parse skinvar configsettingsedit
2184          *
2185          * @param       string  $type   type of global configuration
2186          * @return      void
2187          */
2188         public function parse_configsettingsedit($type)
2189         {
2190                 global $CONF;
2191                 switch ( $type )
2192                 {
2193                         case 'DefaultListSize':
2194                                 if ( !array_key_exists('DefaultListSize', $CONF) )
2195                                 {
2196                                         $query = "INSERT INTO %s VALUES (DefaultListSize, 10);";
2197                                         $query = sprintf($query, sql_table('config'));
2198                                         sql_query($query);
2199                                         $CONF['DefaultListSize'] = 10;
2200                                 }
2201                                 elseif ( intval($CONF['DefaultListSize']) < 1 )
2202                                 {
2203                                         $CONF['DefaultListSize'] = 10;
2204                                 }
2205                                 echo intval($CONF['DefaultListSize']);
2206                                 break;
2207                         case 'SessionCookie':
2208                                 $value = $CONF['SessionCookie'];
2209                                 $txt1  = _SETTINGS_COOKIESESSION;
2210                                 $txt2  = _SETTINGS_COOKIEMONTH;
2211                                 $this->parse_inputyesno('SessionCookie', $value, 10190, 1, 0, $txt1, $txt2);
2212                                 break;
2213                         case 'URLMode':
2214                                 $value = $CONF['URLMode'];
2215                                 $txt1  = _SETTINGS_URLMODE_NORMAL;
2216                                 $txt2  = _SETTINGS_URLMODE_PATHINFO;
2217                                 $this->parse_inputyesno('URLMode', $value, 10077, 'normal', 'pathinfo', $txt1, $txt2);
2218                                 break;
2219                         default:
2220                                 if ( array_key_exists($type, $CONF) && is_string($CONF[$type]) )
2221                                 {
2222                                         echo  Entity::hsc($CONF[$type]);
2223                                 }
2224                                 break;
2225                 }
2226                 return;
2227         }
2228
2229         /**
2230          * AdminActions::parse_configsettingsyesno()
2231          * Parse skinvar configsettingsyesno
2232          *
2233          * @param       string  $type           type of global setting
2234          * @param       integer $tabindex       tabindex attribute of input element
2235          * @return      void
2236          */
2237         public function parse_configsettingsyesno($type, $tabindex)
2238         {
2239                 global $CONF;
2240                 if ( array_key_exists($type, $CONF) )
2241                 {
2242                         $this->parse_inputyesno($type, $CONF[$type], $tabindex);
2243                 }
2244                 return;
2245         }
2246
2247         /**
2248          * AdminActions::parse_contents()
2249          * Parse skinvar contents
2250          *
2251          * @param       string  $which          part for item
2252          * @return      void
2253          */
2254         function parse_contents($which)
2255         {
2256                 global $manager;
2257
2258                 $item = false;
2259                 $contents = array();
2260
2261                 if ( requestVar('action') == 'itemedit' )
2262                 {
2263                         $itemid = intRequestVar('itemid');
2264                         $item =& $manager->getItem($itemid, 1, 1);
2265
2266                         $blog =& $manager->getBlog(getBlogIDFromItemID($itemid));
2267
2268                         if ( $item && $blog->convertBreaks() )
2269                         {
2270                                 $item['body'] = removeBreaks($item['body']);
2271                                 $item['more'] = removeBreaks($item['more']);
2272                         }
2273                         $contents = $item;
2274                 }
2275                 elseif ( requestVar('action') == 'createitem' )
2276                 {
2277                         $blogid = intRequestVar('blogid');
2278                         $blog =& $manager->getBlog($blogid);
2279                         $manager->notify(
2280                                 'PreAddItemForm',
2281                                 array(
2282                                         'contents' => &$contents,
2283                                         'blog'     => &$blog
2284                                 )
2285                         );
2286                 }
2287
2288                 if ( !array_key_exists($which, $contents) )
2289                 {
2290                         $contents[$which] = '';
2291                 }
2292                 echo Entity::hsc($contents[$which],ENT_QUOTES);
2293         }
2294
2295         /**
2296          * AdminActions::parse_currenttime()
2297          * Parse skinvar currenttime
2298          *
2299          * @param       string  $what
2300          */
2301         // for future items
2302         function parse_currenttime($what)
2303         {
2304                 global $manager;
2305                 if ( requestVar('action') == 'itemedit' )
2306                 {
2307                         $itemid = intRequestVar('itemid');
2308                         $blog =& $manager->getBlog(getBlogIDFromItemID($itemid));
2309                 }
2310                 elseif ( requestVar('action') == 'createitem' )
2311                 {
2312                         $blog =& $manager->getBlog(intRequestVar('blogid'));
2313                 }
2314                 $nu = getdate($blog->getCorrectTime());
2315                 echo $nu[$what];
2316         }
2317
2318         /**
2319          * AdminActions::parse_customhelplink()
2320          * Parse skinvar customhelplink
2321          *
2322          * @param       string  $topic          name of topic
2323          * @param       string  $tplName        name of template
2324          * @param       string  $url            string as URI
2325          * @param       string  $iconURL        string as URI for icon
2326          * @param       string  $alt            alternative text for image element
2327          * @param       string  $title          title for anchor element
2328          * @return      void
2329          */
2330         public function parse_customhelplink($topic, $tplName = '', $url = '', $iconURL = '', $alt = '', $title = '', $onclick = '')
2331         {
2332                 $this->customHelp($topic, $url, $iconURL);
2333                 return;
2334         }
2335
2336         /**
2337          * AdminActions::parse_date()
2338          * Parse skinvar date
2339          */
2340         public function parse_date($format = 'c')
2341         {
2342                 global $CONF, $manager;
2343                 echo i18n::formatted_datetime($format, time(), 'iso8601', $manager->getBlog((integer) $CONF['DefaultBlog']));
2344                 return;
2345         }
2346
2347         /**
2348          * AdminActions::parse_defaultadminskintypes()
2349          * Parse skinvar defaultadminskintypes
2350          *
2351          * @param       string  $tabindex               index number for tabindex attribute of input element
2352          * @param       string  $templateName   name of template
2353          * @return      void
2354          */
2355         public function parse_defaultadminskintypes($tabindex, $templateName = '')
2356         {
2357                 $templates = array();
2358
2359                 if ( $templateName )
2360                 {
2361                         $templates = Template::read($templateName);
2362                 }
2363
2364                 $types = $this->skin->getAvailableTypes();
2365                 ksort($types);
2366
2367                 /* NOTE: set templates for HEAD/BODY/FOOT */
2368                 if ( !array_key_exists('ADMINSKINTYPELIST_HEAD', $templates) || empty($templates['ADMINSKINTYPELIST_HEAD']) )
2369                 {
2370                         $template['head'] = "<ul>\n";
2371                 }
2372                 else
2373                 {
2374                         $template['head'] = $templates['ADMINSKINTYPELIST_HEAD'];
2375                 }
2376                 if ( !array_key_exists('ADMINSKINTYPELIST_BODY', $templates) || empty($templates['ADMINSKINTYPELIST_BODY']) )
2377                 {
2378                         $template['body'] = "<li>"
2379                                           . "<a tabindex=\"<%tabindex%>\" href=\"index.php?action=adminskinedittype&amp;skinid=<%skinid%>&amp;type=<%skintype%>\"><%name%></a> <%help%>"
2380                                           . "</li>\n";
2381                 }
2382                 else
2383                 {
2384                         $template['body'] = $templates['ADMINSKINTYPELIST_BODY'];
2385                 }
2386                 if ( !array_key_exists('ADMINSKINTYPELIST_FOOT', $templates) || empty($templates['ADMINSKINTYPELIST_FOOT']) )
2387                 {
2388                         $template['foot'] = "</ul>\n";
2389                 }
2390                 else
2391                 {
2392                         $template['foot'] = $templates['ADMINSKINTYPELIST_FOOT'];
2393                 }
2394
2395                 $handler = new AdminActions('template');
2396                 $parser = new PARSER($handler);
2397
2398                 /* NOTE: do output */
2399                 echo $template['head'];
2400                 foreach ( $types as $type => $fName )
2401                 {
2402                         $helplink = $this->customHelpHtml("skinpart{$type}{$templateName}");
2403                         $data = array(
2404                                 'tabindex'      => $tabindex,
2405                                 'skintype'      => $type,
2406                                 'name'          => $fName,
2407                                 'help'          => $helplink,
2408                                 'skinid'        => intrequestVar('skinid'),
2409                         );
2410                         $parser->parse(Template::fill($template['body'], $data));
2411                         $tabindex++;
2412                 }
2413                 echo $template['foot'];
2414
2415                 return;
2416         }
2417
2418         /**
2419          * AdminActions::parse_defblogselect()
2420          * Parse skinvar defblogselect
2421          *
2422          * @param       string  $templateName   name of template
2423          * @return      void
2424          */
2425         public function parse_defblogselect($templateName = '')
2426         {
2427                 global $CONF;
2428
2429                 $query = "SELECT bname as text, bnumber as value FROM %s;";
2430                 $query = sprintf($query, sql_table('blog'));
2431
2432                 $template['name'] = 'DefaultBlog';
2433                 $template['selected'] = $CONF['DefaultBlog'];
2434                 $template['tabindex'] = 10;
2435
2436                 Showlist($query, 'select', $template, $templateName);
2437
2438                 return;
2439         }
2440
2441         /**
2442          * AdminActions::parse_defcatselect()
2443          * Parse skinvar defcatselect
2444          *
2445          * @param       string  $templateName   name of template
2446          * @return      void
2447          */
2448         public function parse_defcatselect($templateName = '')
2449         {
2450                 global $manager;
2451
2452                 $blogid = intRequestVar('blogid');
2453                 $blog = $manager->getBlog($blogid);
2454
2455                 $query = "SELECT cname as text, catid as value FROM %s WHERE cblog=%d;";
2456                 $query = sprintf($query, sql_table('category'), (integer) $blog->getID());
2457
2458                 $template['name']        = 'defcat';
2459                 $template['selected'] = $blog->getDefaultCategory();
2460                 $template['tabindex'] = 110;
2461
2462                 Showlist($query, 'select', $template, $templateName);
2463
2464                 return;
2465         }
2466
2467         /**
2468          * AdminActions::parse_defskinselect()
2469          * Parse skinvar defskinselect
2470          *
2471          * @param       string  $type                   type of skin
2472          * @param       string  $templateName   name of template
2473          * @return      void
2474          */
2475         public function parse_defskinselect($type = 'blog', $templateName = '')
2476         {
2477                 global $CONF, $manager;
2478
2479                 $query  = "SELECT sdname as text, sdnumber as value FROM %s WHERE sdname NOT LIKE 'admin/%%';";
2480                 $query = sprintf($query, sql_table('skin_desc'));
2481
2482                 $blogid = intRequestVar('blogid');
2483
2484                 if ( !$blogid )
2485                 {
2486                         $template['selected'] = $CONF['BaseSkin'];
2487                 }
2488                 else
2489                 {
2490                         $blog = $manager->getBlog($blogid);
2491                         $template['selected'] = $blog->getDefaultSkin();
2492                 }
2493
2494                 if ( $type != 'blog' )
2495                 {
2496                         $nname = 'BaseSkin';
2497                 }
2498                 else
2499                 {
2500                         $nname = 'defskin';
2501                 }
2502
2503                 $template['name']        = $nname;
2504                 $template['tabindex'] = 50;
2505
2506                 Showlist($query, 'select', $template, $templateName);
2507
2508                 return;
2509         }
2510
2511         /**
2512          * AdminActions::parse_deletecomment()
2513          * Parse skinvar deletecomment
2514          *
2515          * @param       string  $type   type of infomation for comment
2516          * @return      void
2517          */
2518         public function parse_deletecomment($type = 'id')
2519         {
2520                 $commentid      = intRequestVar('commentid');
2521                 $comment        = COMMENT::getComment($commentid);
2522
2523                 switch ( $type )
2524                 {
2525                         case 'id':
2526                                 echo intRequestVar('commentid');
2527                                 break;
2528                         case 'author':
2529                                 if ( array_key_exists('member', $comment) && !empty($comment['member']) )
2530                                 {
2531                                         echo $comment['member'];
2532                                 }
2533                                 else
2534                                 {
2535                                         echo $comment['user'];
2536                                 }
2537                                 break;
2538                         case 'body':
2539                                 $body = strip_tags($comment['body']);
2540                                 echo Entity::hsc(shorten($body, 300, '...'));
2541                 }
2542                 return;
2543         }
2544
2545         /**
2546          * AdminActions::parse_deleteitembody()
2547          * Parse skinvar deleteitembody
2548          *
2549          * @param       void
2550          * @return      void
2551          */
2552         public function parse_deleteitembody()
2553         {
2554                 global $manager;
2555
2556                 $itemid =  intRequestVar('itemid');
2557                 $item =& $manager->getItem($itemid, 1, 1);
2558
2559                 $body =  strip_tags($item['body']);
2560
2561                 echo Entity::hsc(shorten($body, 300, '...'));
2562
2563                 return;
2564         }
2565
2566         /**
2567          * AdminActions::parse_deleteitemid()
2568          * Parse skinvar deleteitemid
2569          *
2570          * @param       void
2571          * @return      void
2572          */
2573         public function parse_deleteitemid()
2574         {
2575                 echo (integer) intRequestVar('itemid');
2576                 return;
2577         }
2578
2579         /**
2580          * AdminActions::parse_deleteitemtitle()
2581          * Parse skinvar deleteitemtitle
2582          *
2583          * @param       void
2584          * @return      void
2585          */
2586         public function parse_deleteitemtitle()
2587         {
2588                 global $manager;
2589
2590                 $itemid = intRequestVar('itemid');
2591                 $item =& $manager->getItem($itemid, 1, 1);
2592
2593                 echo Entity::hsc(strip_tags($item['title']));
2594
2595                 return;
2596         }
2597
2598         /**
2599          * AdminActions::parse_editadminskin()
2600          * Parse skinvar editadminskin
2601          *
2602          * @param       string  $type   type of skin setting
2603          * @return      void
2604          */
2605         public function parse_editadminskin($type = 'id')
2606         {
2607                 $skinid = intRequestVar('skinid');
2608                 $skin   = new Skin($skinid);
2609                 switch ( $type )
2610                 {
2611                         case 'id':
2612                                 echo intRequestVar('skinid');
2613                                 break;
2614                         case 'name':
2615                                 echo Entity::hsc($skin->getName());
2616                                 break;
2617                         case 'desc':
2618                                 echo Entity::hsc($skin->getDescription());
2619                                 break;
2620                         case 'type':
2621                                 echo Entity::hsc($skin->getContentType());
2622                                 break;
2623                         case 'prefix':
2624                                 echo Entity::hsc($skin->getIncludePrefix());
2625                                 break;
2626                         case 'mode':
2627                                 $this->parse_inputyesno('inc_mode', $skin->getIncludeMode(), 120, 'skindir', 'normal', _PARSER_INCMODE_SKINDIR, _PARSER_INCMODE_NORMAL);
2628                         default:
2629                                 break;
2630                 }
2631                 return;
2632         }
2633
2634         /**
2635          * AdminActions::parse_editadminskintype()
2636          * Parse skinvar editadminskintype
2637          *
2638          * @param       string  $type   name of skin type
2639          * @return      void
2640          */
2641         public function parse_editadminskintype($type = 'id')
2642         {
2643                 global $CONF, $manager, $member;
2644
2645                 $fNames = $this->skin->getAvailableTypes();
2646                 $sType  = strtolower(trim(requestVar('type')));
2647
2648                 switch ( $type )
2649                 {
2650                         case 'id':
2651                                 echo intRequestVar('skinid');
2652                                 break;
2653                         case 'name':
2654                                 echo Entity::hsc($this->skin->getName());
2655                                 break;
2656                         case 'desc':
2657                                 echo Entity::hsc($this->skin->getDescription());
2658                                 break;
2659                         case 'type':
2660                                 echo Entity::hsc($this->skin->getContentType());
2661                                 break;
2662                         case 'content':
2663                                 echo Entity::hsc($this->skin->getContentFromDB($sType));
2664                                 break;
2665                         case 'skintype':
2666                                 $skinType = !array_key_exists($sType, $fNames) ? ucfirst($sType) : $fNames[$sType];
2667                                 echo Entity::hsc($skinType);
2668                                 break;
2669                         case 'skintyperaw':
2670                                 echo Entity::hsc($sType);
2671                                 break;
2672                         case 'prefix':
2673                                 echo Entity::hsc($this->skin->getIncludePrefix());
2674                                 break;
2675                         case 'mode':
2676                                 $incMode = $skin->getIncludeMode() ? _PARSER_INCMODE_SKINDIR : _PARSER_INCMODE_NORMAL;
2677                                 echo Entity::hsc($incMode);
2678                                 break;
2679                         default:
2680                                 break;
2681                 }
2682                 return;
2683         }
2684
2685         /**
2686          * AdminActions::parse_editcomment()
2687          * Parse skinvar editcomment
2688          *
2689          * @param       string  $type   type of comment setting
2690          * @return      void
2691          */
2692         public function parse_editcomment($type = 'id')
2693         {
2694                 global $manager;
2695
2696                 $commentid      = intRequestVar('commentid');
2697                 $comment        = COMMENT::getComment($commentid);
2698
2699                 $manager->notify('PrepareCommentForEdit', array('comment' => &$comment));
2700
2701                 switch ( $type )
2702                 {
2703                         case 'id':
2704                                 echo intRequestVar('commentid');
2705                                 break;
2706                         case 'user':
2707                                 if ( !array_key_exists('member', $comment) || empty($comment['member']) )
2708                                 {
2709                                         echo $comment['user'] . " (" . _EDITC_NONMEMBER . ")";
2710                                 }
2711                                 else
2712                                 {
2713                                         echo $comment['member'] . " (" . _EDITC_MEMBER . ")";
2714                                 }
2715                                 break;
2716                         case 'date':
2717                                 echo date("Y-m-d @ H:i", $comment['timestamp']);
2718                                 break;
2719                         case 'body':
2720                                 $comment['body'] = str_replace('<br />', '', $comment['body']);
2721                                 $comment['body'] = preg_replace("#<a href=['\"]([^'\"]+)['\"]( rel=\"nofollow\")?>[^<]*</a>#", "\\1", $comment['body']);
2722                                 echo $comment['body'];
2723                         default:
2724                                 echo $comment[$type];
2725                                 break;
2726                 }
2727                 return;
2728         }
2729
2730         /**
2731          * AdminActions::parse_editdesturl()
2732          * Parse skinvar editdesturl
2733          */
2734         public function parse_editdesturl()
2735         {
2736                 if ( requestVar('desturl') )
2737                 {
2738                         echo Entity::hsc(requestVar('desturl'));
2739                 }
2740                 return;
2741         }
2742
2743         /**
2744          * AdminActions::parse_editmemberlist()
2745          * Parse skinvar editmemberlist
2746          *
2747          * @param       string  $templateName   name of template
2748          * @return      void
2749          */
2750         public function parse_editmemberlist($templateName = '')
2751         {
2752                 global $manager;
2753                 // show list of members with actions
2754                 $query =  'SELECT * FROM '.sql_table('member');
2755                 $template['content'] = 'memberlist';
2756                 $template['tabindex'] = 10;
2757
2758                 $batch = new Batch('member');
2759                 $batch->showlist($query, 'table', $template, _LISTS_NOMORE, $templateName);
2760                 return;
2761         }
2762
2763         /**
2764          * AdminActions::parse_editmember()
2765          * Parse skinvar editmember
2766          *
2767          * @param       string  $type                   type of information for member
2768          * @return      string  $tempateName    name of template to use
2769          * @return      void
2770          */
2771         public function parse_editmember($type = 'id', $templateName = '')
2772         {
2773                 global $CONF, $manager, $member;
2774
2775                 $memberid = intRequestVar('memberid');
2776                 $mem = MEMBER::createFromID($memberid);
2777
2778                 switch ( $type )
2779                 {
2780                         case 'id':
2781                                 echo intRequestVar('memberid');
2782                                 break;
2783                         case 'displayname':
2784                                 if ( $this->skintype == 'teamdelete' || $this->skintype == 'memberdelete' )
2785                                 {
2786                                         echo Entity::hsc($mem->getDisplayName());
2787                                 }
2788                                 else
2789                                 {
2790                                         $dispName = Entity::hsc($mem->getDisplayName());
2791                                         if ( $CONF['AllowLoginEdit'] || $member->isAdmin() )
2792                                         {
2793                                                 echo '<input name="name" tabindex="10" maxlength="32" size="32" value="' . $dispName . "\" />\n";
2794                                         }
2795                                         else
2796                                         {
2797                                                 echo $dispName;
2798                                         }
2799                                 }
2800                                 break;
2801                         case 'realname':
2802                                 echo Entity::hsc($mem->getRealName());
2803                                 break;
2804                         case 'email':
2805                                 echo Entity::hsc($mem->getEmail());
2806                                 break;
2807                         case 'url':
2808                                 echo Entity::hsc($mem->getURL());
2809                                 break;
2810                         case 'admin':
2811                                 $this->parse_inputyesno('admin', $mem->isAdmin(), 60, 1, 0, _YES, _NO, 0, $templateName);
2812                                 break;
2813                         case 'canlogin':
2814                                 $this->parse_inputyesno('canlogin', $mem->canLogin(), 70, 1, 0, _YES, _NO, $mem->isAdmin(), $templateName);
2815                                 break;
2816                         case 'notes':
2817                                 echo Entity::hsc($mem->getNotes());
2818                                 break;
2819                         case 'autosave':
2820                                 $this->parse_inputyesno('autosave', $mem->getAutosave(), 87, 1, 0, _YES, _NO, 0, $templateName);
2821                                 break;
2822                         default:
2823                                 break;
2824                 }
2825                 return;
2826         }
2827
2828         /**
2829          * AdminActions::parse_editpluginfo()
2830          * Parse skinvar editpluginfo
2831          *
2832          * @param       string  $type   type of plugin info
2833          * @return      void
2834          */
2835         public function parse_editpluginfo($type)
2836         {
2837                 $pid = intRequestVar('plugid');
2838                 switch ( $type )
2839                 {
2840                         case 'id':
2841                                 echo $pid;
2842                                 break;
2843                         case 'name':
2844                                 echo Entity::hsc(getPluginNameFromPid($pid));
2845                                 break;
2846                 }
2847                 return;
2848         }
2849
2850         /**
2851          * AdminActions::parse_editplugoptionslist()
2852          * Parse skinvar editplugoptionslist
2853          *
2854          * @param       string  $templateName   name of template
2855          * @return      void
2856          */
2857         public function parse_editplugoptionslist($templateName = '')
2858         {
2859                 global $manager;
2860
2861                 $pid = intRequestVar('plugid');
2862                 $aOptions = array();
2863                 $aOIDs  = array();
2864
2865                 $query  = "SELECT * FROM %s WHERE ocontext='global' AND opid=%d ORDER BY oid ASC;";
2866                 $query = sprintf($query, sql_table('plugin_option_desc'), (integer) $pid);
2867                 $resource = sql_query($query);
2868
2869                 while ( $o = sql_fetch_object($resource) )
2870                 {
2871                         array_push($aOIDs, $o->oid);
2872                         $aOptions[$o->oid] = array(
2873                                 'oid'                   => $o->oid,
2874                                 'value'                 => $o->odef,
2875                                 'name'                  => $o->oname,
2876                                 'description'   => $o->odesc,
2877                                 'type'                  => $o->otype,
2878                                 'typeinfo'              => $o->oextra,
2879                                 'contextid'             => 0
2880                         );
2881                 }
2882
2883                 // fill out actual values
2884                 if ( count($aOIDs) > 0 )
2885                 {
2886                         $query = 'SELECT oid, ovalue FROM %s WHERE oid in (%s)';
2887                         $query = sprintf($query, sql_table('plugin_option'), implode(',', $aOIDs));
2888
2889                         $result = sql_query($query);
2890
2891                         while ( $o = sql_fetch_object($result) )
2892                         {
2893                                 $aOptions[$o->oid]['value'] = $o->ovalue;
2894                         }
2895                 }
2896
2897                 // call plugins
2898                 $data = array(
2899                         'context'       =>  'global',
2900                         'plugid'        =>  $pid,
2901                         'options'       => &$aOptions
2902                 );
2903                 $manager->notify('PrePluginOptionsEdit', $data);
2904
2905                 $template['content'] = 'plugoptionlist';
2906
2907                 $amount = Showlist($aOptions, 'table', $template, $templateName);
2908
2909                 if ( $amount == 0 )
2910                 {
2911                         echo '<p>' . _ERROR_NOPLUGOPTIONS . "</p>\n";
2912                 }
2913                 return;
2914         }
2915
2916         /**
2917          * AdminActions::parse_editskin()
2918          * Parse skinvar editskin
2919          *
2920          * @param       string  $type   type of skin
2921          * @return      void
2922          */
2923         public function parse_editskin($type = 'id')
2924         {
2925                 $skinid = intRequestVar('skinid');
2926                 $skin   = new SKIN($skinid);
2927                 switch ( $type )
2928                 {
2929                         case 'id':
2930                                 echo intRequestVar('skinid');
2931                                 break;
2932                         case 'name':
2933                                 echo Entity::hsc($skin->getName());
2934                                 break;
2935                         case 'desc':
2936                                 echo Entity::hsc($skin->getDescription());
2937                                 break;
2938                         case 'type':
2939                                 echo Entity::hsc($skin->getContentType());
2940                                 break;
2941                         case 'prefix':
2942                                 echo Entity::hsc($skin->getIncludePrefix());
2943                                 break;
2944                         case 'mode':
2945                                 $this->parse_inputyesno('inc_mode', $skin->getIncludeMode(), 120, 'skindir', 'normal', _PARSER_INCMODE_SKINDIR, _PARSER_INCMODE_NORMAL);
2946                         default:
2947                                 break;
2948                 }
2949                 return;
2950         }
2951
2952         /**
2953          * AdminActions::parse_editskintype()
2954          * Parse skinvar editskintype
2955          *
2956          * @param       string  $type   name of type for skin type
2957          * @return      void
2958          */
2959         public function parse_editskintype($type = 'id')
2960         {
2961                 global $CONF, $manager, $member;
2962                 $skinid = intRequestVar('skinid');
2963                 $skin   = new SKIN($skinid);
2964                 $fNames = $skin->getAvailableTypes();
2965                 $sType  = strtolower(trim(requestVar('type')));
2966
2967                 switch ( $type )
2968                 {
2969                         case 'id':
2970                                 echo intRequestVar('skinid');
2971                                 break;
2972                         case 'name':
2973                                 echo Entity::hsc($skin->getName());
2974                                 break;
2975                         case 'desc':
2976                                 echo Entity::hsc($skin->getDescription());
2977                                 break;
2978                         case 'type':
2979                                 echo Entity::hsc($skin->getContentType());
2980                                 break;
2981                         case 'content':
2982                                 echo Entity::hsc($skin->getContentFromDB($sType));
2983                                 break;
2984                         case 'skintype':
2985                                 $skinType = !array_key_exists($sType, $fNames) ? ucfirst($sType) : $fNames[$sType];
2986                                 echo Entity::hsc($skinType);
2987                                 break;
2988                         case 'skintyperaw':
2989                                 echo Entity::hsc($sType);
2990                                 break;
2991                         case 'prefix':
2992                                 echo Entity::hsc($skin->getIncludePrefix());
2993                                 break;
2994                         case 'mode':
2995                                 $incMode = $skin->getIncludeMode() ? _PARSER_INCMODE_SKINDIR : _PARSER_INCMODE_NORMAL;
2996                                 echo Entity::hsc($incMode);
2997                                 break;
2998                         default:
2999                                 break;
3000                 }
3001                 return;
3002         }
3003
3004         /**
3005          * AdminActions::parse_adminurl()
3006          * Parse skinvar adminurl
3007          * (shortcut for admin url)
3008          *
3009          * @param       void
3010          * @return      void
3011          */
3012         public function parse_adminurl()
3013         {
3014                 $this->parse_sitevar('adminurl');
3015                 return;
3016         }
3017
3018         /**
3019          * AdminActions::parse_edittemplateinfo()
3020          * Parse skinvar edittemplateinfo
3021          *
3022          * @param       string  $type                   name of type for skin
3023          * @param       string  $description    description for skin
3024          * @param       string  $name                   name of skin
3025          * @param       string  $help
3026          * @param       string  $tabindex               index value for tabindex attribute of input element
3027          * @param       string  $big
3028          * @param       string  $tplt                   name of template
3029          * @return      boolean
3030          */
3031         public function parse_edittemplateinfo($type, $desc = '', $name = '', $help = '', $tabindex = 0, $big = 0, $tplt = '')
3032         {
3033                 global $manager;
3034
3035                 $t_id           =  intRequestVar('templateid');
3036                 $t_name         =  Template::getNameFromId($t_id);
3037                 $t_desc         =  Template::getDesc($t_id);
3038                 $template       = &Template::read($t_name);
3039
3040                 switch ( $type )
3041                 {
3042                         case 'id':
3043                                 echo intval($t_id);
3044                                 break;
3045                         case 'name':
3046                                 echo Entity::hsc($t_name);
3047                                 break;
3048                         case 'desc':
3049                                 echo Entity::hsc($t_desc);
3050                                 break;
3051                         case 'extratemplate':
3052                                 $tabidx = 600;
3053                                 $pluginfields = array();
3054                                 $manager->notify('TemplateExtraFields', array('fields' => &$pluginfields));
3055
3056                                 $tmplt = array();
3057                                 if ( $desc )
3058                                 {
3059                                         $tmplt = Template::read($desc);
3060                                 }
3061                                 if ( !array_key_exists('TEMPLATE_EDIT_EXPLUGNAME', $tmplt) || empty($tmplt['TEMPLATE_EDIT_EXPLUGNAME']) )
3062                                 {
3063                                         $base = "</tr>\n"
3064                                               . "<tr>\n"
3065                                               . '<th colspan="2"><%explugtplname%>' . "</th>\n";
3066                                 }
3067                                 else
3068                                 {
3069                                         $base = $tmplt['TEMPLATE_EDIT_EXPLUGNAME'];
3070                                 }
3071
3072                                 foreach ( $pluginfields as $pfkey => $pfvalue )
3073                                 {
3074                                         $data = array('explugtplname' => Entity::hsc($pfkey));
3075
3076                                         echo Template::fill($base, $data);
3077
3078                                         foreach ( $pfvalue as $pffield => $pfdesc )
3079                                         {
3080                                                 $this->templateEditRow($template, $pfdesc, $pffield, '', ++$tabidx, 0, $name);
3081                                         }
3082                                 }
3083                                 break;
3084                         default:
3085                                 $desc = defined($desc) ? constant($desc) : $desc;
3086                                 $name = defined($name) ? constant($name) : $name;
3087                                 $this->templateEditRow($template, $desc, $name, $help, $tabindex, $big, $tplt);
3088                                 break;
3089                 }
3090
3091                 return;
3092         }
3093
3094         /**
3095          * AdminActions::parse_editadmintemplateinfo()
3096          * Parse skinvar editadmintemplateinfo
3097          *
3098          * @param       string  $type                   type of skin template
3099          * @param       string  $description    description of template
3100          * @param       string  $name                   name of stemplate
3101          * @param       string  $tabindex               index number for tabindex attribute of input element
3102          * @param       string  $big
3103          * @param       string  $tplt
3104          */
3105         public function parse_editadmintemplateinfo($type, $desc = '', $name = '', $help = '', $tabindex = 0, $big = 0, $tplt = '')
3106         {
3107                 global $manager;
3108
3109                 $t_id           =  intRequestVar('templateid');
3110                 $t_name         =  Template::getNameFromId($t_id);
3111                 $t_desc         =  Template::getDesc($t_id);
3112                 $template       = &Template::read($t_name);
3113
3114                 switch ( $type )
3115                 {
3116                         case 'id':
3117                                 echo intval($t_id);
3118                                 break;
3119                         case 'name':
3120                                 echo Entity::hsc($t_name);
3121                                 break;
3122                         case 'desc':
3123                                 echo Entity::hsc($t_desc);
3124                                 break;
3125                         case 'extratemplate':
3126                                 $tabidx = 600;
3127                                 $pluginfields = array();
3128                                 $manager->notify('AdminTemplateExtraFields', array('fields' => &$pluginfields));
3129
3130                                 $tmplt = array();
3131                                 if ( $desc )
3132                                 {
3133                                         $tmplt = Template::read($desc);
3134                                 }
3135                                 if ( !array_key_exists('TEMPLATE_EDIT_EXPLUGNAME', $tmplt) || empty($tmplt['TEMPLATE_EDIT_EXPLUGNAME']) )
3136                                 {
3137                                         $base = "</tr>\n"
3138                                               . "<tr>\n"
3139                                               . '<th colspan="2"><%explugtplname%>' . "</th>\n";
3140                                 }
3141                                 else
3142                                 {
3143                                         $base = $tmplt['TEMPLATE_EDIT_EXPLUGNAME'];
3144                                 }
3145
3146                                 foreach ( $pluginfields as $pfkey => $pfvalue )
3147                                 {
3148                                         $data = array('explugtplname' => Entity::hsc($pfkey));
3149
3150                                         echo Template::fill($base, $data);
3151
3152                                         foreach ( $pfvalue as $pffield => $pfdesc )
3153                                         {
3154                                                 $this->templateEditRow($template, $pfdesc, $pffield, '', ++$tabidx, 0, $name);
3155                                         }
3156                                 }
3157                                 break;
3158                         default:
3159                                 $desc = defined($desc) ? constant($desc) : $desc;
3160                                 $name = defined($name) ? constant($name) : $name;
3161                                 $this->templateEditRow($template, $desc, $name, $help, $tabindex, $big, $tplt);
3162                                 break;
3163                 }
3164                 return;
3165         }
3166
3167         /**
3168          * AdminActions::parse_eventformextra()
3169          * Parse skinvar eventformextra
3170          *
3171          * @param       string  $type   name of type for event form extra
3172          * @return      void
3173          */
3174         public function parse_eventformextra($type = 'activation')
3175         {
3176                 global $manager;
3177
3178                 $data = array();
3179
3180                 switch ( $type )
3181                 {
3182                         case 'activation':
3183                                 $key = requestVar('ackey');
3184                                 if ( !$key )
3185                                 {
3186                                         Admin::error(_ERROR_ACTIVATE);
3187                                 }
3188                                 $info = MEMBER::getActivationInfo($key);
3189                                 if ( !$info )
3190                                 {
3191                                         Admin::error(_ERROR_ACTIVATE);
3192                                 }
3193                                 $mem  = MEMBER::createFromId($info->vmember);
3194                                 if ( !$mem )
3195                                 {
3196                                         Admin::error(_ERROR_ACTIVATE);
3197                                 }
3198                                 $data = array(
3199                                         'type'          => 'activation',
3200                                         'member'        => $mem
3201                                 );
3202                                 break;
3203                         case 'membermailform-notloggedin':
3204                                 $data = array('type' => 'membermailform-notloggedin',);
3205                                 break;
3206                 }
3207                 $manager->notify('FormExtra', $data);
3208                 return;
3209         }
3210
3211         /**
3212          * AdminActions::parse_extrahead()
3213          * Parse skinvar extrahead
3214          */
3215         public function parse_extrahead()
3216         {
3217                 global $manager;
3218
3219                 $extrahead = Admin::getAdminextrahead();
3220
3221                 $data = array(
3222                         'extrahead'     => &$extrahead,
3223                         'action'        => Admin::getAdminAction()
3224                 );
3225
3226                 $manager->notify('AdminPrePageHead', $data);
3227                 echo $extrahead;
3228                 return;
3229         }
3230
3231         /**
3232          * AdminActions::parse_member()
3233          * Parse skinvar member
3234          * (includes a member info thingie)
3235          *
3236          * @param       string  $what   which memberdata is needed
3237          * @return      void
3238          */
3239         public function parse_member($what)
3240         {
3241                 global $memberinfo, $member, $CONF;
3242
3243                 // 1. only allow the member-details-page specific variables on member pages
3244                 if ( $this->skintype == 'member' )
3245                 {
3246                         switch( $what )
3247                         {
3248                                 case 'name':
3249                                         echo Entity::hsc($memberinfo->getDisplayName());
3250                                         break;
3251                                 case 'realname':
3252                                         echo Entity::hsc($memberinfo->getRealName());
3253                                         break;
3254                                 case 'notes':
3255                                         echo Entity::hsc($memberinfo->getNotes());
3256                                         break;
3257                                 case 'url':
3258                                         echo Entity::hsc($memberinfo->getURL());
3259                                         break;
3260                                 case 'email':
3261                                         echo Entity::hsc($memberinfo->getEmail());
3262                                         break;
3263                                 case 'id':
3264                                         echo Entity::hsc($memberinfo->getID());
3265                                         break;
3266                         }
3267                 }
3268
3269                 // 2. the next bunch of options is available everywhere, as long as the user is logged in
3270                 if ( $member->isLoggedIn() )
3271                 {
3272                         switch( $what )
3273                         {
3274                                 case 'yourname':
3275                                         echo $member->getDisplayName();
3276                                         break;
3277                                 case 'yourrealname':
3278                                         echo $member->getRealName();
3279                                         break;
3280                                 case 'yournotes':
3281                                         echo $member->getNotes();
3282                                         break;
3283                                 case 'yoururl':
3284                                         echo $member->getURL();
3285                                         break;
3286                                 case 'youremail':
3287                                         echo $member->getEmail();
3288                                         break;
3289                                 case 'yourid':
3290                                         echo $member->getID();
3291                                         break;
3292                                 case 'yourprofileurl':
3293                                         if ( $CONF['URLMode'] == 'pathinfo' )
3294                                         {
3295                                                 echo Link::create_member_link($member->getID());
3296                                         }
3297                                         else
3298                                         {
3299                                                 echo $CONF['IndexURL'] . Link::create_member_link($member->getID());
3300                                         }
3301                                         break;
3302                         }
3303                 }
3304                 return;
3305         }
3306
3307         /**
3308          * AdminActions::parse_version()
3309          * Parse skinvar version
3310          * (include nucleus versionnumber)
3311          *
3312          * @param       void
3313          * @return      void
3314          */
3315         public function parse_version()
3316         {
3317                 global $nucleus;
3318                 echo 'Nucleus CMS ' . $nucleus['version'];
3319                 return;
3320         }
3321
3322         /**
3323          * AdminActions::parse_sitevar()
3324          * Parse skinvar sitevar
3325          * (include a sitevar)
3326          *
3327          * @param       string  $which
3328          * @return      void
3329          */
3330         public function parse_sitevar($which)
3331         {
3332                 global $CONF;
3333                 switch ( $which )
3334                 {
3335                         case 'url':
3336                                 echo $CONF['IndexURL'];
3337                                 break;
3338                         case 'name':
3339                                 echo $CONF['SiteName'];
3340                                 break;
3341                         case 'admin':
3342                                 echo $CONF['AdminEmail'];
3343                                 break;
3344                         case 'adminurl':
3345                                 echo $CONF['AdminURL'];
3346                 }
3347                 return;
3348         }
3349
3350         /**
3351          * AdminActions::parse_charset()
3352          * Parse skinvar charset
3353          *
3354          * @param       void
3355          * @return      void
3356          */
3357         public function parse_charset()
3358         {
3359                 echo i18n::get_current_charset();
3360                 return;
3361         }
3362
3363         /**
3364          * AdminActions::parse_getblogsetting()
3365          * Parse skinvar getblogsetting
3366          */
3367         public function parse_getblogsetting($which)
3368         {
3369                 global $blog;
3370
3371                 if ( $blog )
3372                 {
3373                         $b =& $blog;
3374                 }
3375                 elseif ( $bid = intRequestVar('blogid') )
3376                 {
3377                         global $manager;
3378                         $b = $manager->getBlog($bid);
3379                 }
3380                 else
3381                 {
3382                         return;
3383                 }
3384
3385                 switch ( $which )
3386                 {
3387                         case 'id':
3388                                 return Entity::hsc($b->getID());
3389                                 break;
3390                         case 'url':
3391                                 return Entity::hsc($b->getURL());
3392                                 break;
3393                         case 'name':
3394                                 return Entity::hsc($b->getName());
3395                                 break;
3396                         case 'desc':
3397                                 return Entity::hsc($b->getDescription());
3398                                 break;
3399                         case 'short':
3400                                 return Entity::hsc($b->getShortName());
3401                                 break;
3402                         case 'notifyaddress':
3403                                 return Entity::hsc($b->getNotifyAddress());
3404                                 break;
3405                         case 'maxcomments':
3406                                 return Entity::hsc($b->getMaxComments());
3407                                 break;
3408                         case 'updatefile':
3409                                 return Entity::hsc($b->getUpdateFile());
3410                                 break;
3411                         case 'timeoffset':
3412                                 return Entity::hsc($b->getTimeOffset());
3413                                 break;
3414                 }
3415                 return;
3416         }
3417
3418         /**
3419          * AdminActions::parse_geteditpluginfo()
3420          * Parse skinvar geteditpluginfo
3421          *
3422          * @param       string  $type   name of setting for edit plugin info
3423          * @return      void
3424          */
3425         public function parse_geteditpluginfo($type)
3426         {
3427                 $pid = intRequestVar('plugid');
3428                 switch ( $type )
3429                 {
3430                         case 'id':
3431                                 return $pid;
3432                                 break;
3433                         case 'name':
3434                                 return Entity::hsc(getPluginNameFromPid($pid));
3435                                 break;
3436                 }
3437                 return;
3438         }
3439
3440         /**
3441          * AdminActions::parse_getmember()
3442          * Parse skinvar getmember
3443          * (includes a member info thingie)
3444          *
3445          * @param       string  $what   name of setting for member
3446          * @return      void
3447          */
3448         public function parse_getmember($what)
3449         {
3450                 global $memberinfo, $member;
3451                 // 1. only allow the member-details-page specific variables on member pages
3452                 if ( $this->skintype == 'member' )
3453                 {
3454                         switch ( $what )
3455                         {
3456                                 case 'name':
3457                                         return Entity::hsc($memberinfo->getDisplayName());
3458                                         break;
3459                                 case 'realname':
3460                                         return Entity::hsc($memberinfo->getRealName());
3461                                         break;
3462                                 case 'notes':
3463                                         return Entity::hsc($memberinfo->getNotes());
3464                                         break;
3465                                 case 'url':
3466                                         return Entity::hsc($memberinfo->getURL());
3467                                         break;
3468                                 case 'email':
3469                                         return Entity::hsc($memberinfo->getEmail());
3470                                         break;
3471                                 case 'id':
3472                                         return Entity::hsc($memberinfo->getID());
3473                                         break;
3474                         }
3475                 }
3476                 // 2. the next bunch of options is available everywhere, as long as the user is logged in
3477                 if ( $member->isLoggedIn() )
3478                 {
3479                         switch ( $what )
3480                         {
3481                                 case 'yourname':
3482                                         return $member->getDisplayName();
3483                                         break;
3484                                 case 'yourrealname':
3485                                         return $member->getRealName();
3486                                         break;
3487                                 case 'yournotes':
3488                                         return $member->getNotes();
3489                                         break;
3490                                 case 'yoururl':
3491                                         return $member->getURL();
3492                                         break;
3493                                 case 'youremail':
3494                                         return $member->getEmail();
3495                                         break;
3496                                 case 'yourid':
3497                                         return $member->getID();
3498                                         break;
3499                         }
3500                 }
3501                 return;
3502         }
3503
3504         /**
3505          * AdminActions::parse_headmessage()
3506          * Parse skinvar headmessage
3507          *
3508          * @param       void
3509          * @return      void
3510          */
3511         public function parse_headmessage()
3512         {
3513                 if ( !empty(Admin::$headMess) )
3514                 {
3515                         echo '<p>' . _MESSAGE . ': ' . Entity::hsc(Admin::$headMess) . "</p>\n";
3516                 }
3517                 return;
3518         }
3519
3520         /**
3521          * AdminActions::parse_helplink()
3522          * Parse skinvar helplink
3523          *
3524          * @param       string  $topic  name of topic for help
3525          * @return      void
3526          */
3527         public function parse_helplink($topic = '')
3528         {
3529                 if ( !empty($topic) )
3530                 {
3531                         help($topic);
3532                 }
3533                 return;
3534         }
3535
3536         /**
3537          * AdminActions::parse_helpplugname()
3538          * Parse skinvar helpplugname
3539          *
3540          * @param       void
3541          * @return      void
3542          */
3543         public function parse_helpplugname()
3544         {
3545                 $plugid = intGetVar('plugid');
3546                 Entity::hsc(getPluginNameFromPid($plugid));
3547                 return;
3548         }
3549
3550         /**
3551          * AdminActions::parse_ilistaddnew()
3552          * Parse skinvar ilistaddnew
3553          *
3554          * @param       void
3555          * @return      void
3556          */
3557         public function parse_ilistaddnew()
3558         {
3559                 $blogid = intRequestVar('blogid');
3560                 if ( intPostVar('start') == 0 )
3561                 {
3562                         echo '<p><a href="index.php?action=createitem&amp;blogid=' . $blogid . '">' . _ITEMLIST_ADDNEW . "</a></p>\n";
3563                 }
3564                 return;
3565         }
3566
3567         /**
3568          * AdminActions::parse_importskininfo()
3569          * Parse skinvar importskininfo
3570          *
3571          * @param       string  $type   name of information for imported skin
3572          * @return      void
3573          */
3574         public function parse_importskininfo($type)
3575         {
3576                 switch ( $type )
3577                 {
3578                         case 'info':
3579                                 echo Entity::hsc(requestVar('skininfo'));
3580                                 break;
3581                         case 'snames':
3582                                 $dataArr = requestArray('skinnames');
3583                                 echo implode(' <em>' . _AND . '</em> ', $dataArr);
3584                                 break;
3585                         case 'tnames':
3586                                 $dataArr = requestArray('tpltnames');
3587                                 echo implode(' <em>' . _AND . '</em> ', $dataArr);
3588                                 break;
3589                         case 'sclashes':
3590                                 $dataArr = requestArray('skinclashes');
3591                                 echo implode(' <em>' . _AND . '</em> ', $dataArr);
3592                                 break;
3593                         case 'tclashes':
3594                                 $dataArr = requestArray('tpltclashes');
3595                                 echo implode(' <em>' . _AND . '</em> ', $dataArr);
3596                                 break;
3597                         case 'skinfile':
3598                                 echo Entity::hsc(requestVar('skinfile'));
3599                                 break;
3600                         case 'mode':
3601                                 echo Entity::hsc(requestVar('mode'));
3602                                 break;
3603                 }
3604                 return;
3605         }
3606
3607         /**
3608          * AdminActions::parse_inputyesno()
3609          * Parse skinvar inputyesno
3610          *
3611          * some init stuff for all forms
3612          *
3613          * @param       void
3614          * @return      void
3615          */
3616         function parse_init()
3617         {
3618                 global $manager;
3619
3620                 $item = false;
3621                 if ( requestVar('action') == 'itemedit' )
3622                 {
3623                         $itemid = intRequestVar('itemid');
3624                         $item =& $manager->getItem($itemid, 1, 1);
3625
3626                         $blog =& $manager->getBlog(getBlogIDFromItemID($itemid));
3627                         if ( $item && $blog->convertBreaks() )
3628                         {
3629                                 $item['body'] = removeBreaks($item['body']);
3630                                 $item['more'] = removeBreaks($item['more']);
3631                         }
3632                         $contents = $item;
3633                         $authorid = $contents['authorid'];
3634                 }
3635                 elseif ( requestVar('action') == 'createitem' )
3636                 {
3637                         $blogid = intRequestVar('blogid');
3638                         $blog =& $manager->getBlog($blogid);
3639                         $authorid = '';
3640                 }
3641                 $blog->insertJavaScriptInfo($authorid);
3642                 return;
3643         }
3644
3645         /**
3646          * AdminActions::parse_inputyesno()
3647          * Parse skinvar inputyesno
3648          *
3649          * @param       string  $name
3650          * @param       string  $checkedval
3651          * @param       string  $tabindex
3652          * @param       string  $value1
3653          * @param       string  $value2
3654          * @param       string  $yesval
3655          * @param       string  $noval
3656          * @param       string  $isAdmin
3657          * @param       string  $templateName
3658          * @return      void
3659          */
3660         public function parse_inputyesno($name, $checkedval, $tabindex = 0, $value1 = 1, $value2 = 0, $yesval = _YES, $noval = _NO, $isAdmin = 0, $templateName = '')
3661         {
3662                 self::input_yesno($name, $checkedval, $tabindex, $value1, $value2, $yesval, $noval, $isAdmin, $templateName );
3663                 return;
3664         }
3665
3666         /**
3667          * AdminActions::parse_insertpluginfo()
3668          * Parse templatevar insertpluginfo
3669          */
3670         public function parse_insertpluginfo($type)
3671         {
3672                 $option = Admin::$aOptions;
3673                 switch ( $type )
3674                 {
3675                         case 'id':
3676                                 return $option['pid'];
3677                                 break;
3678                         case 'name':
3679                                 return Entity::hsc($option['pfile']);
3680                                 break;
3681                 }
3682                 return;
3683         }
3684
3685         /**
3686          * AdminActions::parse_insertpluginoptions()
3687          * Parse skinvar insertpluginoptions
3688          *
3689          * @param       string  $templateName   name of template
3690          * @return      void
3691          */
3692         public function parse_insertpluginoptions($templateName = '')
3693         {
3694                 $options        = Admin::getAdminaOption();
3695                 $template       = array();
3696                 $templats       = array();
3697
3698                 if ( $templateName )
3699                 {
3700                         $templates = Template::read($templateName);
3701                 }
3702                 if ( !array_key_exists('INSERT_PLUGOPTION_TITLE', $templates) || empty($templates['INSERT_PLUGOPTION_TITLE']) )
3703                 {
3704                         $template['title'] = "<tr>"
3705                                            . "<th colspan=\"2\"><%sprinttext(_PLUGIN_OPTIONS_TITLE, <|%insertpluginfo(name)%|>)%></th>"
3706                                            . "</tr>\n";
3707                 }
3708                 else
3709                 {
3710                         $template['title'] = $templates['INSERT_PLUGOPTION_TITLE'];
3711                 }
3712                 if ( !array_key_exists('INSERT_PLUGOPTION_BODY', $templates) || empty($templates['INSERT_PLUGOPTION_BODY']) )
3713                 {
3714                         $template['body'] = "<tr>"
3715                                           . "<%listplugplugoptionrow%>"
3716                                           . "</tr>\n";
3717                 }
3718                 else
3719                 {
3720                         $template['body'] = $templates['INSERT_PLUGOPTION_BODY'];
3721                 }
3722
3723                 $prevPid = -1;
3724
3725                 include_libs('ACTIONS.php');
3726                 $handler = new Actions($this->skintype);
3727                 $parser = new PARSER($handler);
3728
3729                 foreach ( $options as $option )
3730                 {
3731
3732                         // new plugin?
3733                         if ( $prevPid != $option['pid'] )
3734                         {
3735                                 $prevPid  = $option['pid'];
3736                                 $parser->parse($template['title']);
3737                         }
3738
3739                         $meta = NucleusPlugin::getOptionMeta($option['typeinfo']);
3740
3741                         if ( @$meta['access'] != 'hidden' )
3742                         {
3743                                 $parsed = $parser->parse($template['body']);
3744                         }
3745                 }
3746                 return;
3747         }
3748
3749         /**
3750          * AdminActions::parse_insplugoptcontent()
3751          * Parse skinvar insplugoptcontent
3752          *
3753          * @param       void
3754          * @return      void
3755          */
3756         public function parse_insplugoptcontent()
3757         {
3758                 $option = Admin::$aOption;
3759
3760                 $meta = NucleusPlugin::getOptionMeta($option['typeinfo']);
3761                 if ( array_key_exists('access', $meta) && $meta['access'] != 'hidden' )
3762                 {
3763                         echo '<tr>';
3764                         listplug_plugOptionRow($option);
3765                         echo '</tr>';
3766                 }
3767                 return;
3768         }
3769
3770         /**
3771          * AdminActions::parse_iprangeinput()
3772          * Parse skinvar iprangeinput
3773          *
3774          * @param       void
3775          * @return      void
3776          */
3777         public function parse_iprangeinput()
3778         {
3779                 if ( requestVar('ip') )
3780                 {
3781                         $iprangeVal = Entity::hsc(requestVar('ip'));
3782                         echo "<input name=\"iprange\" type=\"radio\" value=\"{$iprangeVal}\" checked=\"checked\" id=\"ip_fixed\" />\n";
3783                         echo "<label for=\"ip_fixed\">{$iprangeVal}</label><br />\n";
3784                         echo '<input name="iprange" type="radio" value="custom" id="ip_custom" />' . "\n";
3785                         echo '<label for="ip_custom">' . _BAN_IP_CUSTOM . '</label>' . "\n";
3786                         echo "<input name=\"customiprange\" value=\"{$iprangeVal}\" maxlength=\"15\" size=\"15\" />\n";
3787                 }
3788                 else
3789                 {
3790                         echo '<input name="iprange" value="custom" type="hidden" />' . "\n";
3791                         echo '<input name="customiprange" value="" maxlength="15" size="15" />' . "\n";
3792                 }
3793                 return;
3794         }
3795
3796         /**
3797          * AdminActions::parse_itemnavlist()
3798          * Parse skinvar itemnavlist
3799          *
3800          * @param       void
3801          * @return      void
3802          */
3803         public function parse_itemnavlist()
3804         {
3805                 global $CONF, $manager, $member;
3806                 if ( $this->skintype == 'itemlist' )
3807                 {
3808                         $blogid =  intRequestVar('blogid');
3809                         $blog   =& $manager->getBlog($blogid);
3810                 }
3811                 if ( postVar('start') )
3812                 {
3813                         $start = intPostVar('start');
3814                 }
3815                 else
3816                 {
3817                         $start = 0;
3818                 }
3819
3820                 // amount of items to show
3821                 if ( postVar('amount') )
3822                 {
3823                         $amount = intPostVar('amount');
3824                 }
3825                 else
3826                 {
3827                         $amount = intval($CONF['DefaultListSize']);
3828                         if ( $amount < 1 )
3829                         {
3830                                 $amount = 10;
3831                         }
3832                 }
3833                 $query  = "SELECT bshortname, cname, mname, ititle, ibody, inumber, idraft, itime"
3834                         . " FROM %s, %s, %s, %s"
3835                         . " WHERE iblog=bnumber AND iauthor=mnumber AND icat=catid";
3836
3837                 $query = sprintf($query, sql_table('item'), sql_table('blog'), sql_table('member'), sql_table('category'));
3838
3839                 if ( $this->skintype == 'itemlist' )
3840                 {
3841                         $query .= ' AND iblog   = ' . $blogid;
3842                         $template['now'] = $blog->getCorrectTime(time());
3843
3844                         // non-blog-admins can only edit/delete their own items
3845                         if ( !$member->blogAdminRights($blogid) )
3846                         {
3847                                 $query .= ' AND iauthor = ' . $member->getID();
3848                         }
3849                 }
3850                 elseif ( $this->skintype == 'browseownitems' )
3851                 {
3852                         $query .= ' AND iauthor   = ' . $member->getID();
3853                         $blogid = 0;
3854                         $template['now'] = time();
3855                 }
3856
3857                 // search through items
3858                 $search = postVar('search');
3859
3860                 if ( !empty($search) )
3861                 {
3862                         $query .= ' AND ((ititle LIKE "%' . sql_real_escape_string($search) . '%") '
3863                                 . '  OR  (ibody LIKE "%' . sql_real_escape_string($search) . '%") '
3864                                 . '  OR  (imore LIKE "%' . sql_real_escape_string($search) . '%"))';
3865                 }
3866                 $query .= ' ORDER BY itime DESC'
3867                         . " LIMIT {$start},{$amount}";
3868
3869                 $template['content'] = 'itemlist';
3870
3871                 $navList = new Navlist($this->skintype, $start, $amount, 0, 1000, $blogid, $search, 0);
3872                 $navList->showBatchList('item', $query, 'table', $template);
3873                 return;
3874         }
3875
3876         /**
3877          * AdminActions::parse_itemoptions()
3878          * Parse skinvar itemoptions
3879          * Adds the itemOptions of a plugin to a page
3880          * @author TeRanEX
3881          */
3882         function parse_itemoptions()
3883         {
3884                 $this->parse_pluginoptions('item');
3885                 return;
3886         }
3887
3888         /**
3889          * AdminActions::parse_itemoptions()
3890          *
3891          * date change on edit item
3892          *
3893          * Parse skinvar itemoptions
3894          * Adds the itemOptions of a plugin to a page
3895          * @author TeRanEX
3896          */
3897         function parse_itemtime($what)
3898         {
3899                 global $manager;
3900
3901                 $item = false;
3902                 $itemid = intRequestVar('itemid');
3903                 $item =& $manager->getItem($itemid, 1, 1);
3904
3905                 $blog   =& $manager->getBlog(getBlogIDFromItemID($itemid));
3906
3907                 if ( $item && $blog->convertBreaks() && requestVar('action') == 'itemedit' )
3908                 {
3909                         $item['body'] = removeBreaks($item['body']);
3910                         $item['more'] = removeBreaks($item['more']);
3911                 }
3912
3913                 $contents = array();
3914                 if ( requestVar('action') == 'itemedit' )
3915                 {
3916                         $contents = $item;
3917                 }
3918                 elseif ( requestVar('action') == 'createitem' )
3919                 {
3920                         $data = array(
3921                                 'contents' => &$contents,
3922                                 'blog'     => &$this->blog
3923                         );
3924                         $manager->notify('PreAddItemForm', $data);
3925                 }
3926                 $itemtime = getdate($contents['timestamp']);
3927                 echo $itemtime[$what];
3928                 return;
3929         }
3930
3931         /**
3932          * AdminActions::parse_jstoolbaroptions()
3933          * Parse skinvar jstoolbaroptions
3934          *
3935          * @param       void
3936          * @return      void
3937          */
3938         public function parse_jstoolbaroptions()
3939         {
3940                 global $CONF;
3941                 $options = array(
3942                         _SETTINGS_JSTOOLBAR_NONE,
3943                         _SETTINGS_JSTOOLBAR_SIMPLE,
3944                         _SETTINGS_JSTOOLBAR_FULL
3945                 );
3946
3947                 $i = 1;
3948                 foreach ( $options as $option )
3949                 {
3950                         $text  = "<option value=\"%d\"%s>%s</option>\n";
3951                         $extra = ($CONF['DisableJsTools'] == $i) ? ' selected="selected"' : '';
3952                         echo sprintf($text, $i, $extra, $option);
3953                         $i++;
3954                 }
3955                 return;
3956         }
3957         /**
3958          * AdminActions::parse_localeselectoptions()
3959          * Parse skinvar localeselectoptions
3960          *
3961          * @param       void
3962          * @return      void
3963          */
3964         public function parse_localeselectoptions()
3965         {
3966                 $locales = i18n::get_available_locale_list();
3967
3968                 $memid = intRequestVar('memberid');
3969                 if ( $memid )
3970                 {
3971                         $mem = MEMBER::createFromID($memid);
3972                         if ( !$mem->getLocale() || !in_array($mem->getLocale(), $locales) )
3973                         {
3974                                 echo "<option value=\"\" selected=\"selected\">" . Entity::hsc(_MEMBERS_USESITELANG) . "</option>\n";
3975                         }
3976                         else
3977                         {
3978                                 echo "<option value=\"\">" . Entity::hsc(_MEMBERS_USESITELANG) . "</option>\n";
3979                         }
3980                 }
3981                 else
3982                 {
3983                         if ( !i18n::get_current_locale() || !in_array(i18n::get_current_locale(), $locales) )
3984                         {
3985                                 echo "<option value=\"\" selected=\"selected\">en_Latn_US</option>\n";
3986                         }
3987                 }
3988                 foreach ( $locales as $locale )
3989                 {
3990                         if ($memid)
3991                         {
3992                                 if ( $locale == $mem->getLocale() )
3993                                 {
3994                                         echo "<option value=\"{$locale}\" selected=\"selected\">{$locale}</option>\n";
3995                                 }
3996                                 else
3997                                 {
3998                                         echo "<option value=\"{$locale}\">{$locale}</option>\n";
3999                                 }
4000                         }
4001                         else
4002                         {
4003                                 if ( $locale == i18n::get_current_locale() )
4004                                 {
4005                                         echo "<option value=\"{$locale}\" selected=\"selected\">{$locale}</option>\n";
4006                                 }
4007                                 else
4008                                 {
4009                                         echo "<option value=\"{$locale}\">{$locale}</option>\n";
4010                                 }
4011                         }
4012                 }
4013                 return;
4014         }
4015
4016         /**
4017          * AdminActions::parse_listplugplugoptionrow()
4018          * Parse templatevar listplugplugoptionrow
4019          *
4020          * @param       string  $templateName   name of template
4021          * @return      void
4022          */
4023         public function parse_listplugplugoptionrow($templateName = '')
4024         {
4025                 echo listplug_plugOptionRow(Admin::$aOptions, $templateName);
4026                 return;
4027         }
4028
4029         /**
4030          * AdminActions::parse_mediadirwarning()
4031          * Parse skinvar mediadirwarning
4032          *
4033          * @param       void
4034          * @return      void
4035          */
4036         public function parse_mediadirwarning()
4037         {
4038                 global $DIR_MEDIA;
4039                 if ( !is_dir($DIR_MEDIA) )
4040                 {
4041                         echo "<br /><b>" . _WARNING_NOTADIR . "</b>\n";
4042                 }
4043                 if ( !is_readable($DIR_MEDIA) )
4044                 {
4045                         echo "<br /><b>" . _WARNING_NOTREADABLE . "</b>\n";
4046                 }
4047                 if ( !is_writeable($DIR_MEDIA) )
4048                 {
4049                         echo "<br /><b>" . _WARNING_NOTWRITABLE . "</b>\n";
4050                 }
4051                 return;
4052         }
4053
4054         /**
4055          * AdminActions::parse_movedistselect()
4056          * Parse skinvar movedistselect
4057          */
4058         public function parse_movedistselect()
4059         {
4060                 $actionType = requestVar('action');
4061                 switch ( $actionType )
4062                 {
4063                         case 'batchitem':
4064                                 Admin::selectBlogCategory('destcatid');
4065                                 break;
4066                         case 'batchcategory':
4067                                 Admin::selectBlog('destblogid');
4068                                 break;
4069                         default:
4070                                 if ( $this->skintype == 'itemmove' )
4071                                 {
4072                                         $query  = "SELECT icat as result FROM %s WHERE inumber=%d;";
4073                                         $query = sprintf($query, sql_table('item'), intRequestVar('itemid'));
4074                                         $catid  = quickQuery(sprintf($query, intRequestVar('itemid')));
4075                                         Admin::selectBlogCategory('catid', $catid, 10, 1);
4076                                 }
4077                                 break;
4078                 }
4079                 return;
4080         }
4081
4082         /**
4083          * AdminActions::parse_moveitemid()
4084          * Parse skinvar moveitemid
4085          *
4086          * @param       void
4087          * @return      void
4088          */
4089         public function parse_moveitemid()
4090         {
4091                 echo intRequestVar('itemid');
4092                 return;
4093         }
4094
4095         /**
4096          * AdminActions::parse_newestcompare()
4097          * Parse skinvar newestcompare
4098          *
4099          * @param       void
4100          * @return      void
4101          */
4102         public function parse_newestcompare()
4103         {
4104                 global $nucleus;
4105
4106                 $newestVersion  = getLatestVersion();
4107                 $newestCompare  = str_replace('/', '.', $newestVersion);
4108                 $currentVersion = str_replace(array('/', 'v'), array('.', ''), $nucleus['version']);
4109
4110                 if ( $newestVersion && version_compare($newestCompare, $currentVersion, '>') )
4111                 {
4112                         echo '<br /><a style="color:red" href="http://nucleuscms.org/upgrade.php" title="' . _ADMIN_SYSTEMOVERVIEW_LATESTVERSION_TITLE . '">';
4113                         echo _ADMIN_SYSTEMOVERVIEW_LATESTVERSION_TEXT . $newestVersion . '</a>';
4114                 }
4115                 return;
4116         }
4117
4118         /**
4119          * AdminActions::parse_newmemberselect()
4120          * Parse skinvar newmemberselect
4121          *
4122          * @param       string  $templateName   name of template to use
4123          * @return      void
4124          */
4125         public function parse_newmemberselect($templateName = '')
4126         {
4127                 $blogid = intRequestVar('blogid');
4128
4129                 $query = "SELECT tmember FROM %s WHERE tblog=%d;";
4130                 $query = sprintf($query, sql_table('team'), (integer) $blogid);
4131                 $res = sql_query($query);
4132
4133                 $tmem = array();
4134                 while ( $tmember = sql_fetch_object($res) )
4135                 {
4136                         $tmem[] = intval($tmember->tmember);
4137                 }
4138
4139                 $query  = "SELECT mname as text, mnumber as value FROM %s WHERE mnumber NOT IN (%s);";
4140                 $query = sprintf($query, sql_table('member'), implode(', ', $tmem));
4141
4142                 $template['name']        = 'memberid';
4143                 $template['tabindex'] = 10000;
4144                 Showlist($query, 'select', $template, $templateName);
4145                 return;
4146         }
4147
4148         /**
4149          * AdminActions::parse_newpluginlist()
4150          * Parse skinvar newpluginlist
4151          *
4152          * @param       void
4153          * @return      void
4154          */
4155         public function parse_newpluginlist()
4156         {
4157                 $candidates = $this->newPlugCandidates;
4158                 foreach ( $candidates as $name )
4159                 {
4160                         echo '<option value="NP_' . $name . '">' . Entity::hsc($name) . "</option>\n";
4161                 }
4162                 return;
4163         }
4164
4165         /**
4166          * AdminActions::parse_outputspecialdirs()
4167          * Parse skinvar outputspecialdirs
4168          *
4169          * @param       string  $type   type of setting for directory
4170          * @return      void
4171          */
4172         public function parse_outputspecialdirs($type)
4173         {
4174                 global $DIR_MEDIA, $DIR_NUCLEUS;
4175
4176                 switch ( $type )
4177                 {
4178                         case 'nucleusdir':
4179                                 echo Entity::hsc($DIR_NUCLEUS);
4180                                 break;
4181                         case 'mediadir':
4182                                 echo Entity::hsc($DIR_MEDIA);
4183                                 break;
4184                 }
4185                 return;
4186         }
4187
4188         /**
4189          * AdminActions::parse_passrequestvars()
4190          * Parse skinvar passrequestvars
4191          *
4192          * @param       void
4193          * @return      void
4194          */
4195         public function parse_passrequestvars()
4196         {
4197                 $passvar   = Admin::getAdminpassvar();
4198                 $oldaction = postVar('oldaction');
4199
4200                 if ( ($oldaction != 'logout')
4201                   && ($oldaction != 'login')
4202                   && $passvar
4203                   && !postVar('customaction') )
4204                 {
4205                         passRequestVars();
4206                 }
4207                 return;
4208         }
4209
4210         /**
4211          * AdminActions::parse_pluginextras()
4212          * Parse skinvar pluginextras
4213          *
4214          * @param       string  $type   type of plugin context
4215          * @return      void
4216          */
4217         public function parse_pluginextras($type = 'global')
4218         {
4219                 global $manager;
4220                 switch ( $type )
4221                 {
4222                         case 'member':
4223                                 $id  = intRequestVar('memberid');
4224                                 $mem = MEMBER::createFromID($id);
4225                                 $manager->notify('MemberSettingsFormExtras', array('member' => &$mem));
4226                                 break;
4227                         case 'blog':
4228                                 $id  = intRequestVar('blogid');
4229                                 $blg = $manager->getBlog($id);
4230                                 $manager->notify('BlogSettingsFormExtras', array('member' => &$blg));
4231                                 break;
4232                         default:
4233                                 $manager->notify(
4234                                         'GeneralSettingsFormExtras',
4235                                         array(
4236                                         )
4237                                 );
4238                                 break;
4239                 }
4240                 return;
4241         }
4242
4243         /**
4244          * AdminActions::parse_pluginhelp()
4245          * Parse skinvar pluginhelp
4246          *
4247          * @param       void
4248          * @return      void
4249          */
4250         public function parse_pluginhelp()
4251         {
4252                 global $manager, $DIR_PLUGINS;
4253
4254                 $plugid = intGetVar('plugid');
4255                 $plugName =  getPluginNameFromPid($plugid);
4256                 $plug =& $manager->getPlugin($plugName);
4257
4258                 if ( $plug->supportsFeature('HelpPage') > 0 )
4259                 {
4260                         $helpfile = $DIR_PLUGINS . $plug->getShortName() . '/help.';
4261                         if ( @file_exists($helpfile . 'php') )
4262                         {
4263                                 @include($helpfile . 'php');
4264                                 return;
4265                         }
4266                         elseif ( @file_exists($helpfile . 'html') )
4267                         {
4268                                 @include($helpfile . 'html');
4269                                 return;
4270                         }
4271                 }
4272                 echo '<p>' . _ERROR . ': ' . _ERROR_PLUGNOHELPFILE . "</p>\n";
4273                 echo '<p><a href="index.php?action=pluginlist">(' . _BACK . ")</a></p>\n";
4274                 return;
4275         }
4276
4277         /**
4278          * AdminActions::parse_pluginlistlist()
4279          * Parse skinvar pluginlistlist
4280          *
4281          * @param       string  $templateName   name of template to use
4282          * @return      void
4283          */
4284         public function parse_pluginlistlist($templateName = '')
4285         {
4286                 $query = "SELECT * FROM %s ORDER BY porder ASC;";
4287                 $query = sprintf($query, sql_table('plugin'));
4288
4289                 $template['content']  = 'pluginlist';
4290                 $template['tabindex'] = 10;
4291
4292                 Showlist($query, 'table', $template, $templateName);
4293
4294                 return;
4295         }
4296
4297         /**
4298          * AdminActions::parse_pluginoptions()
4299          * Parse skinvar pluginoptions
4300          *
4301          * @param       string  $type   type of plugin option
4302          * @return      void
4303          */
4304         public function parse_pluginoptions($type = 'global')
4305         {
4306                 global $itemid;
4307
4308                 switch ( $type )
4309                 {
4310                         case 'member':
4311                                 $id = intRequestVar('memberid');
4312                                 break;
4313                         case 'blog':
4314                                 $id = intRequestVar('blogid');
4315                                 break;
4316                         case 'category':
4317                                 $id = intRequestVar('catid');
4318                                 break;
4319                         case 'item':
4320                                 $id = $itemid;
4321                                 break;
4322                 }
4323                 Admin::insertPluginOptions($type, $id);
4324                 return;
4325         }
4326
4327         /**
4328          * AdminActions::parse_qmenuaddselect()
4329          * Parse skinvar qmanuaddselect
4330          *
4331          * @param       string  $templateName   name of template to use
4332          * @return      void
4333          */
4334         public function parse_qmenuaddselect($templateName = '')
4335         {
4336                 global $member;
4337                 $showAll = requestVar('showall');
4338                 if ( $member->isAdmin() && ($showAll == 'yes') )
4339                 {
4340                         // Super-Admins have access to all blogs! (no add item support though)
4341                         $query =  'SELECT bnumber as value, bname as text'
4342                                . ' FROM ' . sql_table('blog')
4343                                . ' ORDER BY bname';
4344                 }
4345                 else
4346                 {
4347                         $query =  'SELECT bnumber as value, bname as text'
4348                                . ' FROM ' . sql_table('blog') . ', ' . sql_table('team')
4349                                . ' WHERE tblog=bnumber and tmember=' . $member->getID()
4350                                . ' ORDER BY bname';
4351                 }
4352
4353                 $template['name']               = 'blogid';
4354                 $template['tabindex']   = 15000;
4355                 $template['extra']              = _QMENU_ADD_SELECT;
4356                 $template['selected']   = -1;
4357                 $template['shorten']    = 10;
4358                 $template['shortenel']  = '';
4359                 $template['javascript'] = 'onchange="return form.submit()"';
4360
4361                 Showlist($query, 'select', $template, $templateName);
4362
4363                 return;
4364         }
4365
4366         /**
4367          * AdminActions::parse_quickmenu()
4368          * Parse skinvar quickmenu
4369          *
4370          * @param       string  $templateName   name of template to use
4371          * @return      void
4372          */
4373         public function parse_quickmenu($templateName = '')
4374         {
4375                 global $manager;
4376                 $templates = array();
4377                 $template  = array();
4378                 if ( !empty($templateName) )
4379                 {
4380                         $templates = Template::read($templateName);
4381                 }
4382                 $pluginExtras = array();
4383                 $manager->notify(
4384                         'QuickMenu',
4385                         array(
4386                                 'options' => &$pluginExtras
4387                         )
4388                 );
4389                 if ( count($pluginExtras) > 0 )
4390                 {
4391                         if ( !array_key_exists('PLUGIN_QUICKMENU_TITLE', $templates) || empty($templates['PLUGIN_QUICKMENU_TITLE']) )
4392                         {
4393                                 $template['title'] = "<h2><%text(_QMENU_PLUGINS)%></h2>\n";
4394                         }
4395                         else
4396                         {
4397                                 $template['title'] = $templates['PLUGIN_QUICKMENU_TITLE'];
4398                         }
4399                         if ( !array_key_exists('PLUGIN_QUICKMENU_HEAD', $templates) || empty($templates['PLUGIN_QUICKMENU_HEAD']) )
4400                         {
4401                                 $template['head'] = "<ul>\n";
4402                         }
4403                         else
4404                         {
4405                                 $template['head'] = $templates['PLUGIN_QUICKMENU_HEAD'];
4406                         }
4407                         if ( !array_key_exists('PLUGIN_QUICKMENU_BODY', $templates) && empty($templates['PLUGIN_QUICKMENU_BODY']) )
4408                         {
4409                                 $template['body'] = "<li><a href=\"<%plugadminurl%>\" title=\"<%plugadmintooltip%>\"><%plugadmintitle%></a></li>\n";
4410                         }
4411                         else
4412                         {
4413                                 $template['body'] = $templates['PLUGIN_QUICKMENU_BODY'];
4414                         }
4415                         if ( !array_key_exists('PLUGIN_QUICKMENU_FOOT', $templates) || empty($templates['PLUGIN_QUICKMENU_FOOT']) )
4416                         {
4417                                 $template['foot'] = "</ul>\n";
4418                         }
4419                         else
4420                         {
4421                                 $template['foot'] = $templates['PLUGIN_QUICKMENU_FOOT'];
4422                         }
4423
4424                         $handler = new Actions($this->skintype);
4425                         $parser = new PARSER($handler);
4426
4427                         $parser->parse($template['title']);
4428                         echo $template['head'];
4429                         foreach ( $pluginExtras as $aInfo )
4430                         {
4431                                 $data = array(
4432                                         'plugadminurl'          => Entity::hsc($aInfo['url']),
4433                                         'plugadmintooltip'      => Entity::hsc($aInfo['tooltip']),
4434                                         'plugadmintitle'        => Entity::hsc($aInfo['title']),
4435                                 );
4436                                 echo Template::fill($template['body'], $data);
4437                         }
4438                         echo $template['foot'];
4439                 }
4440                 return;
4441         }
4442
4443         /**
4444          * AdminActions::parse_requestblogid()
4445          * Parse skinvar requestblogid
4446          *
4447          * @param       void
4448          * @return      void
4449          */
4450         public function parse_requestblogid()
4451         {
4452                 echo intRequestVar('blogid');
4453                 return;
4454         }
4455
4456         /**
4457          * AdminActions::parse_requestiprange()
4458          * Parse skinvar requestiprange
4459          *
4460          * @param       void
4461          * @return      void
4462          */
4463         public function parse_requestiprange()
4464         {
4465                 if ( requestVar('iprange') )
4466                 {
4467                         echo Entity::hsc(requestVar('iprange'));
4468                 }
4469                 elseif ( requestVar('ip') )
4470                 {
4471                         echo Entity::hsc(requestVar('ip'));
4472                 }
4473                 return;
4474         }
4475
4476         /**
4477          * AdminActions::parse_selectlocaladminskinfiles()
4478          * Parse skinvar selectlocaladminskinfiles
4479          *
4480          * @param       void
4481          * @return      void
4482          */
4483         public function parse_selectlocaladminskinfiles()
4484         {
4485                 global $DIR_SKINS, $manager;
4486
4487                 $adminskindir = $DIR_SKINS . 'admin/';
4488                 $candidates = SkinImport::searchForCandidates($adminskindir);
4489
4490                 foreach ( $candidates as $skinname => $skinfile )
4491                 {
4492                         $html = Entity::hsc($skinfile);
4493                         echo '<option value="' . $html . '">' . $skinname . "</option>\n";
4494                 }
4495
4496                 return;
4497         }
4498
4499         /**
4500          * AdminActions::parse_selectlocalskinfiles()
4501          * Parse skinvar selectlocalskinfiles
4502          *
4503          * @param       void
4504          * @return      void
4505          */
4506         public function parse_selectlocalskinfiles()
4507         {
4508                 global $DIR_SKINS;
4509
4510                 $candidates = SkinImport::searchForCandidates($DIR_SKINS);
4511
4512                 foreach ( $candidates as $skinname => $skinfile )
4513                 {
4514                         $html = Entity::hsc($skinfile);
4515                         echo '<option value="' . $html . '">' . $skinname . "</option>\n";
4516                 }
4517
4518                 return;
4519         }
4520
4521         /**
4522          * AdminActions::parse_skineditallowedlist()
4523          * Parse skinvar skineditallowedlist
4524          *
4525          * @param       string  $type                   type of skin
4526          * @param       string  $templateName   name of template
4527          * @return      void
4528          */
4529         public function parse_skineditallowedlist($type, $templateName = '')
4530         {
4531                 switch ( $type )
4532                 {
4533                         case 'blog':
4534                                 $query = "SELECT bshortname, bname FROM %s;";
4535                                 $show  = array(
4536                                         'content' => 'shortblognames'
4537                                 );
4538                                 $query = sprintf($query, sql_table('blog'));
4539                                 Showlist($query, 'table', $show, $templateName);
4540                                 break;
4541                         case 'template':
4542                                 $query = "SELECT tdname as name, tddesc as description FROM %s WHERE tdname NOT LIKE 'admin/%%';";
4543                                 $show  = array(
4544                                         'content' => 'shortnames'
4545                                 );
4546                                 $query = sprintf($query, sql_table('template_desc'));
4547                                 Showlist($query, 'table', $show, $templateName);
4548                                 break;
4549                 }
4550                 return;
4551         }
4552
4553         /**
4554          * AdminActions::parse_skinielist()
4555          * Parse skinvar skinielist
4556          *
4557          * @param       string  $type                   type of skin
4558          * @param       string  $templateName   name of template to use
4559          * @return      void
4560          */
4561         public function parse_skinielist($type, $templateName = '')
4562         {
4563                 $templates = array();
4564                 if ( $templateName )
4565                 {
4566                         $templates = Template::read($templateName);
4567                 }
4568                 if ( array_key_exists('SKINIE_EXPORT_LIST', $templates) && !empty($templates['SKINIE_EXPORT_LIST']) )
4569                 {
4570                         $template = $templates['SKINIE_EXPORT_LIST'];
4571                 }
4572                 else
4573                 {
4574                         $template = "<td>"
4575                                   . "<input type=\"checkbox\" name=\"<%typeid%>\" id=\"<%expid%>\" />\n"
4576                                   . "<label for=\"<%expid%>\"><%expname%></label>\n"
4577                                   . "</td>\n"
4578                                   . "<td><%expdesc%></td>\n"
4579                                   . "</tr>\n"
4580                                   . "<tr>\n";
4581                 }
4582                 switch ( $type )
4583                 {
4584                         case 'skin':
4585                                 $res = sql_query('SELECT * FROM ' . sql_table('skin_desc'));
4586                                 while ( $skinObj = sql_fetch_object($res) )
4587                                 {
4588                                         $data = array(
4589                                                 'typeid'        => 'skin[' . $skinObj->sdnumber . ']',
4590                                                 'expid'         => 'skinexp' . $skinObj->sdnumber,
4591                                                 'expname'       => Entity::hsc($skinObj->sdname),
4592                                                 'expdesc'       => Entity::hsc($skinObj->sddesc),
4593                                         );
4594                                         echo Template::fill($template, $data);
4595                                 }
4596                                 break;
4597                         case 'template':
4598                                 $res = sql_query('SELECT * FROM '.sql_table('template_desc'). " WHERE tdname NOT LIKE 'admin/%%';");
4599                                 while ($templateObj = sql_fetch_object($res)) {
4600                                         $data = array(
4601                                                 'typeid'        => 'template[' . $templateObj->tdnumber . ']',
4602                                                 'expid'         => 'templateexp' . $templateObj->tdnumber,
4603                                                 'expname'       => Entity::hsc($templateObj->tdname),
4604                                                 'expdesc'       => Entity::hsc($templateObj->tddesc),
4605                                         );
4606                                         echo Template::fill($template, $data);
4607                                 }
4608                                 break;
4609                 }
4610                 return;
4611         }
4612
4613         /**
4614          * AdminActions::parse_skinoverview()
4615          * Parse skinvar skinoverview
4616          *
4617          * @param       string  $templateName   name of template to use
4618          * @return      void
4619          */
4620         public function parse_skinoverview($templateName = '')
4621         {
4622                 global $CONF;
4623                 $query = "SELECT * FROM %s WHERE sdname NOT LIKE 'admin/%%';";
4624                 $query = sprintf($query, sql_table('skin_desc'));
4625
4626                 $template['content']  = 'skinlist';
4627                 $template['tabindex'] = 10;
4628
4629                 Showlist($query, 'table', $template, $templateName);
4630                 return;
4631         }
4632
4633         /**
4634          * AdminActions::parse_skintypehelp()
4635          * Check editing skintypehelp
4636          *
4637          * @param       void
4638          * @return      void
4639          */
4640         public function parse_skintypehelp()
4641         {
4642                 $nowSkinType = strtolower(trim(requestVar('type')));
4643
4644                 /* TODO: use Skin class */
4645                 $regularType = array(
4646                         'index',
4647                         'item',
4648                         'archivelist',
4649                         'archive',
4650                         'search',
4651                         'error',
4652                         'member',
4653                         'imagepopup'
4654                 );
4655
4656                 if ( in_array($nowSkinType, $regularType) )
4657                 {
4658                         help('skinpart' . $nowSkinType);
4659                 }
4660                 else
4661                 {
4662                         help('skinpartspecial');
4663                 }
4664                 return;
4665         }
4666
4667         /**
4668          * AdminActions::parse_specialskinlist()
4669          * Parse skinvar specialskinlist
4670          *
4671          * @param       string  $templateName   name of template to use
4672          * @return      void
4673          */
4674         public function parse_specialskinlist($templateName = '')
4675         {
4676                 $templates = array();
4677                 if ( $templateName )
4678                 {
4679                         $templates = Template::read($templateName);
4680                 }
4681
4682                 /* TODO: use Skin class */
4683                 $nType  = array(
4684                         'index',
4685                         'item',
4686                         'error',
4687                         'search',
4688                         'archive',
4689                         'archivelist',
4690                         'imagepopup',
4691                         'member'
4692                 );
4693                 $skinid = intRequestVar('skinid');
4694                 $query  = "SELECT stype FROM %s WHERE stype NOT IN ('%s') AND sdesc = %d;";
4695                 $query = sprintf($query, sql_table('skin'), implode("', '", $nType), $skinid);
4696
4697                 $res    = sql_query($query);
4698                 if ( $res && sql_num_rows($res) > 0 )
4699                 {
4700                         $data = array();
4701                         if ( array_key_exists('SPECIALSKINLIST_HEAD', $templates) && !empty($templates['SPECIALSKINLIST_HEAD']) )
4702                         {
4703                                 $template['head'] = $templates['SPECIALSKINLIST_HEAD'];
4704                         }
4705                         else
4706                         {
4707                                 $template['head'] = "<ul>\n";
4708                         }
4709                         echo Template::fill($template['head'], $data);
4710                         if ( !array_key_exists('SPECIALSKINLIST_BODY', $templates) || empty($templates['SPECIALSKINLIST_BODY']) )
4711                         {
4712                                 $template['body'] = '<li><a tabindex="<%tabindex%>" href="index.php?action=skinedittype&amp;skinid=<%skinid%>'
4713                                                                   . '&amp;type=<%skintype%>"><%skintype%></a> (<a tabindex="<%tabindex%>" href="index.php?'
4714                                                                   . 'action=skinremovetype&amp;skinid=<%skinid%>&amp;type=<%skintype%>">remove</a>)</li>';
4715                         }
4716                         else
4717                         {
4718                                 $template['body'] = $templates['SPECIALSKINLIST_BODY'];
4719                         }
4720
4721                         $tabstart = 75;
4722                         while ( $row = sql_fetch_assoc($res) )
4723                         {
4724                                 $data = array(
4725                                         'tabindex'      => $tabstart++,
4726                                         'skinid'        => $skinid,
4727                                         'skintype'      => Entity::hsc(strtolower($row['stype']))
4728                                 );
4729                                 echo Template::fill($template['body'], $data);
4730                         }
4731                         $data = array();
4732                         if (array_key_exists('SPECIALSKINLIST_FOOT', $templates) && !empty($templates['SPECIALSKINLIST_FOOT']) )
4733                         {
4734                                 $template['foot'] = $templates['SPECIALSKINLIST_FOOT'];
4735                         }
4736                         else
4737                         {
4738                                 $template['foot'] = "</ul>\n";
4739                         }
4740                         echo Template::fill($template['foot'], $data);
4741                         return;
4742                 }
4743         }
4744
4745         /**
4746          * AdminActions::parse_sprinttext()
4747          * Parse sprinttext
4748          *
4749          * @param       string  $which
4750          * @param       string  $val
4751          * @return      void
4752          */
4753         public function parse_sprinttext($which, $val)
4754         {
4755                 if ( !defined($which) )
4756                 {
4757                         $base = $which;
4758                 }
4759                 else
4760                 {
4761                         $base = constant($which);
4762                 }
4763
4764                 if ( preg_match('#[^<|%].*[^%|>]#', $val, $matchies) )
4765                 {
4766                         if ( !preg_match('#[(].*[^)]#', $matchies[0], $args) )
4767                         {
4768                                 $met = 'parse_' . $matchies[0];
4769                         }
4770                         else
4771                         {
4772                                 $arg = trim($args[0], '()');
4773                                 $met = 'parse_' . substr($matchies[0], 0, strpos($matchies[0], '('));
4774                         }
4775
4776                         if ( method_exists($this, $met) )
4777                         {
4778                                 $value = call_user_func(array(&$this, $met), $arg);
4779                         }
4780                 }
4781
4782                 if ( !isset($value) || empty($value) )
4783                 {
4784                         $value = $val;
4785                 }
4786                 echo sprintf($base, $value);
4787                 return;
4788         }
4789
4790         /**
4791          * AdminActions::parse_systemsettings()
4792          * Parse skinvar systemsettings
4793          *
4794          * @param       string  $type                   type of settings for system
4795          * @param       string  $templateName   name of template to use
4796          * @return      void
4797          */
4798         public function parse_systemsettings($type = 'phpinfo', $templateName = '')
4799         {
4800                 global $member, $CONF, $nucleus;
4801
4802                 $member->isAdmin() or Admin::disallow();
4803
4804                 $enable  = _ADMIN_SYSTEMOVERVIEW_ENABLE;
4805                 $disable = _ADMIN_SYSTEMOVERVIEW_DISABLE;
4806
4807                 switch ( $type )
4808                 {
4809                         case 'phpversion':
4810                                 echo phpversion();
4811                                 break;
4812                         case 'sqlserverinfo':
4813                                 echo sql_get_server_info();
4814                                 break;
4815                         case 'sqlclientinfo':
4816                                 echo sql_get_client_info();
4817                                 break;
4818                         case 'magicquotesgpc':
4819                                 echo ini_get('magic_quotes_gpc') ? 'On' : 'Off';
4820                                 break;
4821                         case 'magicquotesruntime':
4822                                 echo ini_get('magic_quotes_runtime') ? 'On' : 'Off';
4823                                 break;
4824                         case 'registerglobals':
4825                                 echo ini_get('register_globals') ? 'On' : 'Off';
4826                                 break;
4827                         case 'gdinfo':
4828                                 $templates = array();
4829                                 if ( $templateName )
4830                                 {
4831                                         $templates = Template::read($templateName);
4832                                 }
4833                                 if ( !array_key_exists('SYSTEMINFO_GDSETTINGS', $templates) || empty($templates['SYSTEMINFO_GDSETTINGS']) )
4834                                 {
4835                                         $template = "<tr>\n"
4836                                                   . "<td><%key%></td>\n"
4837                                                   . "<td><%value%></td>\n"
4838                                                   . "</tr>\n";
4839                                 }
4840                                 else
4841                                 {
4842                                         $template = $templates['SYSTEMINFO_GDSETTINGS'];
4843                                 }
4844
4845                                 $gdinfo = gd_info();
4846
4847                                 foreach ( $gdinfo as $key => $value )
4848                                 {
4849                                         if ( is_bool($value) )
4850                                         {
4851                                                 $value = $value ? $enable : $disable;
4852                                         }
4853                                         else
4854                                         {
4855                                                 $value = Entity::hsc($value);
4856                                         }
4857                                         $data = array(
4858                                                 'key'   => $key,
4859                                                 'value' => $value,
4860                                         );
4861                                         echo Template::fill($template, $data);
4862                                 }
4863                                 break;
4864                         case 'modrewrite':
4865                                 ob_start();
4866                                 phpinfo(INFO_MODULES);
4867                                 $im = ob_get_contents();
4868                                 ob_end_clean();
4869                                 echo ( i18n::strpos($im, 'mod_rewrite') !== FALSE ) ? $enable : $disable;
4870                                 break;
4871                         case 'nucleusversion':
4872                                 echo getNucleusVersion() / 100 . '(' . $nucleus['version'] . ')';
4873                                 break;
4874                         case 'nucleuspatchlevel':
4875                                 echo getNucleusPatchLevel();
4876                                 break;
4877                         case 'confself':
4878                                 echo $CONF['Self'];
4879                                 break;
4880                         case 'confitemurl':
4881                                 echo $CONF['ItemURL'];
4882                                 break;
4883                         case 'alertonheaderssent':
4884                                 echo $CONF['alertOnHeadersSent'] ? $enable : $disable;
4885                                 break;
4886                         case 'nucleuscodename':
4887                                 if ( $nucleus['codename'] != '' )
4888                                 {
4889                                         echo ' &quot;' . $nucleus['codename'] . '&quot;';
4890                                 }
4891                                 break;
4892                         case 'versioncheckurl':
4893                                 echo sprintf(_ADMIN_SYSTEMOVERVIEW_VERSIONCHECK_URL, getNucleusVersion(), getNucleusPatchLevel());
4894                                 break;
4895                 }
4896                 return;
4897         }
4898
4899         /**
4900          * AdminActions::parse_templateoverview()
4901          * Parse skinvar templateoverview
4902          *
4903          * @param       string  $templateName   name of template to use
4904          * @return      void
4905          */
4906         public function parse_templateoverview($templateName = '')
4907         {
4908                 $query  = "SELECT * FROM %s WHERE tdname NOT LIKE 'admin/%%' ORDER BY tdname";
4909                 $query = sprintf($query, sql_table('template_desc'));
4910
4911                 $template['content']  = 'templatelist';
4912                 $template['tabindex'] = 10;
4913
4914                 Showlist($query, 'table', $template, $templateName);
4915
4916                 return;
4917         }
4918
4919         /**
4920          * AdminActions::parse_ticket()
4921          * Parse ticket
4922          *
4923          * @param       void
4924          * @return      void
4925          */
4926         public function parse_ticket()
4927         {
4928                 global $manager;
4929                 $manager->addTicketHidden();
4930                 return;
4931         }
4932
4933         /**
4934          * AdminActions::parse_versioncheckurl()
4935          * Parse skinvar versioncheckurl
4936          *
4937          * @param       void
4938          * @return      void
4939          */
4940         public function parse_versioncheckurl()
4941         {
4942                 echo sprintf(_ADMIN_SYSTEMOVERVIEW_VERSIONCHECK_URL, getNucleusVersion(), getNucleusPatchLevel());
4943                 return;
4944         }
4945
4946         /**
4947          * AdminActions::parse_yrbloglist()
4948          * Parse skinvar yrbloglist
4949          *
4950          * @param       string  $templateName   name of template to use
4951          * @return      void
4952          */
4953         public function parse_yrbloglist($templateName = '')
4954         {
4955                 global $member;
4956                 $showAll = requestVar('showall');
4957
4958                 if ( $member->isAdmin() && ($showAll == 'yes') )
4959                 {
4960                         // Super-Admins have access to all blogs! (no add item support though)
4961                         $query =  "SELECT bnumber, bname, 1 as tadmin, burl, bshortname"
4962                                 . " FROM %s"
4963                                 . " ORDER BY bnumber;";
4964                         $query = sprintf($query, sql_table('blog'));
4965                 }
4966                 else
4967                 {
4968                         $query =  "SELECT bnumber, bname, tadmin, burl, bshortname"
4969                                 . " FROM %s,%s"
4970                                 . " WHERE tblog=bnumber and tmember=%d"
4971                                 . " ORDER BY bnumber;";
4972                         $query = sprintf($query, sql_table('blog'), sql_table('team'), (integer) $member->getID());
4973                 }
4974
4975                 $template['content']    = 'bloglist';
4976                 $template['superadmin'] = $member->isAdmin();
4977
4978                 $amount = Showlist($query, 'table', $template, $templateName);
4979
4980                 if ( ($showAll != 'yes') && ($member->isAdmin()) )
4981                 {
4982                         $query = 'SELECT COUNT(*) as result FROM ' . sql_table('blog');
4983
4984                         $total = quickQuery($query);
4985                         if ( $total > $amount )
4986                         {
4987                                 echo '<p><a href="index.php?action=overview&amp;showall=yes">' . _OVERVIEW_SHOWALL . '</a></p>';
4988                         }
4989                 }
4990
4991                 if ( $amount == 0 )
4992                 {
4993                         echo _OVERVIEW_NOBLOGS;
4994                 }
4995                 elseif( $amount != 0 )
4996                 {
4997                         echo '<h2>' . _OVERVIEW_YRDRAFTS . '</h2>';
4998
4999                         $query =  "SELECT ititle, inumber, bshortname"
5000                                . " FROM %s,%s"
5001                                . ' WHERE iauthor=%d AND iblog=bnumber AND idraft=1;';
5002                         $query = sprintf($query, sql_table('item'), sql_table('blog'), (integer) $member->getID());
5003
5004                         $template['content'] = 'draftlist';
5005
5006                         $amountdrafts = Showlist($query, 'table', $template, $templateName);
5007                         if ( $amountdrafts == 0 )
5008                         {
5009                                 echo _OVERVIEW_NODRAFTS;
5010                         }
5011                 }
5012                 return;
5013         }
5014
5015         /**
5016          * AdminActions::checkCondition()
5017          * Checks conditions for if statements
5018          *
5019          * @param       string  $field type of <%if%>
5020          * @param       string  $name property of field
5021          * @param       string  $value value of property
5022          * @return      boolean condition
5023          */
5024         protected function checkCondition($field, $name='', $value = '')
5025         {
5026                 global $CONF, $catid, $blog, $member, $itemidnext, $itemidprev, $manager, $archiveprevexists, $archivenextexists;
5027
5028                 $condition = 0;
5029                 switch ( $field )
5030                 {
5031                         case 'category':
5032                                 if ( !$blog )
5033                                 {
5034                                         if ( $blogid )
5035                                         {
5036                                                 global $manager;
5037                                                 $blog =& $manager->getBlog($blogid);
5038                                         }
5039                                         elseif ( $catid )
5040                                         {
5041                                                 $blogid = getBlogIDFromCatID($catid);
5042                                                 global $manager;
5043                                                 $blog =& $manager->getBlog($blogid);
5044                                         }
5045                                         elseif ( intRequestVar('catid') )
5046                                         {
5047                                                 $catid = intRequestVar('catid');
5048                                                 $blogid = getBlogIDFromCatID($catid);
5049                                                 global $manager;
5050                                                 $blog =& $manager->getBlog($blogid);
5051                                         }
5052                                         else
5053                                         {
5054                                                 return;
5055                                         }
5056                                 }
5057                                 $condition = ($blog && $this->ifCategory($name, $value));
5058                                 break;
5059                         case 'blogsetting':
5060                                 $condition = ($blog && ($blog->getSetting($name) == $value));
5061                                 break;
5062                         case 'loggedin':
5063                                 $condition = $member->isLoggedIn();
5064                                 break;
5065                         case 'onteam':
5066                                 $condition = $member->isLoggedIn() && $this->ifOnTeam($name);
5067                                 break;
5068                         case 'admin':
5069                                 $condition = $member->isLoggedIn() && $this->ifAdmin($name);
5070                                 break;
5071                         case 'superadmin':
5072                                 $condition = $member->isLoggedIn() && $member->isAdmin();
5073                                 break;
5074                         case 'allowloginedit':
5075                                 $condition = $member->isLoggedIn() && ($CONF['AllowLoginEdit'] || $member->isAdmin());
5076                                 break;
5077                         case 'nextitem':
5078                                 $condition = ($itemidnext != '');
5079                                 break;
5080                         case 'previtem':
5081                                 $condition = ($itemidprev != '');
5082                                 break;
5083                         case 'archiveprevexists':
5084                                 $condition = ($archiveprevexists == true);
5085                                 break;
5086                         case 'archivenextexists':
5087                                 $condition = ($archivenextexists == true);
5088                                 break;
5089                         case 'skintype':
5090                                 $condition = (($name == $this->skintype) || ($name == requestVar('action')));
5091                                 break;
5092                         case 'hasplugin':
5093                                 $condition = $this->ifHasPlugin($name, $value);
5094                                 break;
5095                         case 'adminaction':
5096                                 $condition = (Admin::getAdminAction() == $name);
5097                                 break;
5098                         case 'adminoldaction':
5099                                 $condition = (Admin::getAdminAction() == $name);
5100                                 break;
5101                         case 'addresschange':
5102                                 $condition = ($this->ifAddresscange());
5103                                 break;
5104                         case 'bechangepass':
5105                                 $condition = ($this->beChangePassword());
5106                                 break;
5107                         case 'skincandidates':
5108                                 $condition = ($this->ifSkincandidates());
5109                                 break;
5110                         case 'nameclashes':
5111                                 $condition = requestVar('nameclashes');
5112                                 break;
5113                         case 'existsnewplugin':
5114                                 $condition = ($this->existsNewPlugin());
5115                                 break;
5116                         case 'autosave':
5117                                 $condition = (boolean) ($member->getAutosave() == $value);
5118                                 break;
5119                         default:
5120                                 $condition = $manager->pluginInstalled("NP_{$field}") && $this->ifPlugin($field, $name, $value);
5121                                 break;
5122                 }
5123                 return $condition;
5124         }
5125
5126         /**
5127          * Actions::_ifHasPlugin()
5128          *      hasplugin,PlugName
5129          *         -> checks if plugin exists
5130          *      hasplugin,PlugName,OptionName
5131          *         -> checks if the option OptionName from plugin PlugName is not set to 'no'
5132          *      hasplugin,PlugName,OptionName=value
5133          *         -> checks if the option OptionName from plugin PlugName is set to value
5134          *
5135          * @param       string  $name   name of plugin
5136          * @param       string  $value
5137          * @return
5138          */
5139         private function ifHasPlugin($name, $value)
5140         {
5141                 global $manager;
5142                 $condition = false;
5143                 // (pluginInstalled method won't write a message in the actionlog on failure)
5144                 if ( $manager->pluginInstalled("NP_{$name}") )
5145                 {
5146                         $plugin =& $manager->getPlugin("NP_{$name}");
5147                         if ( $plugin != NULL )
5148                         {
5149                                 if ( $value == "" )
5150                                 {
5151                                         $condition = true;
5152                                 }
5153                                 else
5154                                 {
5155                                         list($name2, $value2) = preg_split('#=#', $value, 2);
5156                                         if ( $value2 == "" && $plugin->getOption($name2) != 'no' )
5157                                         {
5158                                                 $condition = true;
5159                                         }
5160                                         else if ( $plugin->getOption($name2) == $value2 )
5161                                         {
5162                                                 $condition = true;
5163                                         }
5164                                 }
5165                         }
5166                 }
5167                 return $condition;
5168         }
5169
5170         /**
5171          * Actions::beChangePassword()
5172          *
5173          * @param       void
5174          * @return      void
5175          */
5176         private function beChangePassword()
5177         {
5178                 return intRequestVar('bNeedsPasswordChange');
5179         }
5180
5181         /**
5182          * Actions::ifSkincandidates()
5183          * Checks if a plugin exists and call its doIf function
5184          *
5185          * @param       void
5186          * @return      void
5187          * @return      boolean
5188          */
5189         private function ifSkincandidates()
5190         {
5191                 global $DIR_SKINS;
5192                 $candidates = SKINIMPORT::searchForCandidates($DIR_SKINS);
5193                 return (count($candidates) > 0);
5194         }
5195
5196         /**
5197          * Actions::ifPlugin()
5198          * Checks if a plugin exists and call its doIf function
5199          *
5200          * @param       string  $name   name of plugin
5201          * @param       string  $key
5202          * @param       string  $value
5203          * @return      callback
5204          */
5205         private function ifPlugin($name, $key = '', $value = '')
5206         {
5207                 global $manager;
5208
5209                 $plugin =& $manager->getPlugin("NP_{$name}");
5210                 if ( !$plugin )
5211                 {
5212                         return;
5213                 }
5214
5215                 $params = func_get_args();
5216                 array_shift($params);
5217
5218                 return call_user_func_array(array(&$plugin, 'doIf'), $params);
5219         }
5220
5221         /**
5222          * AdminActions::ifCategory()
5223          *  Different checks for a category
5224          *
5225          * @param       string  $key    key for information of category
5226          * @param       string  $value  value for information of category
5227          * @return      boolean
5228          */
5229         private function ifCategory($key = '', $value='')
5230         {
5231                 global $blog, $catid;
5232
5233                 // when no parameter is defined, just check if a category is selected
5234                 if (($key != 'catname' && $key != 'catid') || ($value == ''))
5235                 {
5236                         return $blog->isValidCategory($catid);
5237                 }
5238
5239                 // check category name
5240                 if ( $key == 'catname' )
5241                 {
5242                         $value = $blog->getCategoryIdFromName($value);
5243                         if ($value == $catid)
5244                         {
5245                                 return $blog->isValidCategory($catid);
5246                         }
5247                 }
5248
5249                 // check category id
5250                 if (($key == 'catid') && ($value == $catid))
5251                 {
5252                         return $blog->isValidCategory($catid);
5253                 }
5254
5255                 return FALSE;
5256         }
5257
5258         /**
5259          * AdminActions::ifOnTeam()
5260          * Checks if a member is on the team of a blog and return his rights
5261          *
5262          * @param       string  $blogName       name of weblog
5263          * @return      boolean
5264          */
5265         private function ifOnTeam($blogName = '')
5266         {
5267                 global $blog, $member, $manager;
5268
5269                 // when no blog found
5270                 if ( ($blogName == '') && !is_object($blog) )
5271                 {
5272                         return 0;
5273                 }
5274
5275                 // explicit blog selection
5276                 if ($blogName != '')
5277                 {
5278                         $blogid = getBlogIDFromName($blogName);
5279                 }
5280
5281                 if (($blogName == '') || !$manager->existsBlogID($blogid))
5282                 {
5283                         // use current blog
5284                         $blogid = $blog->getID();
5285                 }
5286                 return $member->teamRights($blogid);
5287         }
5288
5289         /**
5290          * AdminActions::ifAdmin()
5291          * Checks if a member is admin of a blog
5292          *
5293          * @param       string  $blogName       name of weblog
5294          * @return      boolean
5295          */
5296         private function ifAdmin($blogName = '')
5297         {
5298                 global $blog, $member, $manager;
5299
5300                 // when no blog found
5301                 if (($blogName == '') && (!is_object($blog)))
5302                 {
5303                         return 0;
5304                 }
5305
5306                 // explicit blog selection
5307                 if ($blogName != '')
5308                 {
5309                         $blogid = getBlogIDFromName($blogName);
5310                 }
5311
5312                 if (($blogName == '') || !$manager->existsBlogID($blogid))
5313                 {
5314                         // use current blog
5315                         $blogid = $blog->getID();
5316                 }
5317
5318                 return $member->isBlogAdmin($blogid);
5319         }
5320
5321         /**
5322          * AdminActions::ifAddresscange()
5323          * Check e-Mail address is changed
5324          *
5325          * @param       void
5326          * @return      boolean
5327          */
5328         private function ifAddresscange()
5329         {
5330                 $key = $this->objAdmin->sessionVar("{$CONF['CookiePrefix']}ackey");
5331                 if ( !$key )
5332                 {
5333                         return FALSE;
5334                 }
5335                 $info = MEMBER::getActivationInfo($key);
5336                 if ( !$info )
5337                 {
5338                         return FALSE;
5339                 }
5340                 $mem  = MEMBER::createFromId($info->vmember);
5341                 if ( !$mem )
5342                 {
5343                         return FALSE;
5344                 }
5345                 if ( $info->vtype == 'addresschange' )
5346                 {
5347                         return TRUE;
5348                 }
5349                 return FALSE;
5350         }
5351
5352         /**
5353          * AdminActions::templateEditRow()
5354          * Template edit box
5355          *
5356          * @param       array   $template
5357          * @param       string  $desc
5358          * @param       string  $name
5359          * @param       string  $help
5360          * @param       integer $tabindex
5361          * @param       boolean $big
5362          * @param       array   $tmplt
5363          * @return      void
5364          */
5365         private function templateEditRow(&$template, $desc, $name, $help = '', $tabindex = 0, $big = 0, $tplt = '')
5366         {
5367                 static $count = 1;
5368
5369                 if ( !array_key_exists($name, $template) )
5370                 {
5371                         $template[$name] = '';
5372                 }
5373
5374                 $tmplt = array();
5375                 $base  = array();
5376
5377                 if ( $tplt )
5378                 {
5379                         $tmplt = skinableTEMPLATE::read($tplt);
5380                 }
5381
5382                 $data = array(
5383                         'description'   => $desc,
5384                         'help'                  => empty($help) ? '' : helpHtml('template' . $help),
5385                         'count'                 => $count,
5386                         'name'                  => $name,
5387                         'tabindex'              => $tabindex,
5388                         'rows'                  => $big ? 10 : 5,
5389                 );
5390
5391                 if ( !array_key_exists('TEMPLATE_EDIT_ROW_HEAD', $tmplt) || empty($tmplt['TEMPLATE_EDIT_ROW_HEAD']) )
5392                 {
5393                         $base['head'] = "</tr>"
5394                                       . "<tr>\n"
5395                                       . "<td><%description%><%help%></td>\n"
5396                                       . "<td id=\"td<%count%>\">\n"
5397                                       . "<textarea class=\"templateedit\" name=\"<%name%>\" tabindex=\"<%tabindex%>\" cols=\"50\" rows=\"<%rows%>\" id=\"textarea<%count%>\">\n";
5398                 }
5399                 else
5400                 {
5401                         $base['head'] = $tmplt['TEMPLATE_EDIT_ROW_HEAD'];
5402                 }
5403
5404                 if ( !array_key_exists('TEMPLATE_EDIT_ROW_TAIL', $tmplt) || empty($tmplt['TEMPLATE_EDIT_ROW_TAIL']) )
5405                 {
5406                         $base['tail'] = "</textarea>\n"
5407                                       . "</td>\n";
5408                 }
5409                 else
5410                 {
5411                         $base['tail'] = $tmplt['TEMPLATE_EDIT_ROW_TAIL'];
5412                 }
5413
5414                 echo TEMPLATE::fill($base['head'], $data);
5415                 echo ENTITY::hsc($template[$name]);
5416                 echo TEMPLATE::fill($base['tail'], $data);
5417
5418                 $count++;
5419
5420                 return;
5421         }
5422
5423         /**
5424          * AdminActions::customHelp()
5425          * shows a link to custom help file
5426          *
5427          * @param       string  $id
5428          * @param       string  $tplName
5429          * @param       string  $url
5430          * @param       string  $iconURL
5431          * @param       string  $alt
5432          * @param       string  $title
5433          * @param       $onclick
5434          *
5435          */
5436         private function customHelp($id, $tplName = '', $url = '', $iconURL = '', $alt = '', $title = '', $onclick = '')
5437         {
5438                 echo self::customHelpHtml($id, $tplName, $url, $iconURL, $alt, $title, $onclick);
5439         }
5440
5441         /**
5442          * AdminActions::customHelp()
5443          * shows a link to custom help file
5444          *
5445          * @param       string  $id
5446          * @param       string  $tplName
5447          * @param       string  $url
5448          * @param       string  $iconURL
5449          * @param       string  $alt
5450          * @param       string  $title
5451          * @param       $onclick
5452          *
5453          */
5454         static function customHelplink($id, $tplName = '', $url = '', $title = '', $onclick = '')
5455         {
5456                 global $CONF;
5457
5458                 $templates = array();
5459
5460                 if ( $tplName )
5461                 {
5462                         $templates = Template::read($tplName);
5463                 }
5464
5465                 if ( !array_key_exists('ADMIN_CUSTOMHELPLINK_ANCHOR', $templates) || empty($templates['ADMIN_CUSTOMHELPLINK_ANCHOR']) )
5466                 {
5467                         $template = "<a href=\"<%helpurl%>#<%helptarget%>\" title=\"<%title%>\" <%onclick%>>\n";
5468                 }
5469                 else
5470                 {
5471                         $template = $templates['ADMIN_CUSTOMHELPLINK_ANCHOR'];
5472                 }
5473
5474                 if ( empty($url) )
5475                 {
5476                         $url = $CONF['AdminURL'] . 'documentation/customHelp.html';
5477                 }
5478
5479                 if ( empty($onclick) )
5480                 {
5481                         $onclick = 'onclick="if (event &amp;&amp; event.preventDefault) event.preventDefault(); return help(this.href);"';
5482                 }
5483                 elseif ( preg_match('#^onclick#', $onclick) )
5484                 {
5485                         $onclick = $onclick;
5486                 }
5487                 else
5488                 {
5489                         $onclick = 'onclick="' . $onclick . '"';
5490                 }
5491
5492                 $data = array(
5493                         'helpurl'               => $url,
5494                         'helptarget'    => $id,
5495                         'onclick'               => $onclick,
5496                         'title'                 => (isset($title) && !empty($title)) ? $title : _HELP_TT,
5497                 );
5498                 return Template::fill($template, $data);
5499         }
5500
5501         /**
5502          * AdminActions::customHelpHtml()
5503          *
5504          * @param       string  $id
5505          * @param       string  $tplName
5506          * @param       string  $url
5507          * @param       string  $iconURL
5508          * @param       string  $alt
5509          * @param       string  $title
5510          * @param       string  $onclick
5511          * @return      string  anchor element with help uri
5512          */
5513         private function customHelpHtml($id, $tplName = '', $url = '', $iconURL = '', $alt = '', $title = '', $onclick = '')
5514         {
5515                 global $CONF;
5516
5517                 $templates = array();
5518
5519                 if ( $tplName )
5520                 {
5521                         $templates = Template::read($tplName);
5522                 }
5523                 if ( !array_key_exists('ADMIN_CUSTOMHELPLINK_ICON', $templates) || !empty($templates['ADMIN_CUSTOMHELPLINK_ICON']) )
5524                 {
5525                         $template = "<img src=\"<%iconurl%>\" <%width%><%height%>alt=\"<%alt%>\" title=\"<%title%>\" /></a>\n";
5526                 }
5527                 else
5528                 {
5529                         $template = $templates['ADMIN_CUSTOMHELPLINK_ICON'];
5530                 }
5531
5532                 if ( empty($iconURL) )
5533                 {
5534                         $iconURL = $CONF['AdminURL'] . 'documentation/icon-help.gif';
5535                 }
5536
5537                 if ( function_exists('getimagesize') )
5538                 {
5539                         $size   = getimagesize($iconURL);
5540                         $width  = 'width="'  . $size[0] . '" ';
5541                         $height = 'height="' . $size[1] . '" ';
5542                 }
5543
5544                 $data = array(
5545                         'iconurl'       => $iconURL,
5546                         'width'         => $width,
5547                         'height'        => $height,
5548                         'alt'           => (isset($alt) && !empty($alt))         ? $alt   : _HELP_TT,
5549                         'title'         => (isset($title) && !empty($title)) ? $title : _HELP_TT,
5550                 );
5551
5552                 $icon = Template::fill($template, $data);
5553                 $help = self::customHelplink($id, $tplName, $url, $title, $onclick);
5554
5555                 return $help . $icon;
5556         }
5557
5558         /**
5559          * AdminActions::input_yesno
5560          *
5561          * @param               $name
5562          * @param               $checkedval
5563          * @param               $tabindex
5564          * @param               $value1
5565          * @param               $value2
5566          * @param               $yesval
5567          * @param               $noval
5568          * @param               $isAdmin
5569          * @param               $templateName
5570          * @param               $showlist
5571          */
5572         private function input_yesno($name,
5573                                                                 $checkedval,
5574                                                                 $tabindex        = 0,
5575                                                                 $value1    = 1,
5576                                                                 $value2    = 0,
5577                                                                 $yesval    = _YES,
5578                                                                 $noval          = _NO,
5579                                                                 $isAdmin          = 0,
5580                                                                 $templateName = '',
5581                                                                 $showlist        = false)
5582         {
5583                 $templates = array();
5584                 if ( $templateName )
5585                 {
5586                         $templates = Template::read($templateName);
5587                 }
5588
5589                 if ( $name == 'admin' )
5590                 {
5591                         if ( !array_key_exists('INPUTYESNO_TEMPLATE_ADMIN', $templates) || empty($templates['INPUTYESNO_TEMPLATE_ADMIN']) )
5592                         {
5593                                 $template = '<input onclick="selectCanLogin(true);" type="radio" name="<%name%>" value="<%yesval%>" <%yescheckedval%> id="<%yesid%>" />' . "\n"
5594                                           . '<label for="<%yesid%>"><%yesvaltext%></label>' . "\n"
5595                                           . '<input onclick="selectCanLogin(false);" type="radio" name="<%name%>" value="<%noval%>" <%nocheckedval%> id="<%noid%>"<%disabled%> />' . "\n"
5596                                           . '<label for="<%noid%>"><%novaltext%></label>' . "\n";
5597                         }
5598                         else
5599                         {
5600                                 $template = $templates['INPUTYESNO_TEMPLATE_ADMIN'];
5601                         }
5602                 }
5603                 else
5604                 {
5605                         if ( array_key_exists('INPUTYESNO_TEMPLATE_NORMAL', $templates) && !empty($templates['INPUTYESNO_TEMPLATE_NORMAL']) )
5606                         {
5607                                 $template = $templates['INPUTYESNO_TEMPLATE_NORMAL'];
5608                         }
5609                         if ( $showlist )
5610                         {
5611                                 if ( array_key_exists('SHOWLIST_LISTPLUG_TABLE_PLGOPT_OYESNO', $templates) && !empty($templates['SHOWLIST_LISTPLUG_TABLE_PLGOPT_OYESNO']) )
5612                                 {
5613                                         $template = $templates['SHOWLIST_LISTPLUG_TABLE_PLGOPT_OYESNO'];
5614                                 }
5615                         }
5616                         if ( !isset($template) )
5617                         {
5618                                 $template = '<input type="radio" name="<%name%>" value="<%yesval%>" <%yescheckedval%> id="<%yesid%>" />' . "\n"
5619                                           . '<label for="<%yesid%>"><%yesvaltext%></label>' . "\n"
5620                                           . '<input type="radio" name="<%name%>" value="<%noval%>" <%nocheckedval%> id="<%noid%>"<%disabled%> />' . "\n"
5621                                           . '<label for="<%noid%>"><%novaltext%></label>' . "\n";
5622                         }
5623                 }
5624
5625                 //echo $template;
5626                 $id             = Entity::hsc($name);
5627                 $id             = str_replace('[', '-', $id);
5628                 $id             = str_replace(']', '-', $id);
5629                 $id1    = $id . Entity::hsc($value1);
5630                 $id2    = $id . Entity::hsc($value2);
5631                 $dat = array(
5632                         'name'                  => Entity::hsc($name),
5633                         'yesval'                => Entity::hsc($value1),
5634                         'noval'                 => Entity::hsc($value2),
5635                         'yesid'                 => $id1,
5636                         'noid'                  => $id2,
5637                         'yesvaltext'    => $yesval,
5638                         'novaltext'             => $noval,
5639                         'yescheckedval' => ($checkedval == $value1) ? ' checked="checked" tabindex="' . $tabindex . '"': '',
5640                         'nocheckedval'  => ($checkedval != $value1) ? ' checked="checked" tabindex="' . $tabindex . '"': '',
5641                         'disabled'              => ($isAdmin && $name == 'canlogin') ? ' disabled="disabled"' : '',
5642                 );
5643
5644                 if ( $showlist )
5645                 {
5646                         return Template::fill($template, $dat);
5647                 }
5648                 else
5649                 {
5650                         echo Template::fill($template, $dat);
5651                 }
5652                 return;
5653         }
5654
5655         /**
5656          * AdminActions::existsNewPlugin()
5657          * Check exists new plugin
5658          *
5659          * @param       void
5660          * @return      boolean exists or not
5661          */
5662         private function existsNewPlugin()
5663         {
5664                 global $DIR_PLUGINS;
5665
5666                 $candidates = array();
5667                 $files = scandir($DIR_PLUGINS);
5668
5669                 foreach ( $files as $file )
5670                 {
5671                         if ( preg_match("#^NP_(.*)\.php$#", $file, $matches) )
5672                         {
5673                                 $name = $matches[1];
5674                                 $query = "SELECT * FROM %s WHERE pfile='%s';";
5675                                 $query = sprintf($query, sql_table('plugin'), sql_real_escape_string("{NP_{$name}"));
5676                                 $res  = sql_query($query);
5677
5678                                 if ( sql_num_rows($res) == 0 )
5679                                 {
5680                                         $candidates[] = $name;
5681                                 }
5682                         }
5683                         continue;
5684                 }
5685                 $this->newPlugCandidates = $candidates;
5686                 return (count($candidates) > 0);
5687         }
5688 }