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                 'languageselectoptions',
  94                 'listplugplugoptionrow',
  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                                         'editmember',
 553                                         'languageselectoptions',
 554                                         'adminskinselectoptions',
 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                                         'languageselectoptions',
 674                                         'configsettingsyesno',
 675                                         'outputspecialdirs',
 676                                         'jstoolbaroptions',
 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          * Parse skinvar languageselectoptions
3959          */
3960         function parse_languageselectoptions()
3961         {
3962                 $locales = i18n::get_available_locale_list();
3963                 $memid = intRequestVar('memberid');
3964
3965                 if ($memid)
3966                 {
3967                         $mem = MEMBER::createFromID($memid);
3968                         if ( !$mem->getLocale() || !in_array($mem->getLocale(), $locales) )
3969                         {
3970                                 echo "<option value=\"\" selected=\"selected\">" . ENTITY::hsc(_MEMBERS_USESITELANG) . "</option>\n";
3971                         }
3972                         else
3973                         {
3974                                 echo "<option value=\"\">" . ENTITY::hsc(_MEMBERS_USESITELANG) . "</option>\n";
3975                         }
3976                 }
3977                 else
3978                 {
3979                         if ( !i18n::get_current_locale() || !in_array(i18n::get_current_locale(), $locales) )
3980                         {
3981                                 echo "<option value=\"\" selected=\"selected\">en_Latn_US</option>\n";
3982                         }
3983                 }
3984                 foreach ( $locales as $locale )
3985                 {
3986                         if ($memid)
3987                         {
3988                                 if ( $locale == $mem->getLocale() )
3989                                 {
3990                                         echo "<option value=\"{$locale}\" selected=\"selected\">{$locale}</option>\n";
3991                                 }
3992                                 else
3993                                 {
3994                                         echo "<option value=\"{$locale}\">{$locale}</option>\n";
3995                                 }
3996                         }
3997                         else
3998                         {
3999                                 if ( $locale == i18n::get_current_locale() )
4000                                 {
4001                                         echo "<option value=\"{$locale}\" selected=\"selected\">{$locale}</option>\n";
4002                                 }
4003                                 else
4004                                 {
4005                                         echo "<option value=\"{$locale}\">{$locale}</option>\n";
4006                                 }
4007                         }
4008                 }
4009                 return;
4010         }
4011
4012         /**
4013          * AdminActions::parse_localeselectoptions()
4014          * Parse skinvar localeselectoptions
4015          *
4016          * @param       void
4017          * @return      void
4018          */
4019         public function parse_localeselectoptions()
4020         {
4021                 $locales = i18n::get_available_locale_list();
4022
4023                 $memid = intRequestVar('memberid');
4024                 if ( $memid )
4025                 {
4026                         $mem = MEMBER::createFromID($memid);
4027                         if ( !$mem->getLocale() || !in_array($mem->getLocale(), $locales) )
4028                         {
4029                                 echo "<option value=\"\" selected=\"selected\">" . Entity::hsc(_MEMBERS_USESITELANG) . "</option>\n";
4030                         }
4031                         else
4032                         {
4033                                 echo "<option value=\"\">" . Entity::hsc(_MEMBERS_USESITELANG) . "</option>\n";
4034                         }
4035                 }
4036                 else
4037                 {
4038                         if ( !i18n::get_current_locale() || !in_array(i18n::get_current_locale(), $locales) )
4039                         {
4040                                 echo "<option value=\"\" selected=\"selected\">en_Latn_US</option>\n";
4041                         }
4042                 }
4043                 foreach ( $locales as $locale )
4044                 {
4045                         if ($memid)
4046                         {
4047                                 if ( $locale == $mem->getLocale() )
4048                                 {
4049                                         echo "<option value=\"{$locale}\" selected=\"selected\">{$locale}</option>\n";
4050                                 }
4051                                 else
4052                                 {
4053                                         echo "<option value=\"{$locale}\">{$locale}</option>\n";
4054                                 }
4055                         }
4056                         else
4057                         {
4058                                 if ( $locale == i18n::get_current_locale() )
4059                                 {
4060                                         echo "<option value=\"{$locale}\" selected=\"selected\">{$locale}</option>\n";
4061                                 }
4062                                 else
4063                                 {
4064                                         echo "<option value=\"{$locale}\">{$locale}</option>\n";
4065                                 }
4066                         }
4067                 }
4068                 return;
4069         }
4070
4071         /**
4072          * AdminActions::parse_listplugplugoptionrow()
4073          * Parse templatevar listplugplugoptionrow
4074          *
4075          * @param       string  $templateName   name of template
4076          * @return      void
4077          */
4078         public function parse_listplugplugoptionrow($templateName = '')
4079         {
4080                 echo listplug_plugOptionRow(Admin::$aOptions, $templateName);
4081                 return;
4082         }
4083
4084         /**
4085          * AdminActions::parse_mediadirwarning()
4086          * Parse skinvar mediadirwarning
4087          *
4088          * @param       void
4089          * @return      void
4090          */
4091         public function parse_mediadirwarning()
4092         {
4093                 global $DIR_MEDIA;
4094                 if ( !is_dir($DIR_MEDIA) )
4095                 {
4096                         echo "<br /><b>" . _WARNING_NOTADIR . "</b>\n";
4097                 }
4098                 if ( !is_readable($DIR_MEDIA) )
4099                 {
4100                         echo "<br /><b>" . _WARNING_NOTREADABLE . "</b>\n";
4101                 }
4102                 if ( !is_writeable($DIR_MEDIA) )
4103                 {
4104                         echo "<br /><b>" . _WARNING_NOTWRITABLE . "</b>\n";
4105                 }
4106                 return;
4107         }
4108
4109         /**
4110          * AdminActions::parse_movedistselect()
4111          * Parse skinvar movedistselect
4112          */
4113         public function parse_movedistselect()
4114         {
4115                 $actionType = requestVar('action');
4116                 switch ( $actionType )
4117                 {
4118                         case 'batchitem':
4119                                 Admin::selectBlogCategory('destcatid');
4120                                 break;
4121                         case 'batchcategory':
4122                                 Admin::selectBlog('destblogid');
4123                                 break;
4124                         default:
4125                                 if ( $this->skintype == 'itemmove' )
4126                                 {
4127                                         $query  = "SELECT icat as result FROM %s WHERE inumber=%d;";
4128                                         $query = sprintf($query, sql_table('item'), intRequestVar('itemid'));
4129                                         $catid  = quickQuery(sprintf($query, intRequestVar('itemid')));
4130                                         Admin::selectBlogCategory('catid', $catid, 10, 1);
4131                                 }
4132                                 break;
4133                 }
4134                 return;
4135         }
4136
4137         /**
4138          * AdminActions::parse_moveitemid()
4139          * Parse skinvar moveitemid
4140          *
4141          * @param       void
4142          * @return      void
4143          */
4144         public function parse_moveitemid()
4145         {
4146                 echo intRequestVar('itemid');
4147                 return;
4148         }
4149
4150         /**
4151          * AdminActions::parse_newestcompare()
4152          * Parse skinvar newestcompare
4153          *
4154          * @param       void
4155          * @return      void
4156          */
4157         public function parse_newestcompare()
4158         {
4159                 global $nucleus;
4160
4161                 $newestVersion  = getLatestVersion();
4162                 $newestCompare  = str_replace('/', '.', $newestVersion);
4163                 $currentVersion = str_replace(array('/', 'v'), array('.', ''), $nucleus['version']);
4164
4165                 if ( $newestVersion && version_compare($newestCompare, $currentVersion, '>') )
4166                 {
4167                         echo '<br /><a style="color:red" href="http://nucleuscms.org/upgrade.php" title="' . _ADMIN_SYSTEMOVERVIEW_LATESTVERSION_TITLE . '">';
4168                         echo _ADMIN_SYSTEMOVERVIEW_LATESTVERSION_TEXT . $newestVersion . '</a>';
4169                 }
4170                 return;
4171         }
4172
4173         /**
4174          * AdminActions::parse_newmemberselect()
4175          * Parse skinvar newmemberselect
4176          *
4177          * @param       string  $templateName   name of template to use
4178          * @return      void
4179          */
4180         public function parse_newmemberselect($templateName = '')
4181         {
4182                 $blogid = intRequestVar('blogid');
4183
4184                 $query = "SELECT tmember FROM %s WHERE tblog=%d;";
4185                 $query = sprintf($query, sql_table('team'), (integer) $blogid);
4186                 $res = sql_query($query);
4187
4188                 $tmem = array();
4189                 while ( $tmember = sql_fetch_object($res) )
4190                 {
4191                         $tmem[] = intval($tmember->tmember);
4192                 }
4193
4194                 $query  = "SELECT mname as text, mnumber as value FROM %s WHERE mnumber NOT IN (%s);";
4195                 $query = sprintf($query, sql_table('member'), implode(', ', $tmem));
4196
4197                 $template['name']        = 'memberid';
4198                 $template['tabindex'] = 10000;
4199                 Showlist($query, 'select', $template, $templateName);
4200                 return;
4201         }
4202
4203         /**
4204          * AdminActions::parse_newpluginlist()
4205          * Parse skinvar newpluginlist
4206          *
4207          * @param       void
4208          * @return      void
4209          */
4210         public function parse_newpluginlist()
4211         {
4212                 $candidates = $this->newPlugCandidates;
4213                 foreach ( $candidates as $name )
4214                 {
4215                         echo '<option value="NP_' . $name . '">' . Entity::hsc($name) . "</option>\n";
4216                 }
4217                 return;
4218         }
4219
4220         /**
4221          * AdminActions::parse_outputspecialdirs()
4222          * Parse skinvar outputspecialdirs
4223          *
4224          * @param       string  $type   type of setting for directory
4225          * @return      void
4226          */
4227         public function parse_outputspecialdirs($type)
4228         {
4229                 global $DIR_MEDIA, $DIR_NUCLEUS;
4230
4231                 switch ( $type )
4232                 {
4233                         case 'nucleusdir':
4234                                 echo Entity::hsc($DIR_NUCLEUS);
4235                                 break;
4236                         case 'mediadir':
4237                                 echo Entity::hsc($DIR_MEDIA);
4238                                 break;
4239                 }
4240                 return;
4241         }
4242
4243         /**
4244          * AdminActions::parse_passrequestvars()
4245          * Parse skinvar passrequestvars
4246          *
4247          * @param       void
4248          * @return      void
4249          */
4250         public function parse_passrequestvars()
4251         {
4252                 $passvar   = Admin::getAdminpassvar();
4253                 $oldaction = postVar('oldaction');
4254
4255                 if ( ($oldaction != 'logout')
4256                   && ($oldaction != 'login')
4257                   && $passvar
4258                   && !postVar('customaction') )
4259                 {
4260                         passRequestVars();
4261                 }
4262                 return;
4263         }
4264
4265         /**
4266          * AdminActions::parse_pluginextras()
4267          * Parse skinvar pluginextras
4268          *
4269          * @param       string  $type   type of plugin context
4270          * @return      void
4271          */
4272         public function parse_pluginextras($type = 'global')
4273         {
4274                 global $manager;
4275                 switch ( $type )
4276                 {
4277                         case 'member':
4278                                 $id  = intRequestVar('memberid');
4279                                 $mem = MEMBER::createFromID($id);
4280                                 $manager->notify('MemberSettingsFormExtras', array('member' => &$mem));
4281                                 break;
4282                         case 'blog':
4283                                 $id  = intRequestVar('blogid');
4284                                 $blg = $manager->getBlog($id);
4285                                 $manager->notify('BlogSettingsFormExtras', array('member' => &$blg));
4286                                 break;
4287                         default:
4288                                 $manager->notify(
4289                                         'GeneralSettingsFormExtras',
4290                                         array(
4291                                         )
4292                                 );
4293                                 break;
4294                 }
4295                 return;
4296         }
4297
4298         /**
4299          * AdminActions::parse_pluginhelp()
4300          * Parse skinvar pluginhelp
4301          *
4302          * @param       void
4303          * @return      void
4304          */
4305         public function parse_pluginhelp()
4306         {
4307                 global $manager, $DIR_PLUGINS;
4308
4309                 $plugid = intGetVar('plugid');
4310                 $plugName =  getPluginNameFromPid($plugid);
4311                 $plug =& $manager->getPlugin($plugName);
4312
4313                 if ( $plug->supportsFeature('HelpPage') > 0 )
4314                 {
4315                         $helpfile = $DIR_PLUGINS . $plug->getShortName() . '/help.';
4316                         if ( @file_exists($helpfile . 'php') )
4317                         {
4318                                 @include($helpfile . 'php');
4319                                 return;
4320                         }
4321                         elseif ( @file_exists($helpfile . 'html') )
4322                         {
4323                                 @include($helpfile . 'html');
4324                                 return;
4325                         }
4326                 }
4327                 echo '<p>' . _ERROR . ': ' . _ERROR_PLUGNOHELPFILE . "</p>\n";
4328                 echo '<p><a href="index.php?action=pluginlist">(' . _BACK . ")</a></p>\n";
4329                 return;
4330         }
4331
4332         /**
4333          * AdminActions::parse_pluginlistlist()
4334          * Parse skinvar pluginlistlist
4335          *
4336          * @param       string  $templateName   name of template to use
4337          * @return      void
4338          */
4339         public function parse_pluginlistlist($templateName = '')
4340         {
4341                 $query = "SELECT * FROM %s ORDER BY porder ASC;";
4342                 $query = sprintf($query, sql_table('plugin'));
4343
4344                 $template['content']  = 'pluginlist';
4345                 $template['tabindex'] = 10;
4346
4347                 Showlist($query, 'table', $template, $templateName);
4348
4349                 return;
4350         }
4351
4352         /**
4353          * AdminActions::parse_pluginoptions()
4354          * Parse skinvar pluginoptions
4355          *
4356          * @param       string  $type   type of plugin option
4357          * @return      void
4358          */
4359         public function parse_pluginoptions($type = 'global')
4360         {
4361                 global $itemid;
4362
4363                 switch ( $type )
4364                 {
4365                         case 'member':
4366                                 $id = intRequestVar('memberid');
4367                                 break;
4368                         case 'blog':
4369                                 $id = intRequestVar('blogid');
4370                                 break;
4371                         case 'category':
4372                                 $id = intRequestVar('catid');
4373                                 break;
4374                         case 'item':
4375                                 $id = $itemid;
4376                                 break;
4377                 }
4378                 Admin::insertPluginOptions($type, $id);
4379                 return;
4380         }
4381
4382         /**
4383          * AdminActions::parse_qmenuaddselect()
4384          * Parse skinvar qmanuaddselect
4385          *
4386          * @param       string  $templateName   name of template to use
4387          * @return      void
4388          */
4389         public function parse_qmenuaddselect($templateName = '')
4390         {
4391                 global $member;
4392                 $showAll = requestVar('showall');
4393                 if ( $member->isAdmin() && ($showAll == 'yes') )
4394                 {
4395                         // Super-Admins have access to all blogs! (no add item support though)
4396                         $query =  'SELECT bnumber as value, bname as text'
4397                                . ' FROM ' . sql_table('blog')
4398                                . ' ORDER BY bname';
4399                 }
4400                 else
4401                 {
4402                         $query =  'SELECT bnumber as value, bname as text'
4403                                . ' FROM ' . sql_table('blog') . ', ' . sql_table('team')
4404                                . ' WHERE tblog=bnumber and tmember=' . $member->getID()
4405                                . ' ORDER BY bname';
4406                 }
4407
4408                 $template['name']               = 'blogid';
4409                 $template['tabindex']   = 15000;
4410                 $template['extra']              = _QMENU_ADD_SELECT;
4411                 $template['selected']   = -1;
4412                 $template['shorten']    = 10;
4413                 $template['shortenel']  = '';
4414                 $template['javascript'] = 'onchange="return form.submit()"';
4415
4416                 Showlist($query, 'select', $template, $templateName);
4417
4418                 return;
4419         }
4420
4421         /**
4422          * AdminActions::parse_quickmenu()
4423          * Parse skinvar quickmenu
4424          *
4425          * @param       string  $templateName   name of template to use
4426          * @return      void
4427          */
4428         public function parse_quickmenu($templateName = '')
4429         {
4430                 global $manager;
4431                 $templates = array();
4432                 $template  = array();
4433                 if ( !empty($templateName) )
4434                 {
4435                         $templates = Template::read($templateName);
4436                 }
4437                 $pluginExtras = array();
4438                 $manager->notify(
4439                         'QuickMenu',
4440                         array(
4441                                 'options' => &$pluginExtras
4442                         )
4443                 );
4444                 if ( count($pluginExtras) > 0 )
4445                 {
4446                         if ( !array_key_exists('PLUGIN_QUICKMENU_TITLE', $templates) || empty($templates['PLUGIN_QUICKMENU_TITLE']) )
4447                         {
4448                                 $template['title'] = "<h2><%text(_QMENU_PLUGINS)%></h2>\n";
4449                         }
4450                         else
4451                         {
4452                                 $template['title'] = $templates['PLUGIN_QUICKMENU_TITLE'];
4453                         }
4454                         if ( !array_key_exists('PLUGIN_QUICKMENU_HEAD', $templates) || empty($templates['PLUGIN_QUICKMENU_HEAD']) )
4455                         {
4456                                 $template['head'] = "<ul>\n";
4457                         }
4458                         else
4459                         {
4460                                 $template['head'] = $templates['PLUGIN_QUICKMENU_HEAD'];
4461                         }
4462                         if ( !array_key_exists('PLUGIN_QUICKMENU_BODY', $templates) && empty($templates['PLUGIN_QUICKMENU_BODY']) )
4463                         {
4464                                 $template['body'] = "<li><a href=\"<%plugadminurl%>\" title=\"<%plugadmintooltip%>\"><%plugadmintitle%></a></li>\n";
4465                         }
4466                         else
4467                         {
4468                                 $template['body'] = $templates['PLUGIN_QUICKMENU_BODY'];
4469                         }
4470                         if ( !array_key_exists('PLUGIN_QUICKMENU_FOOT', $templates) || empty($templates['PLUGIN_QUICKMENU_FOOT']) )
4471                         {
4472                                 $template['foot'] = "</ul>\n";
4473                         }
4474                         else
4475                         {
4476                                 $template['foot'] = $templates['PLUGIN_QUICKMENU_FOOT'];
4477                         }
4478
4479                         $handler = new Actions($this->skintype);
4480                         $parser = new PARSER($handler);
4481
4482                         $parser->parse($template['title']);
4483                         echo $template['head'];
4484                         foreach ( $pluginExtras as $aInfo )
4485                         {
4486                                 $data = array(
4487                                         'plugadminurl'          => Entity::hsc($aInfo['url']),
4488                                         'plugadmintooltip'      => Entity::hsc($aInfo['tooltip']),
4489                                         'plugadmintitle'        => Entity::hsc($aInfo['title']),
4490                                 );
4491                                 echo Template::fill($template['body'], $data);
4492                         }
4493                         echo $template['foot'];
4494                 }
4495                 return;
4496         }
4497
4498         /**
4499          * AdminActions::parse_requestblogid()
4500          * Parse skinvar requestblogid
4501          *
4502          * @param       void
4503          * @return      void
4504          */
4505         public function parse_requestblogid()
4506         {
4507                 echo intRequestVar('blogid');
4508                 return;
4509         }
4510
4511         /**
4512          * AdminActions::parse_requestiprange()
4513          * Parse skinvar requestiprange
4514          *
4515          * @param       void
4516          * @return      void
4517          */
4518         public function parse_requestiprange()
4519         {
4520                 if ( requestVar('iprange') )
4521                 {
4522                         echo Entity::hsc(requestVar('iprange'));
4523                 }
4524                 elseif ( requestVar('ip') )
4525                 {
4526                         echo Entity::hsc(requestVar('ip'));
4527                 }
4528                 return;
4529         }
4530
4531         /**
4532          * AdminActions::parse_selectlocaladminskinfiles()
4533          * Parse skinvar selectlocaladminskinfiles
4534          *
4535          * @param       void
4536          * @return      void
4537          */
4538         public function parse_selectlocaladminskinfiles()
4539         {
4540                 global $DIR_SKINS, $manager;
4541
4542                 $adminskindir = $DIR_SKINS . 'admin/';
4543                 $candidates = SkinImport::searchForCandidates($adminskindir);
4544
4545                 foreach ( $candidates as $skinname => $skinfile )
4546                 {
4547                         $html = Entity::hsc($skinfile);
4548                         echo '<option value="' . $html . '">' . $skinname . "</option>\n";
4549                 }
4550
4551                 return;
4552         }
4553
4554         /**
4555          * AdminActions::parse_selectlocalskinfiles()
4556          * Parse skinvar selectlocalskinfiles
4557          *
4558          * @param       void
4559          * @return      void
4560          */
4561         public function parse_selectlocalskinfiles()
4562         {
4563                 global $DIR_SKINS;
4564
4565                 $candidates = SkinImport::searchForCandidates($DIR_SKINS);
4566
4567                 foreach ( $candidates as $skinname => $skinfile )
4568                 {
4569                         $html = Entity::hsc($skinfile);
4570                         echo '<option value="' . $html . '">' . $skinname . "</option>\n";
4571                 }
4572
4573                 return;
4574         }
4575
4576         /**
4577          * AdminActions::parse_skineditallowedlist()
4578          * Parse skinvar skineditallowedlist
4579          *
4580          * @param       string  $type                   type of skin
4581          * @param       string  $templateName   name of template
4582          * @return      void
4583          */
4584         public function parse_skineditallowedlist($type, $templateName = '')
4585         {
4586                 switch ( $type )
4587                 {
4588                         case 'blog':
4589                                 $query = "SELECT bshortname, bname FROM %s;";
4590                                 $show  = array(
4591                                         'content' => 'shortblognames'
4592                                 );
4593                                 $query = sprintf($query, sql_table('blog'));
4594                                 Showlist($query, 'table', $show, $templateName);
4595                                 break;
4596                         case 'template':
4597                                 $query = "SELECT tdname as name, tddesc as description FROM %s WHERE tdname NOT LIKE 'admin/%%';";
4598                                 $show  = array(
4599                                         'content' => 'shortnames'
4600                                 );
4601                                 $query = sprintf($query, sql_table('template_desc'));
4602                                 Showlist($query, 'table', $show, $templateName);
4603                                 break;
4604                 }
4605                 return;
4606         }
4607
4608         /**
4609          * AdminActions::parse_skinielist()
4610          * Parse skinvar skinielist
4611          *
4612          * @param       string  $type                   type of skin
4613          * @param       string  $templateName   name of template to use
4614          * @return      void
4615          */
4616         public function parse_skinielist($type, $templateName = '')
4617         {
4618                 $templates = array();
4619                 if ( $templateName )
4620                 {
4621                         $templates = Template::read($templateName);
4622                 }
4623                 if ( array_key_exists('SKINIE_EXPORT_LIST', $templates) && !empty($templates['SKINIE_EXPORT_LIST']) )
4624                 {
4625                         $template = $templates['SKINIE_EXPORT_LIST'];
4626                 }
4627                 else
4628                 {
4629                         $template = "<td>"
4630                                   . "<input type=\"checkbox\" name=\"<%typeid%>\" id=\"<%expid%>\" />\n"
4631                                   . "<label for=\"<%expid%>\"><%expname%></label>\n"
4632                                   . "</td>\n"
4633                                   . "<td><%expdesc%></td>\n"
4634                                   . "</tr>\n"
4635                                   . "<tr>\n";
4636                 }
4637                 switch ( $type )
4638                 {
4639                         case 'skin':
4640                                 $res = sql_query('SELECT * FROM ' . sql_table('skin_desc'));
4641                                 while ( $skinObj = sql_fetch_object($res) )
4642                                 {
4643                                         $data = array(
4644                                                 'typeid'        => 'skin[' . $skinObj->sdnumber . ']',
4645                                                 'expid'         => 'skinexp' . $skinObj->sdnumber,
4646                                                 'expname'       => Entity::hsc($skinObj->sdname),
4647                                                 'expdesc'       => Entity::hsc($skinObj->sddesc),
4648                                         );
4649                                         echo Template::fill($template, $data);
4650                                 }
4651                                 break;
4652                         case 'template':
4653                                 $res = sql_query('SELECT * FROM '.sql_table('template_desc'). " WHERE tdname NOT LIKE 'admin/%%';");
4654                                 while ($templateObj = sql_fetch_object($res)) {
4655                                         $data = array(
4656                                                 'typeid'        => 'template[' . $templateObj->tdnumber . ']',
4657                                                 'expid'         => 'templateexp' . $templateObj->tdnumber,
4658                                                 'expname'       => Entity::hsc($templateObj->tdname),
4659                                                 'expdesc'       => Entity::hsc($templateObj->tddesc),
4660                                         );
4661                                         echo Template::fill($template, $data);
4662                                 }
4663                                 break;
4664                 }
4665                 return;
4666         }
4667
4668         /**
4669          * AdminActions::parse_skinoverview()
4670          * Parse skinvar skinoverview
4671          *
4672          * @param       string  $templateName   name of template to use
4673          * @return      void
4674          */
4675         public function parse_skinoverview($templateName = '')
4676         {
4677                 global $CONF;
4678                 $query = "SELECT * FROM %s WHERE sdname NOT LIKE 'admin/%%';";
4679                 $query = sprintf($query, sql_table('skin_desc'));
4680
4681                 $template['content']  = 'skinlist';
4682                 $template['tabindex'] = 10;
4683
4684                 Showlist($query, 'table', $template, $templateName);
4685                 return;
4686         }
4687
4688         /**
4689          * AdminActions::parse_skintypehelp()
4690          * Check editing skintypehelp
4691          *
4692          * @param       void
4693          * @return      void
4694          */
4695         public function parse_skintypehelp()
4696         {
4697                 $nowSkinType = strtolower(trim(requestVar('type')));
4698
4699                 /* TODO: use Skin class */
4700                 $regularType = array(
4701                         'index',
4702                         'item',
4703                         'archivelist',
4704                         'archive',
4705                         'search',
4706                         'error',
4707                         'member',
4708                         'imagepopup'
4709                 );
4710
4711                 if ( in_array($nowSkinType, $regularType) )
4712                 {
4713                         help('skinpart' . $nowSkinType);
4714                 }
4715                 else
4716                 {
4717                         help('skinpartspecial');
4718                 }
4719                 return;
4720         }
4721
4722         /**
4723          * AdminActions::parse_specialskinlist()
4724          * Parse skinvar specialskinlist
4725          *
4726          * @param       string  $templateName   name of template to use
4727          * @return      void
4728          */
4729         public function parse_specialskinlist($templateName = '')
4730         {
4731                 $templates = array();
4732                 if ( $templateName )
4733                 {
4734                         $templates = Template::read($templateName);
4735                 }
4736
4737                 /* TODO: use Skin class */
4738                 $nType  = array(
4739                         'index',
4740                         'item',
4741                         'error',
4742                         'search',
4743                         'archive',
4744                         'archivelist',
4745                         'imagepopup',
4746                         'member'
4747                 );
4748                 $skinid = intRequestVar('skinid');
4749                 $query  = "SELECT stype FROM %s WHERE stype NOT IN ('%s') AND sdesc = %d;";
4750                 $query = sprintf($query, sql_table('skin'), implode("', '", $nType), $skinid);
4751
4752                 $res    = sql_query($query);
4753                 if ( $res && sql_num_rows($res) > 0 )
4754                 {
4755                         $data = array();
4756                         if ( array_key_exists('SPECIALSKINLIST_HEAD', $templates) && !empty($templates['SPECIALSKINLIST_HEAD']) )
4757                         {
4758                                 $template['head'] = $templates['SPECIALSKINLIST_HEAD'];
4759                         }
4760                         else
4761                         {
4762                                 $template['head'] = "<ul>\n";
4763                         }
4764                         echo Template::fill($template['head'], $data);
4765                         if ( !array_key_exists('SPECIALSKINLIST_BODY', $templates) || empty($templates['SPECIALSKINLIST_BODY']) )
4766                         {
4767                                 $template['body'] = '<li><a tabindex="<%tabindex%>" href="index.php?action=skinedittype&amp;skinid=<%skinid%>'
4768                                                                   . '&amp;type=<%skintype%>"><%skintype%></a> (<a tabindex="<%tabindex%>" href="index.php?'
4769                                                                   . 'action=skinremovetype&amp;skinid=<%skinid%>&amp;type=<%skintype%>">remove</a>)</li>';
4770                         }
4771                         else
4772                         {
4773                                 $template['body'] = $templates['SPECIALSKINLIST_BODY'];
4774                         }
4775
4776                         $tabstart = 75;
4777                         while ( $row = sql_fetch_assoc($res) )
4778                         {
4779                                 $data = array(
4780                                         'tabindex'      => $tabstart++,
4781                                         'skinid'        => $skinid,
4782                                         'skintype'      => Entity::hsc(strtolower($row['stype']))
4783                                 );
4784                                 echo Template::fill($template['body'], $data);
4785                         }
4786                         $data = array();
4787                         if (array_key_exists('SPECIALSKINLIST_FOOT', $templates) && !empty($templates['SPECIALSKINLIST_FOOT']) )
4788                         {
4789                                 $template['foot'] = $templates['SPECIALSKINLIST_FOOT'];
4790                         }
4791                         else
4792                         {
4793                                 $template['foot'] = "</ul>\n";
4794                         }
4795                         echo Template::fill($template['foot'], $data);
4796                         return;
4797                 }
4798         }
4799
4800         /**
4801          * AdminActions::parse_sprinttext()
4802          * Parse sprinttext
4803          *
4804          * @param       string  $which
4805          * @param       string  $val
4806          * @return      void
4807          */
4808         public function parse_sprinttext($which, $val)
4809         {
4810                 if ( !defined($which) )
4811                 {
4812                         $base = $which;
4813                 }
4814                 else
4815                 {
4816                         $base = constant($which);
4817                 }
4818
4819                 if ( preg_match('#[^<|%].*[^%|>]#', $val, $matchies) )
4820                 {
4821                         if ( !preg_match('#[(].*[^)]#', $matchies[0], $args) )
4822                         {
4823                                 $met = 'parse_' . $matchies[0];
4824                         }
4825                         else
4826                         {
4827                                 $arg = trim($args[0], '()');
4828                                 $met = 'parse_' . substr($matchies[0], 0, strpos($matchies[0], '('));
4829                         }
4830
4831                         if ( method_exists($this, $met) )
4832                         {
4833                                 $value = call_user_func(array(&$this, $met), $arg);
4834                         }
4835                 }
4836
4837                 if ( !isset($value) || empty($value) )
4838                 {
4839                         $value = $val;
4840                 }
4841                 echo sprintf($base, $value);
4842                 return;
4843         }
4844
4845         /**
4846          * AdminActions::parse_systemsettings()
4847          * Parse skinvar systemsettings
4848          *
4849          * @param       string  $type                   type of settings for system
4850          * @param       string  $templateName   name of template to use
4851          * @return      void
4852          */
4853         public function parse_systemsettings($type = 'phpinfo', $templateName = '')
4854         {
4855                 global $member, $CONF, $nucleus;
4856
4857                 $member->isAdmin() or Admin::disallow();
4858
4859                 $enable  = _ADMIN_SYSTEMOVERVIEW_ENABLE;
4860                 $disable = _ADMIN_SYSTEMOVERVIEW_DISABLE;
4861
4862                 switch ( $type )
4863                 {
4864                         case 'phpversion':
4865                                 echo phpversion();
4866                                 break;
4867                         case 'sqlserverinfo':
4868                                 echo sql_get_server_info();
4869                                 break;
4870                         case 'sqlclientinfo':
4871                                 echo sql_get_client_info();
4872                                 break;
4873                         case 'magicquotesgpc':
4874                                 echo ini_get('magic_quotes_gpc') ? 'On' : 'Off';
4875                                 break;
4876                         case 'magicquotesruntime':
4877                                 echo ini_get('magic_quotes_runtime') ? 'On' : 'Off';
4878                                 break;
4879                         case 'registerglobals':
4880                                 echo ini_get('register_globals') ? 'On' : 'Off';
4881                                 break;
4882                         case 'gdinfo':
4883                                 $templates = array();
4884                                 if ( $templateName )
4885                                 {
4886                                         $templates = Template::read($templateName);
4887                                 }
4888                                 if ( !array_key_exists('SYSTEMINFO_GDSETTINGS', $templates) || empty($templates['SYSTEMINFO_GDSETTINGS']) )
4889                                 {
4890                                         $template = "<tr>\n"
4891                                                   . "<td><%key%></td>\n"
4892                                                   . "<td><%value%></td>\n"
4893                                                   . "</tr>\n";
4894                                 }
4895                                 else
4896                                 {
4897                                         $template = $templates['SYSTEMINFO_GDSETTINGS'];
4898                                 }
4899
4900                                 $gdinfo = gd_info();
4901
4902                                 foreach ( $gdinfo as $key => $value )
4903                                 {
4904                                         if ( is_bool($value) )
4905                                         {
4906                                                 $value = $value ? $enable : $disable;
4907                                         }
4908                                         else
4909                                         {
4910                                                 $value = Entity::hsc($value);
4911                                         }
4912                                         $data = array(
4913                                                 'key'   => $key,
4914                                                 'value' => $value,
4915                                         );
4916                                         echo Template::fill($template, $data);
4917                                 }
4918                                 break;
4919                         case 'modrewrite':
4920                                 ob_start();
4921                                 phpinfo(INFO_MODULES);
4922                                 $im = ob_get_contents();
4923                                 ob_end_clean();
4924                                 echo ( i18n::strpos($im, 'mod_rewrite') !== FALSE ) ? $enable : $disable;
4925                                 break;
4926                         case 'nucleusversion':
4927                                 echo getNucleusVersion() / 100 . '(' . $nucleus['version'] . ')';
4928                                 break;
4929                         case 'nucleuspatchlevel':
4930                                 echo getNucleusPatchLevel();
4931                                 break;
4932                         case 'confself':
4933                                 echo $CONF['Self'];
4934                                 break;
4935                         case 'confitemurl':
4936                                 echo $CONF['ItemURL'];
4937                                 break;
4938                         case 'alertonheaderssent':
4939                                 echo $CONF['alertOnHeadersSent'] ? $enable : $disable;
4940                                 break;
4941                         case 'nucleuscodename':
4942                                 if ( $nucleus['codename'] != '' )
4943                                 {
4944                                         echo ' &quot;' . $nucleus['codename'] . '&quot;';
4945                                 }
4946                                 break;
4947                         case 'versioncheckurl':
4948                                 echo sprintf(_ADMIN_SYSTEMOVERVIEW_VERSIONCHECK_URL, getNucleusVersion(), getNucleusPatchLevel());
4949                                 break;
4950                 }
4951                 return;
4952         }
4953
4954         /**
4955          * AdminActions::parse_templateoverview()
4956          * Parse skinvar templateoverview
4957          *
4958          * @param       string  $templateName   name of template to use
4959          * @return      void
4960          */
4961         public function parse_templateoverview($templateName = '')
4962         {
4963                 $query  = "SELECT * FROM %s WHERE tdname NOT LIKE 'admin/%%' ORDER BY tdname";
4964                 $query = sprintf($query, sql_table('template_desc'));
4965
4966                 $template['content']  = 'templatelist';
4967                 $template['tabindex'] = 10;
4968
4969                 Showlist($query, 'table', $template, $templateName);
4970
4971                 return;
4972         }
4973
4974         /**
4975          * AdminActions::parse_ticket()
4976          * Parse ticket
4977          *
4978          * @param       void
4979          * @return      void
4980          */
4981         public function parse_ticket()
4982         {
4983                 global $manager;
4984                 $manager->addTicketHidden();
4985                 return;
4986         }
4987
4988         /**
4989          * AdminActions::parse_versioncheckurl()
4990          * Parse skinvar versioncheckurl
4991          *
4992          * @param       void
4993          * @return      void
4994          */
4995         public function parse_versioncheckurl()
4996         {
4997                 echo sprintf(_ADMIN_SYSTEMOVERVIEW_VERSIONCHECK_URL, getNucleusVersion(), getNucleusPatchLevel());
4998                 return;
4999         }
5000
5001         /**
5002          * AdminActions::parse_yrbloglist()
5003          * Parse skinvar yrbloglist
5004          *
5005          * @param       string  $templateName   name of template to use
5006          * @return      void
5007          */
5008         public function parse_yrbloglist($templateName = '')
5009         {
5010                 global $member;
5011                 $showAll = requestVar('showall');
5012
5013                 if ( $member->isAdmin() && ($showAll == 'yes') )
5014                 {
5015                         // Super-Admins have access to all blogs! (no add item support though)
5016                         $query =  "SELECT bnumber, bname, 1 as tadmin, burl, bshortname"
5017                                 . " FROM %s"
5018                                 . " ORDER BY bnumber;";
5019                         $query = sprintf($query, sql_table('blog'));
5020                 }
5021                 else
5022                 {
5023                         $query =  "SELECT bnumber, bname, tadmin, burl, bshortname"
5024                                 . " FROM %s,%s"
5025                                 . " WHERE tblog=bnumber and tmember=%d"
5026                                 . " ORDER BY bnumber;";
5027                         $query = sprintf($query, sql_table('blog'), sql_table('team'), (integer) $member->getID());
5028                 }
5029
5030                 $template['content']    = 'bloglist';
5031                 $template['superadmin'] = $member->isAdmin();
5032
5033                 $amount = Showlist($query, 'table', $template, $templateName);
5034
5035                 if ( ($showAll != 'yes') && ($member->isAdmin()) )
5036                 {
5037                         $query = 'SELECT COUNT(*) as result FROM ' . sql_table('blog');
5038
5039                         $total = quickQuery($query);
5040                         if ( $total > $amount )
5041                         {
5042                                 echo '<p><a href="index.php?action=overview&amp;showall=yes">' . _OVERVIEW_SHOWALL . '</a></p>';
5043                         }
5044                 }
5045
5046                 if ( $amount == 0 )
5047                 {
5048                         echo _OVERVIEW_NOBLOGS;
5049                 }
5050                 elseif( $amount != 0 )
5051                 {
5052                         echo '<h2>' . _OVERVIEW_YRDRAFTS . '</h2>';
5053
5054                         $query =  "SELECT ititle, inumber, bshortname"
5055                                . " FROM %s,%s"
5056                                . ' WHERE iauthor=%d AND iblog=bnumber AND idraft=1;';
5057                         $query = sprintf($query, sql_table('item'), sql_table('blog'), (integer) $member->getID());
5058
5059                         $template['content'] = 'draftlist';
5060
5061                         $amountdrafts = Showlist($query, 'table', $template, $templateName);
5062                         if ( $amountdrafts == 0 )
5063                         {
5064                                 echo _OVERVIEW_NODRAFTS;
5065                         }
5066                 }
5067                 return;
5068         }
5069
5070         /**
5071          * AdminActions::checkCondition()
5072          * Checks conditions for if statements
5073          *
5074          * @param       string  $field type of <%if%>
5075          * @param       string  $name property of field
5076          * @param       string  $value value of property
5077          * @return      boolean condition
5078          */
5079         protected function checkCondition($field, $name='', $value = '')
5080         {
5081                 global $CONF, $catid, $blog, $member, $itemidnext, $itemidprev, $manager, $archiveprevexists, $archivenextexists;
5082
5083                 $condition = 0;
5084                 switch ( $field )
5085                 {
5086                         case 'category':
5087                                 if ( !$blog )
5088                                 {
5089                                         if ( $blogid )
5090                                         {
5091                                                 global $manager;
5092                                                 $blog =& $manager->getBlog($blogid);
5093                                         }
5094                                         elseif ( $catid )
5095                                         {
5096                                                 $blogid = getBlogIDFromCatID($catid);
5097                                                 global $manager;
5098                                                 $blog =& $manager->getBlog($blogid);
5099                                         }
5100                                         elseif ( intRequestVar('catid') )
5101                                         {
5102                                                 $catid = intRequestVar('catid');
5103                                                 $blogid = getBlogIDFromCatID($catid);
5104                                                 global $manager;
5105                                                 $blog =& $manager->getBlog($blogid);
5106                                         }
5107                                         else
5108                                         {
5109                                                 return;
5110                                         }
5111                                 }
5112                                 $condition = ($blog && $this->ifCategory($name, $value));
5113                                 break;
5114                         case 'blogsetting':
5115                                 $condition = ($blog && ($blog->getSetting($name) == $value));
5116                                 break;
5117                         case 'loggedin':
5118                                 $condition = $member->isLoggedIn();
5119                                 break;
5120                         case 'onteam':
5121                                 $condition = $member->isLoggedIn() && $this->ifOnTeam($name);
5122                                 break;
5123                         case 'admin':
5124                                 $condition = $member->isLoggedIn() && $this->ifAdmin($name);
5125                                 break;
5126                         case 'superadmin':
5127                                 $condition = $member->isLoggedIn() && $member->isAdmin();
5128                                 break;
5129                         case 'allowloginedit':
5130                                 $condition = $member->isLoggedIn() && ($CONF['AllowLoginEdit'] || $member->isAdmin());
5131                                 break;
5132                         case 'nextitem':
5133                                 $condition = ($itemidnext != '');
5134                                 break;
5135                         case 'previtem':
5136                                 $condition = ($itemidprev != '');
5137                                 break;
5138                         case 'archiveprevexists':
5139                                 $condition = ($archiveprevexists == true);
5140                                 break;
5141                         case 'archivenextexists':
5142                                 $condition = ($archivenextexists == true);
5143                                 break;
5144                         case 'skintype':
5145                                 $condition = (($name == $this->skintype) || ($name == requestVar('action')));
5146                                 break;
5147                         case 'hasplugin':
5148                                 $condition = $this->ifHasPlugin($name, $value);
5149                                 break;
5150                         case 'adminaction':
5151                                 $condition = (Admin::getAdminAction() == $name);
5152                                 break;
5153                         case 'adminoldaction':
5154                                 $condition = (Admin::getAdminAction() == $name);
5155                                 break;
5156                         case 'addresschange':
5157                                 $condition = ($this->ifAddresscange());
5158                                 break;
5159                         case 'bechangepass':
5160                                 $condition = ($this->beChangePassword());
5161                                 break;
5162                         case 'skincandidates':
5163                                 $condition = ($this->ifSkincandidates());
5164                                 break;
5165                         case 'nameclashes':
5166                                 $condition = requestVar('nameclashes');
5167                                 break;
5168                         case 'existsnewplugin':
5169                                 $condition = ($this->existsNewPlugin());
5170                                 break;
5171                         case 'autosave':
5172                                 $condition = (boolean) ($member->getAutosave() == $value);
5173                                 break;
5174                         default:
5175                                 $condition = $manager->pluginInstalled("NP_{$field}") && $this->ifPlugin($field, $name, $value);
5176                                 break;
5177                 }
5178                 return $condition;
5179         }
5180
5181         /**
5182          * Actions::_ifHasPlugin()
5183          *      hasplugin,PlugName
5184          *         -> checks if plugin exists
5185          *      hasplugin,PlugName,OptionName
5186          *         -> checks if the option OptionName from plugin PlugName is not set to 'no'
5187          *      hasplugin,PlugName,OptionName=value
5188          *         -> checks if the option OptionName from plugin PlugName is set to value
5189          *
5190          * @param       string  $name   name of plugin
5191          * @param       string  $value
5192          * @return
5193          */
5194         private function ifHasPlugin($name, $value)
5195         {
5196                 global $manager;
5197                 $condition = false;
5198                 // (pluginInstalled method won't write a message in the actionlog on failure)
5199                 if ( $manager->pluginInstalled("NP_{$name}") )
5200                 {
5201                         $plugin =& $manager->getPlugin("NP_{$name}");
5202                         if ( $plugin != NULL )
5203                         {
5204                                 if ( $value == "" )
5205                                 {
5206                                         $condition = true;
5207                                 }
5208                                 else
5209                                 {
5210                                         list($name2, $value2) = preg_split('#=#', $value, 2);
5211                                         if ( $value2 == "" && $plugin->getOption($name2) != 'no' )
5212                                         {
5213                                                 $condition = true;
5214                                         }
5215                                         else if ( $plugin->getOption($name2) == $value2 )
5216                                         {
5217                                                 $condition = true;
5218                                         }
5219                                 }
5220                         }
5221                 }
5222                 return $condition;
5223         }
5224
5225         /**
5226          * Actions::beChangePassword()
5227          *
5228          * @param       void
5229          * @return      void
5230          */
5231         private function beChangePassword()
5232         {
5233                 return intRequestVar('bNeedsPasswordChange');
5234         }
5235
5236         /**
5237          * Actions::ifSkincandidates()
5238          * Checks if a plugin exists and call its doIf function
5239          *
5240          * @param       void
5241          * @return      void
5242          * @return      boolean
5243          */
5244         private function ifSkincandidates()
5245         {
5246                 global $DIR_SKINS;
5247                 $candidates = SKINIMPORT::searchForCandidates($DIR_SKINS);
5248                 return (count($candidates) > 0);
5249         }
5250
5251         /**
5252          * Actions::ifPlugin()
5253          * Checks if a plugin exists and call its doIf function
5254          *
5255          * @param       string  $name   name of plugin
5256          * @param       string  $key
5257          * @param       string  $value
5258          * @return      callback
5259          */
5260         private function ifPlugin($name, $key = '', $value = '')
5261         {
5262                 global $manager;
5263
5264                 $plugin =& $manager->getPlugin("NP_{$name}");
5265                 if ( !$plugin )
5266                 {
5267                         return;
5268                 }
5269
5270                 $params = func_get_args();
5271                 array_shift($params);
5272
5273                 return call_user_func_array(array(&$plugin, 'doIf'), $params);
5274         }
5275
5276         /**
5277          * AdminActions::ifCategory()
5278          *  Different checks for a category
5279          *
5280          * @param       string  $key    key for information of category
5281          * @param       string  $value  value for information of category
5282          * @return      boolean
5283          */
5284         private function ifCategory($key = '', $value='')
5285         {
5286                 global $blog, $catid;
5287
5288                 // when no parameter is defined, just check if a category is selected
5289                 if (($key != 'catname' && $key != 'catid') || ($value == ''))
5290                 {
5291                         return $blog->isValidCategory($catid);
5292                 }
5293
5294                 // check category name
5295                 if ( $key == 'catname' )
5296                 {
5297                         $value = $blog->getCategoryIdFromName($value);
5298                         if ($value == $catid)
5299                         {
5300                                 return $blog->isValidCategory($catid);
5301                         }
5302                 }
5303
5304                 // check category id
5305                 if (($key == 'catid') && ($value == $catid))
5306                 {
5307                         return $blog->isValidCategory($catid);
5308                 }
5309
5310                 return FALSE;
5311         }
5312
5313         /**
5314          * AdminActions::ifOnTeam()
5315          * Checks if a member is on the team of a blog and return his rights
5316          *
5317          * @param       string  $blogName       name of weblog
5318          * @return      boolean
5319          */
5320         private function ifOnTeam($blogName = '')
5321         {
5322                 global $blog, $member, $manager;
5323
5324                 // when no blog found
5325                 if ( ($blogName == '') && !is_object($blog) )
5326                 {
5327                         return 0;
5328                 }
5329
5330                 // explicit blog selection
5331                 if ($blogName != '')
5332                 {
5333                         $blogid = getBlogIDFromName($blogName);
5334                 }
5335
5336                 if (($blogName == '') || !$manager->existsBlogID($blogid))
5337                 {
5338                         // use current blog
5339                         $blogid = $blog->getID();
5340                 }
5341                 return $member->teamRights($blogid);
5342         }
5343
5344         /**
5345          * AdminActions::ifAdmin()
5346          * Checks if a member is admin of a blog
5347          *
5348          * @param       string  $blogName       name of weblog
5349          * @return      boolean
5350          */
5351         private function ifAdmin($blogName = '')
5352         {
5353                 global $blog, $member, $manager;
5354
5355                 // when no blog found
5356                 if (($blogName == '') && (!is_object($blog)))
5357                 {
5358                         return 0;
5359                 }
5360
5361                 // explicit blog selection
5362                 if ($blogName != '')
5363                 {
5364                         $blogid = getBlogIDFromName($blogName);
5365                 }
5366
5367                 if (($blogName == '') || !$manager->existsBlogID($blogid))
5368                 {
5369                         // use current blog
5370                         $blogid = $blog->getID();
5371                 }
5372
5373                 return $member->isBlogAdmin($blogid);
5374         }
5375
5376         /**
5377          * AdminActions::ifAddresscange()
5378          * Check e-Mail address is changed
5379          *
5380          * @param       void
5381          * @return      boolean
5382          */
5383         private function ifAddresscange()
5384         {
5385                 $key = $this->objAdmin->sessionVar("{$CONF['CookiePrefix']}ackey");
5386                 if ( !$key )
5387                 {
5388                         return FALSE;
5389                 }
5390                 $info = MEMBER::getActivationInfo($key);
5391                 if ( !$info )
5392                 {
5393                         return FALSE;
5394                 }
5395                 $mem  = MEMBER::createFromId($info->vmember);
5396                 if ( !$mem )
5397                 {
5398                         return FALSE;
5399                 }
5400                 if ( $info->vtype == 'addresschange' )
5401                 {
5402                         return TRUE;
5403                 }
5404                 return FALSE;
5405         }
5406
5407         /**
5408          * AdminActions::templateEditRow()
5409          * Template edit box
5410          *
5411          * @param       array   $template
5412          * @param       string  $desc
5413          * @param       string  $name
5414          * @param       string  $help
5415          * @param       integer $tabindex
5416          * @param       boolean $big
5417          * @param       array   $tmplt
5418          * @return      void
5419          */
5420         private function templateEditRow(&$template, $desc, $name, $help = '', $tabindex = 0, $big = 0, $tplt = '')
5421         {
5422                 static $count = 1;
5423
5424                 if ( !array_key_exists($name, $template) )
5425                 {
5426                         $template[$name] = '';
5427                 }
5428
5429                 $tmplt = array();
5430                 $base  = array();
5431
5432                 if ( $tplt )
5433                 {
5434                         $tmplt = skinableTEMPLATE::read($tplt);
5435                 }
5436
5437                 $data = array(
5438                         'description'   => $desc,
5439                         'help'                  => empty($help) ? '' : helpHtml('template' . $help),
5440                         'count'                 => $count,
5441                         'name'                  => $name,
5442                         'tabindex'              => $tabindex,
5443                         'rows'                  => $big ? 10 : 5,
5444                 );
5445
5446                 if ( !array_key_exists('TEMPLATE_EDIT_ROW_HEAD', $tmplt) || empty($tmplt['TEMPLATE_EDIT_ROW_HEAD']) )
5447                 {
5448                         $base['head'] = "</tr>"
5449                                       . "<tr>\n"
5450                                       . "<td><%description%><%help%></td>\n"
5451                                       . "<td id=\"td<%count%>\">\n"
5452                                       . "<textarea class=\"templateedit\" name=\"<%name%>\" tabindex=\"<%tabindex%>\" cols=\"50\" rows=\"<%rows%>\" id=\"textarea<%count%>\">\n";
5453                 }
5454                 else
5455                 {
5456                         $base['head'] = $tmplt['TEMPLATE_EDIT_ROW_HEAD'];
5457                 }
5458
5459                 if ( !array_key_exists('TEMPLATE_EDIT_ROW_TAIL', $tmplt) || empty($tmplt['TEMPLATE_EDIT_ROW_TAIL']) )
5460                 {
5461                         $base['tail'] = "</textarea>\n"
5462                                       . "</td>\n";
5463                 }
5464                 else
5465                 {
5466                         $base['tail'] = $tmplt['TEMPLATE_EDIT_ROW_TAIL'];
5467                 }
5468
5469                 echo TEMPLATE::fill($base['head'], $data);
5470                 echo ENTITY::hsc($template[$name]);
5471                 echo TEMPLATE::fill($base['tail'], $data);
5472
5473                 $count++;
5474
5475                 return;
5476         }
5477
5478         /**
5479          * AdminActions::customHelp()
5480          * shows a link to custom help file
5481          *
5482          * @param       string  $id
5483          * @param       string  $tplName
5484          * @param       string  $url
5485          * @param       string  $iconURL
5486          * @param       string  $alt
5487          * @param       string  $title
5488          * @param       $onclick
5489          *
5490          */
5491         private function customHelp($id, $tplName = '', $url = '', $iconURL = '', $alt = '', $title = '', $onclick = '')
5492         {
5493                 echo self::customHelpHtml($id, $tplName, $url, $iconURL, $alt, $title, $onclick);
5494         }
5495
5496         /**
5497          * AdminActions::customHelp()
5498          * shows a link to custom help file
5499          *
5500          * @param       string  $id
5501          * @param       string  $tplName
5502          * @param       string  $url
5503          * @param       string  $iconURL
5504          * @param       string  $alt
5505          * @param       string  $title
5506          * @param       $onclick
5507          *
5508          */
5509         static function customHelplink($id, $tplName = '', $url = '', $title = '', $onclick = '')
5510         {
5511                 global $CONF;
5512
5513                 $templates = array();
5514
5515                 if ( $tplName )
5516                 {
5517                         $templates = Template::read($tplName);
5518                 }
5519
5520                 if ( !array_key_exists('ADMIN_CUSTOMHELPLINK_ANCHOR', $templates) || empty($templates['ADMIN_CUSTOMHELPLINK_ANCHOR']) )
5521                 {
5522                         $template = "<a href=\"<%helpurl%>#<%helptarget%>\" title=\"<%title%>\" <%onclick%>>\n";
5523                 }
5524                 else
5525                 {
5526                         $template = $templates['ADMIN_CUSTOMHELPLINK_ANCHOR'];
5527                 }
5528
5529                 if ( empty($url) )
5530                 {
5531                         $url = $CONF['AdminURL'] . 'documentation/customHelp.html';
5532                 }
5533
5534                 if ( empty($onclick) )
5535                 {
5536                         $onclick = 'onclick="if (event &amp;&amp; event.preventDefault) event.preventDefault(); return help(this.href);"';
5537                 }
5538                 elseif ( preg_match('#^onclick#', $onclick) )
5539                 {
5540                         $onclick = $onclick;
5541                 }
5542                 else
5543                 {
5544                         $onclick = 'onclick="' . $onclick . '"';
5545                 }
5546
5547                 $data = array(
5548                         'helpurl'               => $url,
5549                         'helptarget'    => $id,
5550                         'onclick'               => $onclick,
5551                         'title'                 => (isset($title) && !empty($title)) ? $title : _HELP_TT,
5552                 );
5553                 return Template::fill($template, $data);
5554         }
5555
5556         /**
5557          * AdminActions::customHelpHtml()
5558          *
5559          * @param       string  $id
5560          * @param       string  $tplName
5561          * @param       string  $url
5562          * @param       string  $iconURL
5563          * @param       string  $alt
5564          * @param       string  $title
5565          * @param       string  $onclick
5566          * @return      string  anchor element with help uri
5567          */
5568         private function customHelpHtml($id, $tplName = '', $url = '', $iconURL = '', $alt = '', $title = '', $onclick = '')
5569         {
5570                 global $CONF;
5571
5572                 $templates = array();
5573
5574                 if ( $tplName )
5575                 {
5576                         $templates = Template::read($tplName);
5577                 }
5578                 if ( !array_key_exists('ADMIN_CUSTOMHELPLINK_ICON', $templates) || !empty($templates['ADMIN_CUSTOMHELPLINK_ICON']) )
5579                 {
5580                         $template = "<img src=\"<%iconurl%>\" <%width%><%height%>alt=\"<%alt%>\" title=\"<%title%>\" /></a>\n";
5581                 }
5582                 else
5583                 {
5584                         $template = $templates['ADMIN_CUSTOMHELPLINK_ICON'];
5585                 }
5586
5587                 if ( empty($iconURL) )
5588                 {
5589                         $iconURL = $CONF['AdminURL'] . 'documentation/icon-help.gif';
5590                 }
5591
5592                 if ( function_exists('getimagesize') )
5593                 {
5594                         $size   = getimagesize($iconURL);
5595                         $width  = 'width="'  . $size[0] . '" ';
5596                         $height = 'height="' . $size[1] . '" ';
5597                 }
5598
5599                 $data = array(
5600                         'iconurl'       => $iconURL,
5601                         'width'         => $width,
5602                         'height'        => $height,
5603                         'alt'           => (isset($alt) && !empty($alt))         ? $alt   : _HELP_TT,
5604                         'title'         => (isset($title) && !empty($title)) ? $title : _HELP_TT,
5605                 );
5606
5607                 $icon = Template::fill($template, $data);
5608                 $help = self::customHelplink($id, $tplName, $url, $title, $onclick);
5609
5610                 return $help . $icon;
5611         }
5612
5613         /**
5614          * AdminActions::input_yesno
5615          *
5616          * @param               $name
5617          * @param               $checkedval
5618          * @param               $tabindex
5619          * @param               $value1
5620          * @param               $value2
5621          * @param               $yesval
5622          * @param               $noval
5623          * @param               $isAdmin
5624          * @param               $templateName
5625          * @param               $showlist
5626          */
5627         private function input_yesno($name,
5628                                                                 $checkedval,
5629                                                                 $tabindex        = 0,
5630                                                                 $value1    = 1,
5631                                                                 $value2    = 0,
5632                                                                 $yesval    = _YES,
5633                                                                 $noval          = _NO,
5634                                                                 $isAdmin          = 0,
5635                                                                 $templateName = '',
5636                                                                 $showlist        = false)
5637         {
5638                 $templates = array();
5639                 if ( $templateName )
5640                 {
5641                         $templates = Template::read($templateName);
5642                 }
5643
5644                 if ( $name == 'admin' )
5645                 {
5646                         if ( !array_key_exists('INPUTYESNO_TEMPLATE_ADMIN', $templates) || empty($templates['INPUTYESNO_TEMPLATE_ADMIN']) )
5647                         {
5648                                 $template = '<input onclick="selectCanLogin(true);" type="radio" name="<%name%>" value="<%yesval%>" <%yescheckedval%> id="<%yesid%>" />' . "\n"
5649                                           . '<label for="<%yesid%>"><%yesvaltext%></label>' . "\n"
5650                                           . '<input onclick="selectCanLogin(false);" type="radio" name="<%name%>" value="<%noval%>" <%nocheckedval%> id="<%noid%>"<%disabled%> />' . "\n"
5651                                           . '<label for="<%noid%>"><%novaltext%></label>' . "\n";
5652                         }
5653                         else
5654                         {
5655                                 $template = $templates['INPUTYESNO_TEMPLATE_ADMIN'];
5656                         }
5657                 }
5658                 else
5659                 {
5660                         if ( array_key_exists('INPUTYESNO_TEMPLATE_NORMAL', $templates) && !empty($templates['INPUTYESNO_TEMPLATE_NORMAL']) )
5661                         {
5662                                 $template = $templates['INPUTYESNO_TEMPLATE_NORMAL'];
5663                         }
5664                         if ( $showlist )
5665                         {
5666                                 if ( array_key_exists('SHOWLIST_LISTPLUG_TABLE_PLGOPT_OYESNO', $templates) && !empty($templates['SHOWLIST_LISTPLUG_TABLE_PLGOPT_OYESNO']) )
5667                                 {
5668                                         $template = $templates['SHOWLIST_LISTPLUG_TABLE_PLGOPT_OYESNO'];
5669                                 }
5670                         }
5671                         if ( !isset($template) )
5672                         {
5673                                 $template = '<input type="radio" name="<%name%>" value="<%yesval%>" <%yescheckedval%> id="<%yesid%>" />' . "\n"
5674                                           . '<label for="<%yesid%>"><%yesvaltext%></label>' . "\n"
5675                                           . '<input type="radio" name="<%name%>" value="<%noval%>" <%nocheckedval%> id="<%noid%>"<%disabled%> />' . "\n"
5676                                           . '<label for="<%noid%>"><%novaltext%></label>' . "\n";
5677                         }
5678                 }
5679
5680                 //echo $template;
5681                 $id             = Entity::hsc($name);
5682                 $id             = str_replace('[', '-', $id);
5683                 $id             = str_replace(']', '-', $id);
5684                 $id1    = $id . Entity::hsc($value1);
5685                 $id2    = $id . Entity::hsc($value2);
5686                 $dat = array(
5687                         'name'                  => Entity::hsc($name),
5688                         'yesval'                => Entity::hsc($value1),
5689                         'noval'                 => Entity::hsc($value2),
5690                         'yesid'                 => $id1,
5691                         'noid'                  => $id2,
5692                         'yesvaltext'    => $yesval,
5693                         'novaltext'             => $noval,
5694                         'yescheckedval' => ($checkedval == $value1) ? ' checked="checked" tabindex="' . $tabindex . '"': '',
5695                         'nocheckedval'  => ($checkedval != $value1) ? ' checked="checked" tabindex="' . $tabindex . '"': '',
5696                         'disabled'              => ($isAdmin && $name == 'canlogin') ? ' disabled="disabled"' : '',
5697                 );
5698
5699                 if ( $showlist )
5700                 {
5701                         return Template::fill($template, $dat);
5702                 }
5703                 else
5704                 {
5705                         echo Template::fill($template, $dat);
5706                 }
5707                 return;
5708         }
5709
5710         /**
5711          * AdminActions::existsNewPlugin()
5712          * Check exists new plugin
5713          *
5714          * @param       void
5715          * @return      boolean exists or not
5716          */
5717         private function existsNewPlugin()
5718         {
5719                 global $DIR_PLUGINS;
5720
5721                 $candidates = array();
5722                 $files = scandir($DIR_PLUGINS);
5723
5724                 foreach ( $files as $file )
5725                 {
5726                         if ( preg_match("#^NP_(.*)\.php$#", $file, $matches) )
5727                         {
5728                                 $name = $matches[1];
5729                                 $query = "SELECT * FROM %s WHERE pfile='%s';";
5730                                 $query = sprintf($query, sql_table('plugin'), sql_real_escape_string("{NP_{$name}"));
5731                                 $res  = sql_query($query);
5732
5733                                 if ( sql_num_rows($res) == 0 )
5734                                 {
5735                                         $candidates[] = $name;
5736                                 }
5737                         }
5738                         continue;
5739                 }
5740                 $this->newPlugCandidates = $candidates;
5741                 return (count($candidates) > 0);
5742         }
5743 }