cgi-files/lib/page.lib

   1 #################################################################################
   2 # page.lib: Kiriwrite Page Library                                              #
   3 #                                                                               #
   4 # This library is under the same license as the main Kiriwrite script.          #
   5 #################################################################################
   6
   7 # This section of the file is for when the library is called from the main
   8 # Kiriwrite script.
   9
  10 if ($form_data->{'action'}){
  11         my $http_query_action = $form_data->{'action'};
  12
  13         # Check if the action requested matches with one of the options below. If it does,
  14         # go to that section, otherwise return an error.
  15
  16         if ($http_query_action eq "view"){
  17
  18                 # The action selected was to view pages from a database,
  19
  20                 my $http_query_database         = $form_data->{'database'};
  21                 my $http_query_browsenumber     = $form_data->{'browsenumber'};
  22                 my $pagedata            = kiriwrite_page_list($http_query_database, $http_query_browsenumber);
  23
  24                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
  25                 kiriwrite_output_page($kiriwrite_lang->{pages}->{viewingdatabase}, $pagedata, "pages"); # Output the page to browser/console/stdout.
  26                 exit;                   # End the script.
  27
  28         } elsif ($http_query_action eq "add"){
  29
  30                 # The action selected was to add a page to the selected database.
  31
  32                 my $http_query_confirm  = $form_data->{'confirm'};
  33
  34                 if (!$http_query_confirm){
  35
  36                         $http_query_confirm = 0;
  37
  38                 }
  39
  40                 if ($http_query_confirm eq 1){
  41
  42                         my $http_query_database         = $form_data->{'database'};
  43                         my $http_query_filename         = $form_data->{'pagefilename'};
  44                         my $http_query_name             = $form_data->{'pagename'};
  45                         my $http_query_description      = $form_data->{'pagedescription'};
  46                         my $http_query_section          = $form_data->{'pagesection'};
  47                         my $http_query_template         = $form_data->{'pagetemplate'};
  48                         my $http_query_settings         = $form_data->{'pagesettings'};
  49                         my $http_query_content          = $form_data->{'pagecontent'};
  50
  51                         my $pagedata                    = kiriwrite_page_add($http_query_database, $http_query_filename, $http_query_name, $http_query_description, $http_query_section, $http_query_template, $http_query_settings, $http_query_content, $http_query_confirm);
  52
  53                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
  54                         kiriwrite_output_page($kiriwrite_lang->{pages}->{addpage}, $pagedata, "pages"); # Output the page to browser/console/stdout.
  55                         exit;                           # End the script.
  56
  57                 }
  58
  59                 my $http_query_database = $form_data->{'database'};
  60                 my $pagedata            = kiriwrite_page_add($http_query_database);
  61
  62                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
  63                 kiriwrite_output_page($kiriwrite_lang->{pages}->{addpage}, $pagedata, "pages"); # Output the page to browser/console/stdout.
  64                 exit;                           # End the script.
  65
  66         } elsif ($http_query_action eq "edit"){
  67
  68                 # The action selected was to edit a page from a database.
  69
  70                 my $http_query_confirm = $form_data->{'confirm'};
  71
  72                 if (!$http_query_confirm){
  73
  74                         $http_query_confirm = 0;
  75
  76                 }
  77
  78                 if ($http_query_confirm eq 1){
  79
  80                         # Get the needed values from the HTTP query.
  81
  82                         my $http_query_database         = $form_data->{'database'};
  83                         my $http_query_filename         = $form_data->{'page'};
  84                         my $http_query_newfilename      = $form_data->{'pagefilename'};
  85                         my $http_query_name             = $form_data->{'pagename'};
  86                         my $http_query_description      = $form_data->{'pagedescription'};
  87                         my $http_query_section          = $form_data->{'pagesection'};
  88                         my $http_query_template         = $form_data->{'pagetemplate'};
  89                         my $http_query_settings         = $form_data->{'pagesettings'};
  90                         my $http_query_content          = $form_data->{'pagecontent'};
  91
  92                         # Pass the values to the editing pages subroutine.
  93
  94                         my $pagedata = kiriwrite_page_edit($http_query_database, $http_query_filename, $http_query_newfilename, $http_query_name, $http_query_description, $http_query_section, $http_query_template, $http_query_settings, $http_query_content, $http_query_confirm);
  95
  96                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
  97                         kiriwrite_output_page($kiriwrite_lang->{pages}->{editpagetitle}, $pagedata, "pages");   # Output the page to browser/console/stdout.
  98                         exit;                           # End the script.
  99
 100                 }
 101
 102                 # Get the needed values from the HTTP query.
 103
 104                 my $http_query_database = $form_data->{'database'};
 105                 my $http_query_filename = $form_data->{'page'};
 106
 107                 # Pass the values to the editing pages subroutine.
 108
 109                 my $pagedata = kiriwrite_page_edit($http_query_database, $http_query_filename);
 110
 111                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
 112                 kiriwrite_output_page($kiriwrite_lang->{pages}->{editpagetitle}, $pagedata, "pages");   # Output the page to browser/console/stdout.
 113                 exit;                           # End the script.
 114
 115
 116         } elsif ($http_query_action eq "delete"){
 117
 118                 # The action selected was to delete a page from a database.
 119
 120                 my $http_query_database = $form_data->{'database'};
 121                 my $http_query_page     = $form_data->{'page'};
 122                 my $http_query_confirm  = $form_data->{'confirm'};
 123
 124                 my $pagedata = "";
 125                 my $selectionlist = "";
 126
 127                 if ($http_query_confirm){
 128
 129                         # The action has been confirmed, so try to delete the selected page
 130                         # from the database.
 131
 132                         $pagedata = kiriwrite_page_delete($http_query_database, $http_query_page, $http_query_confirm);
 133
 134                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
 135                         kiriwrite_output_page($kiriwrite_lang->{pages}->{deletepagetitle}, $pagedata, "pages"); # Output the page to browser/console/stdout.
 136                         exit;                           # End the script.
 137
 138                 }
 139
 140                 $pagedata = kiriwrite_page_delete($http_query_database, $http_query_page);
 141
 142                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
 143                 kiriwrite_output_page($kiriwrite_lang->{pages}->{deletepagetitle}, $pagedata, "pages"); # Output the page to browser/console/stdout.
 144                 exit;                           # End the script.
 145
 146
 147         } elsif ($http_query_action eq "multidelete"){
 148
 149                 # The action selected was to delete multiple pages from a
 150                 # database.
 151
 152                 my $http_query_database = $form_data->{'database'};
 153                 my $http_query_confirm  = $form_data->{'confirm'};
 154
 155                 my @filelist;
 156                 my $pagedata;
 157
 158                 if ($http_query_confirm){
 159
 160                         # The action to delete multiple pages from the selected
 161                         # database has been confirmed.
 162
 163                         @filelist       = kiriwrite_selectedlist();
 164                         $pagedata       = kiriwrite_page_multidelete($http_query_database, $http_query_confirm, @filelist);
 165
 166                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
 167                         kiriwrite_output_page($kiriwrite_lang->{pages}->{deletemultiplepages}, $pagedata, "pages"); # Output the page to browser/console/stdout.
 168                         exit;                           # End the script.
 169
 170                 }
 171
 172                 # Get the list of selected pages and pass them to the
 173                 # multiple page delete subroutine.
 174
 175                 @filelist       = kiriwrite_selectedlist();
 176                 $pagedata       = kiriwrite_page_multidelete($http_query_database, $http_query_confirm, @filelist);
 177
 178                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
 179                 kiriwrite_output_page($kiriwrite_lang->{pages}->{deletemultiplepages}, $pagedata, "pages"); # Output the page to browser/console/stdout.
 180                 exit;                           # End the script.
 181
 182         } elsif ($http_query_action eq "multimove"){
 183
 184                 # The action selected was to move multiple pages from a
 185                 # database.
 186
 187                 my $http_query_database         = $form_data->{'database'};
 188                 my $http_query_newdatabase      = $form_data->{'newdatabase'};
 189                 my $http_query_confirm          = $form_data->{'confirm'};
 190
 191                 my @filelist;
 192                 my $pagedata;
 193
 194                 if ($http_query_confirm){
 195
 196                         # The action to move multiple pages from the selected
 197                         # database has been confirmed.
 198
 199                         @filelist       = kiriwrite_selectedlist();
 200                         $pagedata       = kiriwrite_page_multimove($http_query_database, $http_query_newdatabase, $http_query_confirm, @filelist);
 201
 202                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
 203                         kiriwrite_output_page($kiriwrite_lang->{pages}->{movepages}, $pagedata, "pages"); # Output the page to browser/console/stdout.
 204                         exit;                           # End the script.
 205
 206                 }
 207
 208                 # Get the list of selected pages and pass them to the
 209                 # multiple page move subroutine.
 210
 211                 @filelist       = kiriwrite_selectedlist();
 212                 $pagedata       = kiriwrite_page_multimove($http_query_database, $http_query_newdatabase, $http_query_confirm, @filelist);
 213
 214                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
 215                 kiriwrite_output_page($kiriwrite_lang->{pages}->{movepages}, $pagedata, "pages"); # Output the page to browser/console/stdout.
 216                 exit;                           # End the script.
 217
 218         } elsif ($http_query_action eq "multicopy"){
 219
 220                 # The action selected was to copy multiple pages from a
 221                 # database.
 222
 223                 my $http_query_database         = $form_data->{'database'};
 224                 my $http_query_newdatabase      = $form_data->{'newdatabase'};
 225                 my $http_query_confirm          = $form_data->{'confirm'};
 226
 227                 my @filelist;
 228                 my $pagedata;
 229
 230                 if ($http_query_confirm){
 231
 232                         # The action to copy multiple pages from the selected
 233                         # database has been confirmed.
 234
 235                         @filelist       = kiriwrite_selectedlist();
 236                         $pagedata       = kiriwrite_page_multicopy($http_query_database, $http_query_newdatabase, $http_query_confirm, @filelist);
 237
 238                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
 239                         kiriwrite_output_page($kiriwrite_lang->{pages}->{copypages}, $pagedata, "pages"); # Output the page to browser/console/stdout.
 240                         exit;                           # End the script.
 241
 242                 }
 243
 244                 # Get the list of selected pages and pass them to the
 245                 # multiple page copy subroutine.
 246
 247                 @filelist       = kiriwrite_selectedlist();
 248                 $pagedata       = kiriwrite_page_multicopy($http_query_database, $http_query_newdatabase, $http_query_confirm, @filelist);
 249
 250                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
 251                 kiriwrite_output_page($kiriwrite_lang->{pages}->{copypages}, $pagedata, "pages"); # Output the page to browser/console/stdout.
 252                 exit;                           # End the script.
 253
 254         } elsif ($http_query_action eq "multiedit"){
 255
 256                 # The action selected was to edit multiple pages from a
 257                 # database.
 258
 259                 my $http_query_database         = $form_data->{'database'};
 260                 my $http_query_newsection       = $form_data->{'newsection'};
 261                 my $http_query_altersection     = $form_data->{'altersection'};
 262                 my $http_query_newtemplate      = $form_data->{'newtemplate'};
 263                 my $http_query_altertemplate    = $form_data->{'altertemplate'};
 264                 my $http_query_newsettings      = $form_data->{'newsettings'};
 265                 my $http_query_altersettings    = $form_data->{'altersettings'};
 266                 my $http_query_confirm          = $form_data->{'confirm'};
 267
 268                 my @filelist;
 269                 my $pagedata;
 270
 271                 if (!$http_query_confirm){
 272
 273                         @filelist       = kiriwrite_selectedlist();
 274                         $pagedata       = kiriwrite_page_multiedit($http_query_database, $http_query_newsection, $http_query_altersection, $http_query_newtemplate, $http_query_altertemplate, $http_query_newsettings, $http_query_altersettings, $http_query_confirm, @filelist);
 275
 276                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
 277                         kiriwrite_output_page($kiriwrite_lang->{pages}->{multiedit}, $pagedata, "pages"); # Output the page to browser/console/stdout.
 278                         exit;
 279
 280                 }
 281
 282                 # Get the list of selected pages and pass them to the
 283                 # multiple page edit subroutine.
 284
 285                 @filelist       = kiriwrite_selectedlist();
 286                 $pagedata       = kiriwrite_page_multiedit($http_query_database, $http_query_newsection, $http_query_altersection, $http_query_newtemplate, $http_query_altertemplate, $http_query_newsettings, $http_query_altersettings, $http_query_confirm, @filelist);
 287
 288                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
 289                 kiriwrite_output_page($kiriwrite_lang->{pages}->{multiedit}, $pagedata, "pages"); # Output the page to browser/console/stdout.
 290                 exit;                           # End the script.
 291
 292         } else {
 293                 kiriwrite_error("invalidaction");
 294         }
 295
 296 } else {
 297
 298         # If there the action option is left blank, then print out a form where the database
 299         # can be selected to view pages from.
 300
 301         my $pagedata = kiriwrite_page_list();
 302
 303         kiriwrite_output_header;        # Output the header to browser/console/stdout.
 304         kiriwrite_output_page($kiriwrite_lang->{pages}->{databaseselecttitle}, $pagedata, "pages");     # Output the page to browser/console/stdout.
 305         exit;                           # End the script.
 306
 307 }
 308
 309 #################################################################################
 310 # Begin list of relevant subroutines.                                           #
 311 #################################################################################
 312
 313 sub kiriwrite_page_list{
 314 #################################################################################
 315 # kiriwrite_page_list: Lists pages from an database.                            #
 316 #                                                                               #
 317 # Usage:                                                                        #
 318 #                                                                               #
 319 # kiriwrite_page_list([database], [browsernumber]);                             #
 320 #                                                                               #
 321 # database      Specifies the database to retrieve the pages from.              #
 322 # browsenumber  Specifies which list of pages to look at.                       #
 323 #################################################################################
 324
 325         # Get the database file name from what was passed to the subroutine.
 326
 327         my ($database_file, $page_browsenumber) = @_;
 328
 329         # Check if the database_file variable is empty, if it is then print out a
 330         # select box asking the user to select a database from the list.
 331
 332         if (!$database_file) {
 333
 334                 # Define the variables required for this section.
 335
 336                 my %database_info;
 337                 my @database_list;
 338                 my @databasefilenames;
 339                 my @databasenames;
 340                 my $dbseek              = 0;
 341                 my $dbfilename          = "";
 342                 my $dbname              = "";
 343                 my $data_file           = "";
 344                 my $data_file_length    = 0;
 345                 my $data_file_friendly  = "";
 346                 my $database_name       = "";
 347                 my $file_permissions    = "";
 348
 349                 # Connect to the database server.
 350
 351                 $kiriwrite_dbmodule->connect();
 352
 353                 # Check if any errors occured while connecting to the database server.
 354
 355                 if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
 356
 357                         # A database connection error has occured so return
 358                         # an error.
 359
 360                         kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
 361
 362                 }
 363
 364                 # Open the data directory and get all of the databases.
 365
 366                 @database_list  = $kiriwrite_dbmodule->getdblist();
 367
 368                 # Check if any errors occured while trying to get the list of databases.
 369
 370                 if ($kiriwrite_dbmodule->geterror eq "DataDirMissing"){
 371
 372                         # The database directory is missing so return an error.
 373
 374                         kiriwrite_error("datadirectorymissing");
 375
 376                 } elsif ($kiriwrite_dbmodule->geterror eq "DataDirInvalidPermissions"){
 377
 378                         # The database directory has invalid permissions set so return
 379                         # an error.
 380
 381                         kiriwrite_error("datadirectoryinvalidpermissions");
 382
 383                 }
 384
 385                 # Get the information about each database (the short name and friendly name).
 386
 387                 foreach $data_file (@database_list){
 388
 389                         $kiriwrite_dbmodule->selectdb({ DatabaseName => $data_file });
 390
 391                         # Check if any errors occured while selecting the database.
 392
 393                         if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
 394
 395                                 # The database does not exist, so process the next
 396                                 # database.
 397
 398                                 next;
 399
 400                         } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
 401
 402                                 # The database has invalid permissions set, so process
 403                                 # the next database.
 404
 405                                 next;
 406
 407                         }
 408
 409                         # Get the database information.
 410
 411                         %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
 412
 413                         # Check if any errors had occured while getting the database
 414                         # information.
 415
 416                         if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
 417
 418                                 # A database error has occured, so process the next
 419                                 # database.
 420
 421                                 next;
 422
 423                         };
 424
 425                         # Set the database name.
 426
 427                         $database_name          = $database_info{"DatabaseName"};
 428
 429                         # Check if the database name is undefined and if it is
 430                         # then set it blank.
 431
 432                         if (!$database_name){
 433                                 $database_name = "";
 434                         }
 435
 436                         # Append the database to the list of databases available.
 437
 438                         push(@databasefilenames, $data_file);
 439                         push(@databasenames, $database_name);
 440
 441                 }
 442
 443                 # Disconnect from the database server.
 444
 445                 $kiriwrite_dbmodule->disconnect();
 446
 447                 # Write the page data.
 448
 449                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{viewpages}, { Style => "pageheader" });
 450                 $kiriwrite_presmodule->addlinebreak();
 451                 $kiriwrite_presmodule->addlinebreak();
 452                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{nodatabaseselected});
 453                 $kiriwrite_presmodule->addlinebreak();
 454                 $kiriwrite_presmodule->addlinebreak();
 455                 $kiriwrite_presmodule->startform($kiriwrite_env{"script_filename"});
 456                 $kiriwrite_presmodule->startbox();
 457                 $kiriwrite_presmodule->addhiddendata("mode", "page");
 458                 $kiriwrite_presmodule->addhiddendata("action", "view");
 459                 $kiriwrite_presmodule->addselectbox("database");
 460                 foreach $dbfilename (@databasefilenames){
 461                         $dbname = $databasenames[$dbseek];
 462                         $dbseek++;
 463                         $kiriwrite_presmodule->addoption($dbname . " (" . $dbfilename . ")", { Value => $dbfilename });
 464                 }
 465                 $kiriwrite_presmodule->endselectbox();
 466                 $kiriwrite_presmodule->addtext(" | ");
 467                 $kiriwrite_presmodule->addsubmit($kiriwrite_lang->{pages}->{viewbutton});
 468                 $kiriwrite_presmodule->endbox();
 469                 $kiriwrite_presmodule->endform();
 470
 471                 return $kiriwrite_presmodule->grab();
 472
 473         } else {
 474
 475                 my %database_info;
 476                 my %page_info;
 477                 my @database_pages;
 478                 my $pagemultioptions    = "";
 479                 my $db_name             = "";
 480                 my $tablestyle          = "";
 481
 482                 my $page_filename       = "";
 483                 my $page_name           = "";
 484                 my $page_description    = "";
 485                 my $page_modified       = "";
 486
 487                 my $tablestyletype      = 0;
 488                 my $page_count          = 0;
 489                 my $db_file_notblank    = 0;
 490                 my $page_split          = $kiriwrite_config{"display_pagecount"};
 491                 my $page_list           = 0;
 492                 my $page_list_count     = 0;
 493
 494                 tie(%database_info, 'Tie::IxHash');
 495                 tie(%page_info, 'Tie::IxHash');
 496
 497                 # The database_file variable is not blank, so print out a list of pages from
 498                 # the selected database.
 499
 500                 # Preform a variable check on the database filename to make sure that it is
 501                 # valid before using it.
 502
 503                 kiriwrite_variablecheck($database_file, "filename", "", 0);
 504                 kiriwrite_variablecheck($database_file, "maxlength", 32, 0);
 505
 506                 if (!$page_browsenumber || $page_browsenumber eq 0){
 507
 508                         $page_browsenumber = 1;
 509
 510                 }
 511
 512                 # Check if the page browse number is valid and if it isn't
 513                 # then return an error.
 514
 515                 my $kiriwrite_browsenumber_length_check         = kiriwrite_variablecheck($page_browsenumber, "maxlength", 7, 1);
 516                 my $kiriwrite_browsenumber_number_check         = kiriwrite_variablecheck($page_browsenumber, "numbers", 0, 1);
 517
 518                 if ($kiriwrite_browsenumber_length_check eq 1){
 519
 520                         # The browse number was too long so return
 521                         # an error.
 522
 523                         kiriwrite_error("browsenumbertoolong");
 524
 525                 }
 526
 527                 if ($kiriwrite_browsenumber_number_check eq 1){
 528
 529                         # The browse number wasn't a number so
 530                         # return an error.
 531
 532                         kiriwrite_error("browsenumberinvalid");
 533
 534                 }
 535
 536                 # Connect to the database server.
 537
 538                 $kiriwrite_dbmodule->connect();
 539
 540                 # Check if any errors occured while connecting to the database server.
 541
 542                 if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
 543
 544                         # A database connection error has occured so return
 545                         # an error.
 546
 547                         kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
 548
 549                 }
 550
 551                 # Select the database.
 552
 553                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $database_file });
 554
 555                 # Check if any errors had occured while selecting the database.
 556
 557                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
 558
 559                         # The database does not exist, so return an error.
 560
 561                         kiriwrite_error("databasemissingfile");
 562
 563                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
 564
 565                         # The database has invalid permissions set, so return
 566                         # an error.
 567
 568                         kiriwrite_error("databaseinvalidpermissions");
 569
 570                 }
 571
 572                 # Get information about the database.
 573
 574                 %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
 575
 576                 $db_name = $database_info{"DatabaseName"};
 577
 578                 # Check if any errors had occured while getting the database
 579                 # information.
 580
 581                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
 582
 583                         # A database error has occured so return an error and
 584                         # also the extended error information.
 585
 586                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
 587
 588                 }
 589
 590                 # Get the count of pages in the database.
 591
 592                 my $page_total_count = $kiriwrite_dbmodule->getpagecount();
 593
 594                 # Check if any errors had occured while getting the count of
 595                 # pages in the database.
 596
 597                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
 598
 599                         # A database error has occured so return an error and
 600                         # also the extended error information.
 601
 602                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
 603
 604                 }
 605
 606                 # Work out the total amount of page browse numbers.
 607
 608                 if ($page_total_count ne 0){
 609
 610                         if ($page_total_count eq $page_split){
 611
 612                                 $page_list = int(($page_total_count / $page_split));
 613
 614                         } else {
 615
 616                                 $page_list = int(($page_total_count / $page_split) + 1);
 617
 618                         }
 619
 620                 }
 621
 622                 my $start_from = ($page_browsenumber - 1) * $page_split;
 623
 624                 # Get the list of pages.
 625
 626                 @database_pages = $kiriwrite_dbmodule->getpagelist({ StartFrom => $start_from, Limit => $page_split });
 627
 628                 # Check if any errors had occured while getting the list of pages.
 629
 630                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
 631
 632                         # A database error has occured so return an error and
 633                         # also the extended error information.
 634
 635                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
 636
 637                 }
 638
 639                 # Check if there are any page names in the database array.
 640
 641                 if (@database_pages){
 642
 643                         # Write the start of the page.
 644
 645                         $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{pages}->{pagelist}, $db_name), { Style => "pageheader" });
 646                         $kiriwrite_presmodule->addlinebreak();
 647                         $kiriwrite_presmodule->addlinebreak();
 648                         $kiriwrite_presmodule->startform($kiriwrite_env{"script_filename"}, "POST");
 649                         $kiriwrite_presmodule->startbox();
 650                         $kiriwrite_presmodule->addhiddendata("mode", "page");
 651                         $kiriwrite_presmodule->addhiddendata("database", $database_file);
 652                         $kiriwrite_presmodule->addhiddendata("type", "multiple");
 653
 654                         # Write out the page browsing list.
 655
 656                         $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{showlistpage});
 657                         $kiriwrite_presmodule->addselectbox("browsenumber");
 658
 659                         # Write out the list of available pages to browse.
 660
 661                         while ($page_list_count ne $page_list){
 662
 663                                 $page_list_count++;
 664
 665                                 if ($page_list_count eq 1 && !$page_browsenumber){
 666
 667                                         $kiriwrite_presmodule->addoption($page_list_count, { Value => $page_list_count, Selected => 1 });
 668
 669                                 } else {
 670
 671                                         if ($page_browsenumber eq $page_list_count){
 672
 673                                                 $kiriwrite_presmodule->addoption($page_list_count, { Value => $page_list_count, Selected => 1 });
 674
 675                                         } else {
 676
 677                                                 $kiriwrite_presmodule->addoption($page_list_count, { Value => $page_list_count });
 678
 679                                         }
 680
 681                                 }
 682
 683                         }
 684
 685                         $kiriwrite_presmodule->endselectbox();
 686                         $kiriwrite_presmodule->addbutton("action", { Value => "view", Description => $kiriwrite_lang->{pages}->{show} });
 687
 688
 689                         if ($page_list ne $page_browsenumber){
 690
 691                                 $kiriwrite_presmodule->addtext(" | ");
 692                                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $database_file . "&browsenumber=" . ($page_browsenumber + 1), { Text => $kiriwrite_lang->{pages}->{nextpage} });
 693
 694                         }
 695
 696                         # Check if the page browse number is not blank and
 697                         # not set as 0 and hide the Previous page link if
 698                         # it is.
 699
 700                         if ($page_browsenumber > 1){
 701
 702                                 $kiriwrite_presmodule->addtext(" | ");
 703                                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $database_file . "&browsenumber=" . ($page_browsenumber - 1), { Text => $kiriwrite_lang->{pages}->{previouspage} });
 704
 705                         }
 706
 707                         $kiriwrite_presmodule->addlinebreak();
 708
 709                         # Write the list of multiple selection options.
 710
 711                         $kiriwrite_presmodule->addreset($kiriwrite_lang->{common}->{selectnone});
 712                         $kiriwrite_presmodule->addtext(" | ");
 713                         $kiriwrite_presmodule->addbutton("action", { Value => "multidelete", Description => $kiriwrite_lang->{pages}->{deleteselectedbutton} });
 714                         $kiriwrite_presmodule->addtext(" | ");
 715                         $kiriwrite_presmodule->addbutton("action", { Value => "multimove", Description => $kiriwrite_lang->{pages}->{moveselectedbutton} });
 716                         $kiriwrite_presmodule->addtext(" | ");
 717                         $kiriwrite_presmodule->addbutton("action", { Value => "multicopy", Description => $kiriwrite_lang->{pages}->{copyselectedbutton} });
 718                         $kiriwrite_presmodule->addtext(" | ");
 719                         $kiriwrite_presmodule->addbutton("action", { Value => "multiedit", Description => $kiriwrite_lang->{pages}->{editselectedbutton} });
 720
 721                         $kiriwrite_presmodule->addlinebreak();
 722                         $kiriwrite_presmodule->addlinebreak();
 723                         $kiriwrite_presmodule->endbox();
 724
 725                         # Write the table header.
 726
 727                         $kiriwrite_presmodule->starttable("", { CellPadding => 5, CellSpacing => 0 });
 728                         $kiriwrite_presmodule->startheader();
 729                         $kiriwrite_presmodule->addheader("", { Style => "tablecellheader" });
 730                         $kiriwrite_presmodule->addheader($kiriwrite_lang->{pages}->{pagefilename}, { Style => "tablecellheader" });
 731                         $kiriwrite_presmodule->addheader($kiriwrite_lang->{pages}->{pagename}, { Style => "tablecellheader" });
 732                         $kiriwrite_presmodule->addheader($kiriwrite_lang->{pages}->{pagedescription}, { Style => "tablecellheader" });
 733                         $kiriwrite_presmodule->addheader($kiriwrite_lang->{pages}->{lastmodified}, { Style => "tablecellheader" });
 734                         $kiriwrite_presmodule->addheader($kiriwrite_lang->{common}->{options}, { Style => "tablecellheader" });
 735                         $kiriwrite_presmodule->endheader();
 736
 737                         # Process each page filename and get the page information.
 738
 739                         foreach $page_filename (@database_pages){
 740
 741                                 %page_info = $kiriwrite_dbmodule->getpageinfo({ PageFilename => $page_filename, Reduced => 1 });
 742
 743                                 # Check if any errors have occured.
 744
 745                                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
 746
 747                                         # A database error has occured so return an error and
 748                                         # also the extended error information.
 749
 750                                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
 751
 752                                 } elsif ($kiriwrite_dbmodule->geterror eq "PageDoesNotExist"){
 753
 754                                         # The page does not exist, so process the next page.
 755
 756                                         next;
 757
 758                                 }
 759
 760                                 $page_count++;
 761
 762                                 $page_filename          = $page_info{"PageFilename"};
 763                                 $page_name              = $page_info{"PageName"};
 764                                 $page_description       = $page_info{"PageDescription"};
 765                                 $page_modified          = $page_info{"PageLastModified"};
 766
 767                                 # Set the table cell style.
 768
 769                                 if ($tablestyletype eq 0){
 770
 771                                         $tablestyle = "tablecell1";
 772                                         $tablestyletype = 1;
 773
 774                                 } else {
 775
 776                                         $tablestyle = "tablecell2";
 777                                         $tablestyletype = 0;
 778
 779                                 }
 780
 781                                 # Write out the row of data.
 782
 783                                 $kiriwrite_presmodule->startrow();
 784                                 $kiriwrite_presmodule->addcell($tablestyle);
 785                                 $kiriwrite_presmodule->addhiddendata("id[" . $page_count . "]", $page_filename);
 786                                 $kiriwrite_presmodule->addcheckbox("name[" . $page_count . "]");
 787                                 $kiriwrite_presmodule->endcell();
 788                                 $kiriwrite_presmodule->addcell($tablestyle);
 789                                 $kiriwrite_presmodule->addtext($page_filename);
 790                                 $kiriwrite_presmodule->endcell();
 791                                 $kiriwrite_presmodule->addcell($tablestyle);
 792
 793                                 if (!$page_name){
 794
 795                                         $kiriwrite_presmodule->additalictext($kiriwrite_lang->{blank}->{noname});
 796
 797                                 } else {
 798
 799                                         $kiriwrite_presmodule->addtext($page_name);
 800
 801                                 }
 802
 803                                 $kiriwrite_presmodule->endcell();
 804                                 $kiriwrite_presmodule->addcell($tablestyle);
 805
 806                                 if (!$page_description){
 807
 808                                         $kiriwrite_presmodule->additalictext($kiriwrite_lang->{blank}->{nodescription});
 809
 810                                 } else {
 811
 812                                         $kiriwrite_presmodule->addtext($page_description);
 813
 814                                 }
 815
 816                                 $kiriwrite_presmodule->endcell();
 817                                 $kiriwrite_presmodule->addcell($tablestyle);
 818
 819                                 if (!$page_modified){
 820
 821                                         $kiriwrite_presmodule->additalictext("No Date");
 822
 823                                 } else {
 824
 825                                         $kiriwrite_presmodule->addtext($page_modified);
 826
 827                                 }
 828
 829                                 $kiriwrite_presmodule->endcell();
 830                                 $kiriwrite_presmodule->addcell($tablestyle);
 831                                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"}  . "?mode=page&action=edit&database=" . $database_file . "&page=" . $page_filename, { Text => $kiriwrite_lang->{options}->{edit} });
 832                                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"}  . "?mode=page&action=delete&database=" . $database_file . "&page=" . $page_filename, { Text => $kiriwrite_lang->{options}->{delete} });
 833                                 $kiriwrite_presmodule->endcell();
 834                                 $kiriwrite_presmodule->endrow();
 835
 836                                 # Increment the counter.
 837
 838                         }
 839
 840                 }
 841
 842                 # Disconnect from the database server.
 843
 844                 $kiriwrite_dbmodule->disconnect();
 845
 846                 $kiriwrite_presmodule->endtable();
 847                 $kiriwrite_presmodule->startbox();
 848                 $kiriwrite_presmodule->addhiddendata("count", $page_count);
 849                 $kiriwrite_presmodule->endbox();
 850                 $kiriwrite_presmodule->endform();
 851
 852                 if (!@database_pages && $page_browsenumber > 1){
 853
 854                         # There were no values given for the page browse
 855                         # number given so write a message saying that
 856                         # there were no pages for the page browse number
 857                         # given.
 858
 859                         $kiriwrite_presmodule->clear();
 860                         $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{pages}->{pagelist}, $db_name), { Style => "pageheader" });
 861                         $kiriwrite_presmodule->addlinebreak();
 862                         $kiriwrite_presmodule->addlinebreak();
 863                         $kiriwrite_presmodule->startbox("errorbox");
 864                         $kiriwrite_presmodule->enterdata($kiriwrite_lang->{pages}->{nopagesinpagebrowse});
 865                         $kiriwrite_presmodule->addlinebreak();
 866                         $kiriwrite_presmodule->addlinebreak();
 867                         $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $database_file, { Text => $kiriwrite_lang->{pages}->{returntofirstpagebrowse} });
 868                         $kiriwrite_presmodule->endbox();
 869
 870                 } elsif (!@database_pages || !$page_count){
 871
 872                         # There were no values in the database pages array and
 873                         # the page count had not been incremented so write a
 874                         # message saying that there were no pages in the
 875                         # database.
 876
 877                         $kiriwrite_presmodule->clear();
 878                         $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{pages}->{pagelist}, $db_name), { Style => "pageheader" });
 879                         $kiriwrite_presmodule->addlinebreak();
 880                         $kiriwrite_presmodule->addlinebreak();
 881                         $kiriwrite_presmodule->startbox("errorbox");
 882                         $kiriwrite_presmodule->enterdata($kiriwrite_lang->{pages}->{nopagesindatabase});
 883                         $kiriwrite_presmodule->endbox();
 884
 885                 }
 886
 887                 return $kiriwrite_presmodule->grab();
 888
 889         }
 890
 891 }
 892
 893 sub kiriwrite_page_add{
 894 #################################################################################
 895 # kiriwrite_page_add: Adds a page to a database                                 #
 896 #                                                                               #
 897 # Usage:                                                                        #
 898 #                                                                               #
 899 # kiriwrite_page_add(database, pagefilename, title, description, section,       #
 900 #                       template, settings, info, confirm);                     #
 901 #                                                                               #
 902 # database      Specifies the database name.                                    #
 903 # pagefilename  Specifies the page filename.                                    #
 904 # title         Specifies the page title to be used.                            #
 905 # description   Specifies the short description of the page.                    #
 906 # section       Specifies the section assigned to the page.                     #
 907 # template      Specifies the template to use.                                  #
 908 # settings      Specifies the settings to be used on the page.                  #
 909 # data          Specifies the data which consists the page.                     #
 910 # confirm       Confirms action to add an page.                                 #
 911 #################################################################################
 912
 913         # Fetch the required variables that have been passed to the subroutine.
 914
 915         my ($pagedatabase, $pagefilename, $pagetitle, $pagedescription, $pagesection, $pagetemplate, $pagesettings, $pagefiledata, $confirm) = @_;
 916
 917         # Check if the action to add a new page has been confirmed (or not).
 918
 919         if (!$confirm){
 920
 921                 $confirm = 0;
 922
 923         }
 924
 925         kiriwrite_variablecheck($confirm, "maxlength", 1, 0);
 926
 927         # Check if the database filename is valid and return an error if
 928         # it isn't.
 929
 930         my $pagedatabase_filename_check = kiriwrite_variablecheck($pagedatabase, "filename", 0, 1);
 931
 932         if ($pagedatabase_filename_check eq 1){
 933
 934                 # The database filename is blank, so return an error.
 935
 936                 kiriwrite_error("blankdatabasepageadd");
 937
 938         } elsif ($pagedatabase_filename_check eq 2){
 939
 940                 # The database filename is invalid, so return an error.
 941
 942                 kiriwrite_error("databasefilenameinvalid");
 943
 944         }
 945
 946         # Check the length the database name and return an error if it's
 947         # too long.
 948
 949         my $pagedatabase_length_check   = kiriwrite_variablecheck($pagedatabase, "maxlength", 32, 1);
 950
 951         if ($pagedatabase_length_check eq 1){
 952
 953                 # The database name is too long, so return an error.
 954
 955                 kiriwrite_error("databasefilenametoolong");
 956
 957         }
 958
 959         if ($confirm eq "1"){
 960
 961                 # Check all the variables to see if they UTF8 valid.
 962
 963                 kiriwrite_variablecheck($pagefilename, "utf8", 0, 0);
 964                 kiriwrite_variablecheck($pagetitle, "utf8", 0, 0);
 965                 kiriwrite_variablecheck($pagedescription, "utf8", 0, 0);
 966                 kiriwrite_variablecheck($pagesection, "utf8", 0, 0);
 967                 kiriwrite_variablecheck($pagedatabase, "utf8", 0, 0);
 968                 kiriwrite_variablecheck($pagesettings, "utf8", 0, 0);
 969                 kiriwrite_variablecheck($pagetemplate, "utf8", 0, 0);
 970                 kiriwrite_variablecheck($pagefiledata, "utf8", 0, 0);
 971
 972                 # Convert the values into proper UTF8 values.
 973
 974                 $pagefilename           = kiriwrite_utf8convert($pagefilename);
 975                 $pagetitle              = kiriwrite_utf8convert($pagetitle);
 976                 $pagedescription        = kiriwrite_utf8convert($pagedescription);
 977                 $pagesection            = kiriwrite_utf8convert($pagesection);
 978                 $pagedatabase           = kiriwrite_utf8convert($pagedatabase);
 979                 $pagesettings           = kiriwrite_utf8convert($pagesettings);
 980                 $pagetemplate           = kiriwrite_utf8convert($pagetemplate);
 981                 $pagefiledata           = kiriwrite_utf8convert($pagefiledata);
 982
 983                 # Check all the variables (except for the page data, filename and settings
 984                 # will be checked more specifically later if needed) that were passed to
 985                 # the subroutine.
 986
 987                 my $pagefilename_maxlength_check                = kiriwrite_variablecheck($pagefilename, "maxlength", 256, 1);
 988                 my $pagetitle_maxlength_check                   = kiriwrite_variablecheck($pagetitle, "maxlength", 512, 1);
 989                 my $pagedescription_maxlength_check             = kiriwrite_variablecheck($pagedescription, "maxlength", 512, 1);
 990                 my $pagesection_maxlength_check                 = kiriwrite_variablecheck($pagesection, "maxlength", 256, 1);
 991                 my $pagedatabase_maxlength_check                = kiriwrite_variablecheck($pagedatabase, "maxlength", 32, 1);
 992                 my $pagesettings_maxlength_check                = kiriwrite_variablecheck($pagesettings, "maxlength", 1, 1);
 993                 my $pagetemplate_maxlength_check                = kiriwrite_variablecheck($pagetemplate, "maxlength", 64, 1);
 994
 995                 # Check if an value returned is something else other than 0.
 996
 997                 if ($pagefilename_maxlength_check eq 1){
 998
 999                         # The page filename given is too long, so return an error.
1000
1001                         kiriwrite_error("pagefilenametoolong");
1002
1003                 }
1004
1005                 if ($pagetitle_maxlength_check eq 1){
1006
1007                         # The page title given is too long, so return an error.
1008
1009                         kiriwrite_error("pagetitletoolong");
1010
1011                 }
1012
1013                 if ($pagedescription_maxlength_check eq 1){
1014
1015                         # The page description given is too long, so return an error.
1016
1017                         kiriwrite_error("pagedescriptiontoolong");
1018
1019                 }
1020
1021                 if ($pagesection_maxlength_check eq 1){
1022
1023                         # The page section given is too long, so return an error.
1024
1025                         kiriwrite_error("pagesectiontoolong");
1026
1027                 }
1028
1029                 if ($pagedatabase_maxlength_check eq 1){
1030
1031                         # The page database given is too long, so return an error.
1032
1033                         kiriwrite_error("pagedatabasefilenametoolong");
1034
1035                 }
1036
1037                 if ($pagesettings_maxlength_check eq 1){
1038
1039                         # The page settings given is too long, so return an error.
1040
1041                         kiriwrite_error("pagesettingstoolong");
1042
1043                 }
1044
1045                 if ($pagetemplate_maxlength_check eq 1){
1046
1047                         # The page template given is too long, so return an error.
1048
1049                         kiriwrite_error("pagetemplatefilenametoolong");
1050
1051                 }
1052
1053                 # The action to create a new page has been confirmed, so add the page to the
1054                 # selected database.
1055
1056                 if (!$pagefilename){
1057                         kiriwrite_error("pagefilenameblank");
1058                 }
1059
1060                 # Check the page filename and page settings.
1061
1062                 my $pagefilename_filename_check = kiriwrite_variablecheck($pagefilename, "page_filename", 0, 1);
1063                 my $pagesettings_setting_check  = kiriwrite_variablecheck($pagesettings, "pagesetting", 0, 1);
1064                 my $pagetemplate_filename_check = 0;
1065
1066                 if ($pagetemplate ne "!none"){
1067
1068                         # A template is being used so check the filename of the
1069                         # template.
1070
1071                         $pagetemplate_filename_check    = kiriwrite_variablecheck($pagetemplate, "page_filename", 0, 1);
1072
1073                 }
1074
1075                 if ($pagefilename_filename_check ne 0){
1076
1077                         # The page filename given is invalid, so return an error.
1078
1079                         kiriwrite_error("pagefilenameinvalid");
1080
1081                 }
1082
1083                 if ($pagesettings_setting_check eq 1){
1084
1085                         # The page settings given is invalid, so return an error.
1086
1087                         kiriwrite_error("pagesettingsinvalid");
1088
1089                 }
1090
1091                 if ($pagetemplate_filename_check eq 1){
1092
1093                         # The template filename given is invalid, so return an error
1094
1095                         kiriwrite_error("templatefilenameinvalid");
1096
1097                 }
1098
1099                 # Check if the database has write permissions.
1100
1101                 my $database_permissions = $kiriwrite_dbmodule->dbpermissions($pagedatabase, 1, 1);
1102
1103                 if ($database_permissions eq 1){
1104
1105                         # The database permissions are invalid so return an error.
1106
1107                         kiriwrite_error("databaseinvalidpermissions");
1108
1109                 }
1110
1111                 # Connect to the database server.
1112
1113                 $kiriwrite_dbmodule->connect();
1114
1115                 # Check if any errors occured while connecting to the database server.
1116
1117                 if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
1118
1119                         # A database connection error has occured so return
1120                         # an error.
1121
1122                         kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
1123
1124                 }
1125
1126                 # Select the database to add the page to.
1127
1128                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $pagedatabase });
1129
1130                 # Check if any errors had occured while selecting the database.
1131
1132                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
1133
1134                         # The database does not exist, so return an error.
1135
1136                         kiriwrite_error("databasemissingfile");
1137
1138                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
1139
1140                         # The database has invalid permissions set, so return
1141                         # an error.
1142
1143                         kiriwrite_error("databaseinvalidpermissions");
1144
1145                 }
1146
1147                 # Get information about the database.
1148
1149                 my %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
1150
1151                 # Check if any error occured while getting the database information.
1152
1153                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
1154
1155                         # A database error has occured so return an error and
1156                         # also the extended error information.
1157
1158                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
1159
1160                 };
1161
1162                 # Add the page to the selected database.
1163
1164                 $kiriwrite_dbmodule->addpage({ PageFilename => $pagefilename, PageName => $pagetitle, PageDescription => $pagedescription, PageSection => $pagesection, PageTemplate => $pagetemplate, PageContent => $pagefiledata, PageSettings => $pagesettings });
1165
1166                 # Check if any errors occured while adding the page.
1167
1168                 if ($kiriwrite_dbmodule->geterror eq "PageExists"){
1169
1170                         # A page with the filename given already exists so
1171                         # return an error.
1172
1173                         kiriwrite_error("pagefilenameexists");
1174
1175                 } elsif ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
1176
1177                         # A database error has occured so return an error
1178                         # with extended error information.
1179
1180                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
1181
1182                 }
1183
1184                 my $database_name = $database_info{"DatabaseName"};
1185
1186                 # Disconnect from the database server.
1187
1188                 $kiriwrite_dbmodule->disconnect();
1189
1190                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{addpage}, { Style => "pageheader" });
1191                 $kiriwrite_presmodule->addlinebreak();
1192                 $kiriwrite_presmodule->addlinebreak();
1193                 $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{pages}->{pageaddedmessage}, $pagetitle, $database_name));
1194                 $kiriwrite_presmodule->addlinebreak();
1195                 $kiriwrite_presmodule->addlinebreak();
1196                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $pagedatabase, { Text => kiriwrite_language($kiriwrite_lang->{pages}->{returnpagelist}, $database_name) });
1197
1198                 return $kiriwrite_presmodule->grab();
1199
1200         } elsif ($confirm eq 0) {
1201
1202                 # The action to create a new page has not been confirmed, so print out a form
1203                 # for adding a page to a database.
1204
1205                 my %template_list;
1206                 my %template_info;
1207                 my @templates_list;
1208                 my %database_info;
1209                 my $template_filename;
1210                 my $template_name;
1211                 my $template_data = "";
1212                 my $template_warningmessage;
1213                 my $template_warning = 0;
1214                 my $template_count = 0;
1215                 my $template;
1216
1217                 tie(%template_list, 'Tie::IxHash');
1218
1219                 # Connect to the database server.
1220
1221                 $kiriwrite_dbmodule->connect();
1222
1223                 # Check if any errors occured while connecting to the database server.
1224
1225                 if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
1226
1227                         # A database connection error has occured so return
1228                         # an error.
1229
1230                         kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
1231
1232                 }
1233
1234                 # Select the database.
1235
1236                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $pagedatabase });
1237
1238                 # Check if any errors had occured while selecting the database.
1239
1240                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
1241
1242                         # The database does not exist, so return an error.
1243
1244                         kiriwrite_error("databasemissingfile");
1245
1246                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
1247
1248                         # The database has invalid permissions set, so return
1249                         # an error.
1250
1251                         kiriwrite_error("databaseinvalidpermissions");
1252
1253                 }
1254
1255                 # Check if the database has write permissions.
1256
1257                 my $database_permissions = $kiriwrite_dbmodule->dbpermissions($pagedatabase, 1, 1);
1258
1259                 if ($database_permissions eq 1){
1260
1261                         # The database permissions are invalid so return an error.
1262
1263                         kiriwrite_error("databaseinvalidpermissions");
1264
1265                 }
1266
1267                 # Get information about the database.
1268
1269                 %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
1270
1271                 # Check if any error occured while getting the database information.
1272
1273                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
1274
1275                         # A database error has occured so return an error and
1276                         # also the extended error information.
1277
1278                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
1279
1280                 };
1281
1282                 # Connect to the template database.
1283
1284                 $kiriwrite_dbmodule->connecttemplate();
1285
1286                 # Check if any errors occured while connecting to the template database.
1287
1288                 if ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseDoesNotExist"){
1289
1290                         # The template database does not exist so set the template
1291                         # warning message.
1292
1293                         $template_warningmessage = $kiriwrite_lang->{pages}->{notemplatedatabase};
1294                         $template_warning = 1;
1295
1296                 } elsif ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseInvalidPermissionsSet"){
1297
1298                         # The template database has invalid permissions set so write
1299                         # the template warning message.
1300
1301                         $template_warningmessage = $kiriwrite_lang->{pages}->{templatepermissionserror};
1302                         $template_warning = 1;
1303
1304                 }
1305
1306                 if ($template_warning eq 0){
1307
1308                         # Get the list of templates available.
1309
1310                         @templates_list = $kiriwrite_dbmodule->gettemplatelist();
1311
1312                         # Check if any errors had occured.
1313
1314                         if ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseError"){
1315
1316                                 # A database error occured while getting the list
1317                                 # of templates so return a warning message with the
1318                                 # extended error information.
1319
1320                                 $template_warningmessage = kiriwrite_language($kiriwrite_lang->{pages}->{templatedatabaseerror}, $kiriwrite_dbmodule->geterror(1));
1321                                 $template_warning = 1;
1322
1323                         }
1324
1325                         if ($template_warning eq 0){
1326
1327                                 # Check to see if there are any templates in the templates
1328                                 # list array.
1329
1330                                 my $template_filename = "";
1331                                 my $template_name = "";
1332
1333                                 foreach $template (@templates_list){
1334
1335                                         # Get information about the template.
1336
1337                                         %template_info = $kiriwrite_dbmodule->gettemplateinfo({ TemplateFilename => $template });
1338
1339                                         # Check if any error occured while getting the template information.
1340
1341                                         if ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseError"){
1342
1343                                                 # A database error has occured, so return an error.
1344
1345                                                 kiriwrite_error("templatedatabaseerror", $kiriwrite_dbmodule->geterror(1));
1346
1347                                         } elsif ($kiriwrite_dbmodule->geterror eq "TemplateDoesNotExist"){
1348
1349                                                 # The template does not exist, so process the next template.
1350
1351                                                 next;
1352
1353                                         }
1354
1355                                         # Get the template filename and name.
1356
1357                                         $template_filename = $template_info{"TemplateFilename"};
1358                                         $template_name = $template_info{"TemplateName"};
1359
1360                                         $template_list{$template_count}{Filename} = $template_filename;
1361                                         $template_list{$template_count}{Name} = $template_name;
1362
1363                                         $template_count++;
1364
1365                                 }
1366
1367                                 # Check if the final template list is blank.
1368
1369                                 if (!%template_list){
1370
1371                                         # The template list is blank so write the template
1372                                         # warning message.
1373
1374                                         $template_warningmessage = $kiriwrite_lang->{pages}->{notemplatesavailable};
1375
1376                                 }
1377
1378                         }
1379
1380                 }
1381
1382                 my $database_name       = $database_info{"DatabaseName"};
1383
1384                 # Disconnect from the template database.
1385
1386                 $kiriwrite_dbmodule->disconnecttemplate();
1387
1388                 # Disconnect from the database server.
1389
1390                 $kiriwrite_dbmodule->disconnect();
1391
1392                 # write out the form for adding a page.
1393
1394                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{addpage}, { Style => "pageheader" });
1395                 $kiriwrite_presmodule->startform($kiriwrite_env{"script_filename"}, "POST");#
1396                 $kiriwrite_presmodule->startbox();
1397                 $kiriwrite_presmodule->addhiddendata("mode", "page");
1398                 $kiriwrite_presmodule->addhiddendata("action", "add");
1399                 $kiriwrite_presmodule->addhiddendata("database", $pagedatabase);
1400                 $kiriwrite_presmodule->addhiddendata("confirm", "1");
1401                 $kiriwrite_presmodule->addlinebreak();
1402                 $kiriwrite_presmodule->endbox();
1403                 $kiriwrite_presmodule->starttable("", { CellPadding => 5, CellSpacing => 0 });
1404
1405                 $kiriwrite_presmodule->startheader();
1406                 $kiriwrite_presmodule->addcell("tablecellheader");
1407                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{common}->{setting});
1408                 $kiriwrite_presmodule->endcell();
1409                 $kiriwrite_presmodule->addcell("tablecellheader");
1410                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{common}->{value});
1411                 $kiriwrite_presmodule->endcell();
1412                 $kiriwrite_presmodule->endheader();
1413
1414                 $kiriwrite_presmodule->startrow();
1415                 $kiriwrite_presmodule->addcell("tablecell1");
1416                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{database});
1417                 $kiriwrite_presmodule->endcell();
1418                 $kiriwrite_presmodule->addcell("tablecell2");
1419                 $kiriwrite_presmodule->addtext($database_name);
1420                 $kiriwrite_presmodule->endcell();
1421                 $kiriwrite_presmodule->endrow();
1422
1423                 $kiriwrite_presmodule->startrow();
1424                 $kiriwrite_presmodule->addcell("tablecell1");
1425                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{pagename});
1426                 $kiriwrite_presmodule->endcell();
1427                 $kiriwrite_presmodule->addcell("tablecell2");
1428                 $kiriwrite_presmodule->addinputbox("pagename", { Size => 64, MaxLength => 512 });
1429                 $kiriwrite_presmodule->endcell();
1430                 $kiriwrite_presmodule->endrow();
1431
1432                 $kiriwrite_presmodule->startrow();
1433                 $kiriwrite_presmodule->addcell("tablecell1");
1434                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{pagedescription});
1435                 $kiriwrite_presmodule->endcell();
1436                 $kiriwrite_presmodule->addcell("tablecell2");
1437                 $kiriwrite_presmodule->addinputbox("pagedescription", { Size => 64, MaxLength => 512 });
1438                 $kiriwrite_presmodule->endcell();
1439                 $kiriwrite_presmodule->endrow();
1440
1441                 $kiriwrite_presmodule->startrow();
1442                 $kiriwrite_presmodule->addcell("tablecell1");
1443                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{pagesection});
1444                 $kiriwrite_presmodule->endcell();
1445                 $kiriwrite_presmodule->addcell("tablecell2");
1446                 $kiriwrite_presmodule->addinputbox("pagesection", { Size => 64, MaxLength => 256 });
1447                 $kiriwrite_presmodule->endcell();
1448                 $kiriwrite_presmodule->endrow();
1449
1450                 $kiriwrite_presmodule->startrow();
1451                 $kiriwrite_presmodule->addcell("tablecell1");
1452                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{pagetemplate});
1453                 $kiriwrite_presmodule->endcell();
1454                 $kiriwrite_presmodule->addcell("tablecell2");
1455
1456                 # Check if the template warning value has been set
1457                 # and write the error message in place of the templates
1458                 # list if it is.
1459
1460                 if ($template_warning eq 1){
1461
1462                         $kiriwrite_presmodule->addhiddendata("pagetemplate", "!none");
1463                         $kiriwrite_presmodule->addtext($template_warningmessage);
1464
1465                 } else {
1466
1467                         my $template_file;
1468                         my $page_filename;
1469                         my $page_name;
1470
1471                         $kiriwrite_presmodule->addselectbox("pagetemplate");
1472
1473                         foreach $template_file (keys %template_list){
1474
1475                                 $page_filename  = $template_list{$template_file}{Filename};
1476                                 $page_name      = $template_list{$template_file}{Name};
1477                                 $kiriwrite_presmodule->addoption($page_name . " (" . $page_filename . ")", { Value => $page_filename });
1478                                 $template_count++;
1479
1480                                 $template_count = 0;
1481                         }
1482
1483                         $kiriwrite_presmodule->addoption($kiriwrite_lang->{pages}->{usenotemplate}, { Value => "!none", Selected => 1 });
1484                         $kiriwrite_presmodule->endselectbox();
1485
1486                 }
1487
1488                 $kiriwrite_presmodule->endcell();
1489                 $kiriwrite_presmodule->endrow();
1490
1491                 $kiriwrite_presmodule->startrow();
1492                 $kiriwrite_presmodule->addcell("tablecell1");
1493                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{pagefilename});
1494                 $kiriwrite_presmodule->endcell();
1495                 $kiriwrite_presmodule->addcell("tablecell2");
1496                 $kiriwrite_presmodule->addinputbox("pagefilename", { Size => 64, MaxLength => 256 });
1497                 $kiriwrite_presmodule->endcell();
1498                 $kiriwrite_presmodule->endrow();
1499
1500                 $kiriwrite_presmodule->startrow();
1501                 $kiriwrite_presmodule->addcell("tablecell1");
1502                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{pagecontent});
1503                 $kiriwrite_presmodule->endcell();
1504                 $kiriwrite_presmodule->addcell("tablecell2");
1505                 $kiriwrite_presmodule->addtextbox("pagecontent", { Columns => $kiriwrite_config{"display_textareacols"}, Rows => $kiriwrite_config{"display_textarearows"} });
1506                 $kiriwrite_presmodule->addlinebreak();
1507                 $kiriwrite_presmodule->addlinebreak();
1508                 $kiriwrite_presmodule->startbox("datalist");
1509                 $kiriwrite_presmodule->addboldtext($kiriwrite_lang->{common}->{tags});
1510                 $kiriwrite_presmodule->addlinebreak();
1511                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{common}->{pagetitle});
1512                 $kiriwrite_presmodule->addlinebreak();
1513                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{common}->{pagename});
1514                 $kiriwrite_presmodule->addlinebreak();
1515                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{common}->{pagedescription});
1516                 $kiriwrite_presmodule->addlinebreak();
1517                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{common}->{pagesection});
1518                 $kiriwrite_presmodule->addlinebreak();
1519                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{common}->{pageautosection});
1520                 $kiriwrite_presmodule->addlinebreak();
1521                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{common}->{pageautotitle});
1522                 $kiriwrite_presmodule->addlinebreak();
1523                 $kiriwrite_presmodule->endbox();
1524                 $kiriwrite_presmodule->endcell();
1525                 $kiriwrite_presmodule->endrow();
1526
1527                 $kiriwrite_presmodule->startrow();
1528                 $kiriwrite_presmodule->addcell("tablecell1");
1529                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{pagesettings});
1530                 $kiriwrite_presmodule->endcell();
1531                 $kiriwrite_presmodule->addcell("tablecell2");
1532                 $kiriwrite_presmodule->addradiobox("pagesettings", { Description => $kiriwrite_lang->{pages}->{usepageandsection}, Value => "1", Selected => 1, LineBreak => 1});
1533                 $kiriwrite_presmodule->addradiobox("pagesettings", { Description => $kiriwrite_lang->{pages}->{usepagename}, Value => "2", Selected => 0, LineBreak => 1});
1534                 $kiriwrite_presmodule->addradiobox("pagesettings", { Description => $kiriwrite_lang->{pages}->{usesectionname}, Value => "3", Selected => 0, LineBreak => 1});
1535                 $kiriwrite_presmodule->addradiobox("pagesettings", { Description => $kiriwrite_lang->{pages}->{nopagesection}, Value => "0", Selected => 0, LineBreak => 1});
1536                 $kiriwrite_presmodule->endcell();
1537                 $kiriwrite_presmodule->endrow();
1538
1539                 $kiriwrite_presmodule->endtable();
1540
1541                 $kiriwrite_presmodule->startbox();
1542                 $kiriwrite_presmodule->addlinebreak();
1543                 $kiriwrite_presmodule->addsubmit($kiriwrite_lang->{pages}->{addpagebutton});
1544                 $kiriwrite_presmodule->addtext(" | ");
1545                 $kiriwrite_presmodule->addreset($kiriwrite_lang->{common}->{clearvalues});
1546                 $kiriwrite_presmodule->addtext(" | ");
1547                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $pagedatabase, { Text => kiriwrite_language($kiriwrite_lang->{pages}->{returnpagelist}, $database_name) });
1548                 $kiriwrite_presmodule->endbox();
1549                 $kiriwrite_presmodule->endform();
1550
1551
1552                 return $kiriwrite_presmodule->grab();
1553
1554         } else {
1555
1556                 # The confirm value is something else than '1' or '0' so
1557                 # return an error.
1558
1559                 kiriwrite_error("invalidvalue");
1560
1561         }
1562
1563
1564
1565 }
1566
1567 sub kiriwrite_page_delete{
1568 #################################################################################
1569 # kiriwrite_page_delete: Deletes a (single) page from a database.               #
1570 #                                                                               #
1571 # Usage:                                                                        #
1572 #                                                                               #
1573 # kiriwrite_page_delete(database, page, [confirm]);                             #
1574 #                                                                               #
1575 # database      Specifies the database to delete from.                          #
1576 # page          Specifies the page to delete.                                   #
1577 # confirm       Confirms the action to delete the page.                         #
1578 #################################################################################
1579
1580         my ($database, $page, $confirm) = @_;
1581
1582         # Check if the database filename is valid and return an error if
1583         # it isn't.
1584
1585         my $pagedatabase_filename_check = kiriwrite_variablecheck($database, "filename", 0, 1);
1586
1587         if ($pagedatabase_filename_check eq 1){
1588
1589                 # The database filename is blank, so return an error.
1590
1591                 kiriwrite_error("blankdatabasepageadd");
1592
1593         } elsif ($pagedatabase_filename_check eq 2){
1594
1595                 # The database filename is invalid, so return an error.
1596
1597                 kiriwrite_error("databasefilenameinvalid");
1598
1599         }
1600
1601         # Check the length the database name and return an error if it's
1602         # too long.
1603
1604         my $pagedatabase_length_check   = kiriwrite_variablecheck($database, "maxlength", 32, 1);
1605
1606         if ($pagedatabase_length_check eq 1){
1607
1608                 # The database name is too long, so return an error.
1609
1610                 kiriwrite_error("databasefilenametoolong");
1611
1612         }
1613
1614         # Check if the page name is specified is blank and return an error if
1615         # it is.
1616
1617         if (!$page){
1618
1619                 # The page name is blank, so return an error.
1620
1621                 kiriwrite_error("blankfilename");
1622
1623         }
1624
1625         # If the confirm value is blank, then set the confirm value to 0.
1626
1627         if (!$confirm){
1628
1629                 $confirm = 0;
1630
1631         }
1632
1633         if ($confirm eq 1){
1634
1635                 # The action to delete the selected page from the database
1636                 # has been confirmed.
1637
1638                 # Connect to the database server.
1639
1640                 $kiriwrite_dbmodule->connect();
1641
1642                 # Check if any errors occured while connecting to the database server.
1643
1644                 if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
1645
1646                         # A database connection error has occured so return
1647                         # an error.
1648
1649                         kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
1650
1651                 }
1652
1653                 # Select the database to delete the page from.
1654
1655                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $database });
1656
1657                 # Check if any errors had occured while selecting the database.
1658
1659                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
1660
1661                         # The database does not exist, so return an error.
1662
1663                         kiriwrite_error("databasemissingfile");
1664
1665                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
1666
1667                         # The database has invalid permissions set, so return
1668                         # an error.
1669
1670                         kiriwrite_error("databaseinvalidpermissions");
1671
1672                 }
1673
1674                 # Check if the database has write permissions.
1675
1676                 my $database_permissions = $kiriwrite_dbmodule->dbpermissions($database, 1, 1);
1677
1678                 if ($database_permissions eq 1){
1679
1680                         # The database permissions are invalid so return an error.
1681
1682                         kiriwrite_error("databaseinvalidpermissions");
1683
1684                 }
1685
1686                 # Get the information about the database.
1687
1688                 my %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
1689
1690                 # Check if any error occured while getting the database information.
1691
1692                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
1693
1694                         # A database error has occured so return an error and
1695                         # also the extended error information.
1696
1697                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
1698
1699                 }
1700
1701                 # Get the information about the page that is going to be deleted.
1702
1703                 my %page_info = $kiriwrite_dbmodule->getpageinfo({ PageFilename => $page });
1704
1705                 # Check if any errors occured while getting the page information.
1706
1707                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
1708
1709                         # A database error has occured so return an error and
1710                         # also the extended error information.
1711
1712                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
1713
1714                 } elsif ($kiriwrite_dbmodule->geterror eq "PageDoesNotExist"){
1715
1716                         # The page does not exist, so return an error.
1717
1718                         kiriwrite_error("pagefilenamedoesnotexist");
1719
1720                 }
1721
1722                 # Delete the page from the database.
1723
1724                 $kiriwrite_dbmodule->deletepage({ PageFilename => $page });
1725
1726                 # Check if any errors occured while deleting the page from the database.
1727
1728                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
1729
1730                         # A database error has occured so return an error and
1731                         # also the extended error information.
1732
1733                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
1734
1735                 } elsif ($kiriwrite_dbmodule->geterror eq "PageDoesNotExist"){
1736
1737                         # The page does not exist, so return an error.
1738
1739                         kiriwrite_error("pagefilenamedoesnotexist");
1740
1741                 }
1742
1743                 # Get the database name and page name.
1744
1745                 my $database_name       = $database_info{"DatabaseName"};
1746                 my $page_name           = $page_info{"PageName"};
1747
1748                 # Disconnect from the database server.
1749
1750                 $kiriwrite_dbmodule->disconnect();
1751
1752                 # Write out a message saying that the selected page from
1753                 # the database has been deleted.
1754
1755                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{pagedeleted}, { Style => "pageheader" });
1756                 $kiriwrite_presmodule->addlinebreak();
1757                 $kiriwrite_presmodule->addlinebreak();
1758                 $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{pages}->{pagedeletedmessage}, $page_name, $database_name));
1759                 $kiriwrite_presmodule->addlinebreak();
1760                 $kiriwrite_presmodule->addlinebreak();
1761                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $database, { Text => kiriwrite_language($kiriwrite_lang->{pages}->{returnpagelist}, $database_name)});
1762
1763                 return $kiriwrite_presmodule->grab();
1764
1765         } elsif ($confirm eq 0){
1766
1767                 # Connect to the database server.
1768
1769                 $kiriwrite_dbmodule->connect();
1770
1771                 # Check if any errors occured while connecting to the database server.
1772
1773                 if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
1774
1775                         # A database connection error has occured so return
1776                         # an error.
1777
1778                         kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
1779
1780                 }
1781
1782                 # Select the database.
1783
1784                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $database });
1785
1786                 # Check if any errors had occured while selecting the database.
1787
1788                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
1789
1790                         # The database does not exist, so return an error.
1791
1792                         kiriwrite_error("databasemissingfile");
1793
1794                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
1795
1796                         # The database has invalid permissions set, so return
1797                         # an error.
1798
1799                         kiriwrite_error("databaseinvalidpermissions");
1800
1801                 }
1802
1803                 # Get information about the database.
1804
1805                 my %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
1806
1807                 # Check if any errors occured while getting the database information.
1808
1809                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
1810
1811                         # A database error has occured so return an error and
1812                         # also the extended error information.
1813
1814                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
1815
1816                 }
1817
1818                 # Get information about the page that is going to be deleted.
1819
1820                 my %page_info = $kiriwrite_dbmodule->getpageinfo({ PageFilename => $page });
1821
1822                 # Check if any errors occured while getting the page information.
1823
1824                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
1825
1826                         # A database error has occured so return an error and
1827                         # also the extended error information.
1828
1829                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
1830
1831                 } elsif ($kiriwrite_dbmodule->geterror eq "PageDoesNotExist"){
1832
1833                         # The page does not exist, so return an error.
1834
1835                         kiriwrite_error("pagefilenamedoesnotexist");
1836
1837                 }
1838
1839                 my $database_name       = $database_info{"DatabaseName"};
1840                 my $page_name           = $page_info{"PageName"};
1841
1842                 # Disconnect from the database server.
1843
1844                 $kiriwrite_dbmodule->disconnect();
1845
1846                 # Write a message asking the user to confirm the deletion of the
1847                 # page.
1848
1849                 $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{pages}->{deletepage}, $page_name), { Style => "pageheader" });
1850                 $kiriwrite_presmodule->startform($kiriwrite_env{"script_filename"}, "POST");
1851                 $kiriwrite_presmodule->startbox();
1852                 $kiriwrite_presmodule->addhiddendata("mode", "page");
1853                 $kiriwrite_presmodule->addhiddendata("action", "delete");
1854                 $kiriwrite_presmodule->addhiddendata("database", $database);
1855                 $kiriwrite_presmodule->addhiddendata("page", $page);
1856                 $kiriwrite_presmodule->addhiddendata("confirm", "1");
1857                 $kiriwrite_presmodule->addlinebreak();
1858                 $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{pages}->{deletepagemessage}, $page_name, $database_name));
1859                 $kiriwrite_presmodule->addlinebreak();
1860                 $kiriwrite_presmodule->addlinebreak();
1861                 $kiriwrite_presmodule->addsubmit($kiriwrite_lang->{pages}->{deletepagebutton});
1862                 $kiriwrite_presmodule->addtext(" | ");
1863                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $database, { Text => kiriwrite_language($kiriwrite_lang->{pages}->{deletepagesreturnlink}, $database_name)});
1864                 $kiriwrite_presmodule->endbox();
1865                 $kiriwrite_presmodule->endform();
1866
1867                 return $kiriwrite_presmodule->grab();
1868
1869         } else {
1870
1871                 # Another page deletion type was specified, so return an error.
1872
1873                 kiriwrite_error("invalidoption");
1874
1875         }
1876
1877 }
1878
1879 sub kiriwrite_page_edit{
1880 #################################################################################
1881 # kiriwrite_page_edit: Edits a page from a database.                            #
1882 #                                                                               #
1883 # Usage:                                                                        #
1884 #                                                                               #
1885 # kiriwrite_page_edit(database, filename, newfilename, newname, newdescription, #
1886 #                       newsection, newtemplate,  newsettings, newpagecontent   #
1887 #                       confirm);                                               #
1888 #                                                                               #
1889 # database       Specifies the database to edit from.                           #
1890 # filename       Specifies the filename to use.                                 #
1891 # newfilename    Specifies the new page filename to use.                        #
1892 # newname        Specifies the new page name to use.                            #
1893 # newdescription Specifies the new description for the page.                    #
1894 # newsection     Specifies the new section name to use.                         #
1895 # newtemplate    Specifies the new template filename to use.                    #
1896 # newsettings    Specifies the new page settings to use.                        #
1897 # newpagecontent Specifies the new page content to use.                         #
1898 # confirm        Confirms the action to edit the page.                          #
1899 #################################################################################
1900
1901         # Get the values that have been passed to the subroutine.
1902
1903         my ($database, $pagefilename, $pagenewfilename, $pagenewtitle, $pagenewdescription, $pagenewsection, $pagenewtemplate, $pagenewsettings, $pagenewcontent, $confirm) = @_;
1904
1905         # Check if the confirm value is blank and if it is, then set it to '0'.
1906
1907         if (!$confirm){
1908
1909                 $confirm = 0;
1910
1911         }
1912
1913         # Check if the confirm value is more than one character long and if it
1914         # is then return an error.
1915
1916         kiriwrite_variablecheck($confirm, "maxlength", 1, 0);
1917
1918         # Check if the database filename is valid and return an error if
1919         # it isn't.
1920
1921         my $pagedatabase_filename_check = kiriwrite_variablecheck($database, "filename", 0, 1);
1922
1923         if ($pagedatabase_filename_check eq 1){
1924
1925                 # The database filename is blank, so return an error.
1926
1927                 kiriwrite_error("blankdatabasepageadd");
1928
1929         } elsif ($pagedatabase_filename_check eq 2){
1930
1931                 # The database filename is invalid, so return an error.
1932
1933                 kiriwrite_error("databasefilenameinvalid");
1934
1935         }
1936
1937         # Check the length the database name and return an error if it's
1938         # too long.
1939
1940         my $pagedatabase_length_check   = kiriwrite_variablecheck($database, "maxlength", 32, 1);
1941
1942         if ($pagedatabase_length_check eq 1){
1943
1944                 # The database name is too long, so return an error.
1945
1946                 kiriwrite_error("databasefilenametoolong");
1947
1948         }
1949
1950         # Check if the page identification number is blank (which it shouldn't
1951         # be) and if it is, then return an error.
1952
1953         if (!$pagefilename){
1954
1955                 kiriwrite_error("blankfilename");
1956
1957         }
1958
1959         # Check if the confirm value is '1' and if it is, edit the specified
1960         # page in the database.
1961
1962         if ($confirm eq 1){
1963
1964                 # Check if the new page filename is blank.
1965
1966                 if (!$pagenewfilename){
1967
1968                         # The page filename is blank so return an error.
1969
1970                         kiriwrite_error("pagefilenameblank");
1971
1972                 }
1973
1974                 # The action to edit a page has been confirmed so check the
1975                 # variables recieved are UTF8 compiliant before converting.
1976
1977                 kiriwrite_variablecheck($database, "utf8", 0, 0);
1978                 kiriwrite_variablecheck($pagefilename, "utf8", 0, 0);
1979                 kiriwrite_variablecheck($pagenewfilename, "utf8", 0, 0);
1980                 kiriwrite_variablecheck($pagenewtitle, "utf8", 0, 0);
1981                 kiriwrite_variablecheck($pagenewdescription, "utf8", 0, 0);
1982                 kiriwrite_variablecheck($pagenewsection, "utf8", 0, 0);
1983                 kiriwrite_variablecheck($pagenewsettings, "utf8", 0, 0);
1984                 kiriwrite_variablecheck($pagenewtemplate, "utf8", 0, 0);
1985                 kiriwrite_variablecheck($pagenewcontent, "utf8", 0, 0);
1986
1987                 # Convert the variables into proper UTF8 variables.
1988
1989                 $database               = kiriwrite_utf8convert($database);
1990                 $pagefilename           = kiriwrite_utf8convert($pagefilename);
1991                 $pagenewfilename        = kiriwrite_utf8convert($pagenewfilename);
1992                 $pagenewtitle           = kiriwrite_utf8convert($pagenewtitle);
1993                 $pagenewdescription     = kiriwrite_utf8convert($pagenewdescription);
1994                 $pagenewsection         = kiriwrite_utf8convert($pagenewsection);
1995                 $pagenewsettings        = kiriwrite_utf8convert($pagenewsettings);
1996                 $pagenewtemplate        = kiriwrite_utf8convert($pagenewtemplate);
1997                 $pagenewcontent         = kiriwrite_utf8convert($pagenewcontent);
1998
1999                 # Check the lengths of the variables.
2000
2001                 my $pagenewfilename_maxlength_check     = kiriwrite_variablecheck($pagenewfilename, "maxlength", 256, 1);
2002                 my $pagenewtitle_maxlength_check        = kiriwrite_variablecheck($pagenewtitle, "maxlength", 512, 1);
2003                 my $pagenewdescription_maxlength_check  = kiriwrite_variablecheck($pagenewdescription, "maxlength", 512, 1);
2004                 my $pagenewsection_maxlength_check      = kiriwrite_variablecheck($pagenewsection, "maxlength", 256, 1);
2005                 my $pagenewsettings_maxlength_check     = kiriwrite_variablecheck($pagenewsettings, "maxlength", 1, 1);
2006                 my $pagenewtemplate_maxlength_check     = kiriwrite_variablecheck($pagenewtemplate, "maxlength", 64, 1);
2007
2008                 # Check each result to see if the length of the variable
2009                 # is valid and return an error if it isn't.
2010
2011                 if ($pagenewfilename_maxlength_check eq 1){
2012
2013                         # The new page filename given is too long, so return an error.
2014
2015                         kiriwrite_error("pagefilenametoolong");
2016
2017                 }
2018
2019                 if ($pagenewtitle_maxlength_check eq 1){
2020
2021                         # The new page title given is too long, so return an error.
2022
2023                         kiriwrite_error("pagetitletoolong");
2024
2025                 }
2026
2027                 if ($pagenewdescription_maxlength_check eq 1){
2028
2029                         # The new page description given is too long, so return an error.
2030
2031                         kiriwrite_error("pagedescriptiontoolong");
2032
2033                 }
2034
2035                 if ($pagenewsection_maxlength_check eq 1){
2036
2037                         # The new page section given is too long, so return an error.
2038
2039                         kiriwrite_error("pagesectiontoolong");
2040
2041                 }
2042
2043                 if ($pagenewsettings_maxlength_check eq 1){
2044
2045                         # The new page settings given is too long, so return an error.
2046
2047                         kiriwrite_error("pagesettingstoolong");
2048
2049                 }
2050
2051                 if ($pagenewtemplate_maxlength_check eq 1){
2052
2053                         # The new page template given is too long, so return an error.
2054
2055                         kiriwrite_error("pagetemplatefilenametoolong");
2056
2057                 }
2058
2059                 # Check if the new page filename and new page settings
2060                 # are valid.
2061
2062                 my $pagenewfilename_filename_check      = kiriwrite_variablecheck($pagenewfilename, "page_filename", 0, 1);
2063                 my $pagenewsettings_settings_check      = kiriwrite_variablecheck($pagenewsettings, "pagesetting", 0, 1);
2064                 my $pagetemplate_filename_check = 0;
2065
2066                 if ($pagenewtemplate ne "!none"){
2067
2068                         # A template is being used so check the filename of the
2069                         # template.
2070
2071                         $pagetemplate_filename_check    = kiriwrite_variablecheck($pagenewtemplate, "page_filename", 0, 1);
2072
2073                 }
2074
2075                 # Check each result to see if the variables have passed
2076                 # their tests and return an error if they haven't.
2077
2078                 if ($pagenewfilename_filename_check ne 0){
2079
2080                         # The new page filename is invalid, so return an error.
2081
2082                         kiriwrite_error("pagefilenameinvalid");
2083
2084                 }
2085
2086                 if ($pagenewsettings_settings_check eq 1){
2087
2088                         # The new page settings is invalid, so return an error.
2089
2090                         kiriwrite_error("pagesettingsinvalid");
2091
2092                 }
2093
2094                 if ($pagetemplate_filename_check eq 1){
2095
2096                         # The template filename given is invalid, so return an error
2097
2098                         kiriwrite_error("templatefilenameinvalid");
2099
2100                 }
2101
2102                 # Connect to the database server.
2103
2104                 $kiriwrite_dbmodule->connect();
2105
2106                 # Check if any errors occured while connecting to the database server.
2107
2108                 if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
2109
2110                         # A database connection error has occured so return
2111                         # an error.
2112
2113                         kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
2114
2115                 }
2116
2117                 # Select the database.
2118
2119                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $database });
2120
2121                 # Check if any errors had occured while selecting the database.
2122
2123                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
2124
2125                         # The database does not exist, so return an error.
2126
2127                         kiriwrite_error("databasemissingfile");
2128
2129                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
2130
2131                         # The database has invalid permissions set, so return
2132                         # an error.
2133
2134                         kiriwrite_error("databaseinvalidpermissions");
2135
2136                 }
2137
2138                 # Check if the database has write permissions.
2139
2140                 my $database_permissions = $kiriwrite_dbmodule->dbpermissions($database, 1, 1);
2141
2142                 if ($database_permissions eq 1){
2143
2144                         # The database permissions are invalid so return an error.
2145
2146                         kiriwrite_error("databaseinvalidpermissions");
2147
2148                 }
2149
2150                 # Get the database information.
2151
2152                 my %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
2153
2154                 # Check if any errors had occured while getting the database information.
2155
2156                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
2157
2158                         # A database error has occured so return an error and
2159                         # also the extended error information.
2160
2161                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
2162
2163                 };
2164
2165                 my $database_name = $database_info{"DatabaseName"};
2166
2167                 # Edit the selected page.
2168
2169                 $kiriwrite_dbmodule->editpage({ PageFilename => $pagefilename, PageNewFilename => $pagenewfilename, PageNewName => $pagenewtitle, PageNewDescription => $pagenewdescription, PageNewSection => $pagenewsection, PageNewTemplate => $pagenewtemplate, PageNewContent => $pagenewcontent, PageNewSettings => $pagenewsettings });
2170
2171                 # Check if any errors occured while editing the page.
2172
2173                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
2174
2175                         # A database error has occured so return an error and
2176                         # also the extended error information.
2177
2178                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
2179
2180                 } elsif ($kiriwrite_dbmodule->geterror eq "PageDoesNotExist"){
2181
2182                         # The pages does not exist in the database.
2183
2184                         kiriwrite_error("pagefilenamedoesnotexist");
2185
2186                 } elsif ($kiriwrite_dbmodule->geterror eq "PageExists"){
2187
2188                         # A page already exists with the new filename.
2189
2190                         kiriwrite_error("pagefilenameexists");
2191
2192                 }
2193
2194                 # Disconnect from the database server.
2195
2196                 $kiriwrite_dbmodule->disconnect();
2197
2198                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{editedpage}, { Style => "pageheader" });
2199                 $kiriwrite_presmodule->addlinebreak();
2200                 $kiriwrite_presmodule->addlinebreak();
2201                 $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{pages}->{editedpagemessage}, $pagenewtitle));
2202                 $kiriwrite_presmodule->addlinebreak();
2203                 $kiriwrite_presmodule->addlinebreak();
2204                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $database, { Text => kiriwrite_language($kiriwrite_lang->{pages}->{returnpagelist}, $database_name) });
2205
2206                 return $kiriwrite_presmodule->grab();
2207
2208         } elsif ($confirm eq 0) {
2209
2210                 # Connect to the database server.
2211
2212                 $kiriwrite_dbmodule->connect();
2213
2214                 # Check if any errors occured while connecting to the database server.
2215
2216                 if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
2217
2218                         # A database connection error has occured so return
2219                         # an error.
2220
2221                         kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
2222
2223                 }
2224
2225                 # Select the database.
2226
2227                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $database });
2228
2229                 # Check if any errors had occured while selecting the database.
2230
2231                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
2232
2233                         # The database does not exist, so return an error.
2234
2235                         kiriwrite_error("databasemissingfile");
2236
2237                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
2238
2239                         # The database has invalid permissions set, so return
2240                         # an error.
2241
2242                         kiriwrite_error("databaseinvalidpermissions");
2243
2244                 }
2245
2246                 # Get the information about the database.
2247
2248                 my %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
2249
2250                 # Check if any errors had occured while getting the database information.
2251
2252                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
2253
2254                         # A database error has occured so return an error and
2255                         # also the extended error information.
2256
2257                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
2258
2259                 };
2260
2261                 my $database_name = $database_info{"DatabaseName"};
2262
2263                 # Get the page info.
2264
2265                 my %page_info = $kiriwrite_dbmodule->getpageinfo({ PageFilename => $pagefilename });
2266
2267                 # Check if any errors occured while getting the page information.
2268
2269                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
2270
2271                         # A database error has occured so return an error and
2272                         # also the extended error information.
2273
2274                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
2275
2276                 } elsif ($kiriwrite_dbmodule->geterror eq "PageDoesNotExist"){
2277
2278                         # The page does not exist, so return an error.
2279
2280                         kiriwrite_error("pagefilenamedoesnotexist");
2281
2282                 }
2283
2284                 # Get the values from the hash.
2285
2286                 my $data_filename               = $page_info{"PageFilename"};
2287                 my $data_name                   = $page_info{"PageName"};
2288                 my $data_description            = $page_info{"PageDescription"};
2289                 my $data_section                = $page_info{"PageSection"};
2290                 my $data_template               = $page_info{"PageTemplate"};
2291                 my $data_content                = $page_info{"PageContent"};
2292                 my $data_settings               = $page_info{"PageSettings"};
2293                 my $data_lastmodified           = $page_info{"PageLastModified"};
2294
2295                 my $template_warning;
2296                 my $page_count = 0;
2297                 my %template_list;
2298                 my %template_info;
2299                 my @database_pages;
2300                 my @database_info;
2301                 my @database_templates;
2302                 my @template_filenames;
2303                 my $template_file;
2304                 my $template_filename;
2305                 my $template_name;
2306                 my $template_count = 0;
2307                 my $template_found = 0;
2308
2309                 tie(%template_list, 'Tie::IxHash');
2310
2311                 # Connect to the template database.
2312
2313                 $kiriwrite_dbmodule->connecttemplate();
2314
2315                 # Check if any errors occured while connecting to the template database.
2316
2317                 if ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseDoesNotExist"){
2318
2319                         # The template database does not exist so set the template
2320                         # warning message.
2321
2322                         $template_warning = $kiriwrite_lang->{pages}->{notemplatedatabasekeep};
2323
2324                 } elsif ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseInvalidPermissionsSet"){
2325
2326                         # The template database has invalid permissions set so write
2327                         # the template warning message.
2328
2329                         $template_warning = $kiriwrite_lang->{pages}->{templatepermissionserrorkeep};
2330
2331                 }
2332
2333                 if (!$template_warning){
2334
2335                         # Get the list of available templates.
2336
2337                         @template_filenames = $kiriwrite_dbmodule->gettemplatelist();
2338
2339                         # Check if any errors had occured.
2340
2341                         if ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseError"){
2342
2343                                 # A database error occured while getting the list
2344                                 # of templates so return an error with the
2345                                 # extended error information.
2346
2347                                 $template_warning = kiriwrite_language($kiriwrite_lang->{pages}->{templatedatabaseerrorkeep} , $kiriwrite_dbmodule->geterror(1));
2348
2349                         }
2350
2351                         if (!$template_warning){
2352
2353                                 foreach $template_filename (@template_filenames){
2354
2355                                         # Get the information about each template.
2356
2357                                         %template_info = $kiriwrite_dbmodule->gettemplateinfo({ TemplateFilename => $template_filename });
2358
2359                                         # Check if any errors occured while getting the template information.
2360
2361                                         if ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseError"){
2362
2363                                                 # A template database error has occured so return a warning message
2364                                                 # with the extended error information.
2365
2366                                                 $template_warning = kiriwrite_language($kiriwrite_lang->{pages}->{templatedatabaseerrorkeep} , $kiriwrite_dbmodule->geterror(1));
2367                                                 last;
2368
2369                                         } elsif ($kiriwrite_dbmodule->geterror eq "TemplateDoesNotExist"){
2370
2371                                                 # The template does not exist so process the next template.
2372
2373                                                 next;
2374
2375                                         }
2376
2377                                         # Append the template name and filename to the list of available templates.
2378
2379                                         $template_list{$template_count}{Filename} = $template_info{"TemplateFilename"};
2380                                         $template_list{$template_count}{Name}     = $template_info{"TemplateName"};
2381
2382                                         # Append the template filename and name and make it the selected
2383                                         # template if that is the template the page is using.
2384
2385                                         if ($data_template eq $template_filename && !$template_found){
2386
2387                                                 $template_list{$template_count}{Selected}       = 1;
2388                                                 $template_found = 1;
2389
2390                                         } else {
2391
2392                                                 $template_list{$template_count}{Selected}       = 0;
2393
2394                                         }
2395
2396                                         $template_count++;
2397
2398                                 }
2399
2400                         }
2401
2402                 }
2403
2404                 # Check if certain values are undefined and if they
2405                 # are then set them blank (defined).
2406
2407                 if (!$data_name){
2408                         $data_name = "";
2409                 }
2410
2411                 if (!$data_description){
2412                         $data_description = "";
2413                 }
2414
2415                 if (!$data_section){
2416                         $data_section = "";
2417                 }
2418
2419                 if (!$data_template){
2420                         $data_template = "";
2421
2422                 }
2423
2424                 if (!$data_content){
2425                         $data_content = "";
2426                 }
2427
2428                 if (!$data_settings){
2429                         $data_settings = "";
2430                 }
2431
2432                 if (!$data_lastmodified){
2433                         $data_lastmodified = "";
2434                 }
2435
2436                 # Begin writing out the form for editing the selected page.
2437
2438                 $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{pages}->{editpage}, $data_name), { Style => "pageheader" });
2439                 $kiriwrite_presmodule->addlinebreak();
2440                 $kiriwrite_presmodule->addlinebreak();
2441
2442                 $kiriwrite_presmodule->startform($kiriwrite_env{"script_filename"}, "POST");
2443                 $kiriwrite_presmodule->startbox();
2444                 $kiriwrite_presmodule->addhiddendata("mode", "page");
2445                 $kiriwrite_presmodule->addhiddendata("action", "edit");
2446                 $kiriwrite_presmodule->addhiddendata("database", $database);
2447                 $kiriwrite_presmodule->addhiddendata("page", $pagefilename);
2448                 $kiriwrite_presmodule->addhiddendata("confirm", 1);
2449                 $kiriwrite_presmodule->endbox();
2450
2451                 $kiriwrite_presmodule->starttable("", { CellPadding => 5, CellSpacing => 0 });
2452
2453                 $kiriwrite_presmodule->startheader();
2454                 $kiriwrite_presmodule->addheader($kiriwrite_lang->{common}->{setting}, { Style => "tablecellheader" });
2455                 $kiriwrite_presmodule->addheader($kiriwrite_lang->{common}->{value}, { Style => "tablecellheader" });
2456                 $kiriwrite_presmodule->endheader();
2457
2458                 $kiriwrite_presmodule->startrow();
2459                 $kiriwrite_presmodule->addcell("tablecell1");
2460                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{database});
2461                 $kiriwrite_presmodule->endcell();
2462                 $kiriwrite_presmodule->addcell("tablecell2");
2463                 $kiriwrite_presmodule->addtext($database_name);
2464                 $kiriwrite_presmodule->endcell();
2465                 $kiriwrite_presmodule->endrow();
2466
2467                 $kiriwrite_presmodule->startrow();
2468                 $kiriwrite_presmodule->addcell("tablecell1");
2469                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{pagename});
2470                 $kiriwrite_presmodule->endcell();
2471                 $kiriwrite_presmodule->addcell("tablecell2");
2472                 $kiriwrite_presmodule->addinputbox("pagename", { Size => 64, MaxLength => 512, Value => $data_name });
2473                 $kiriwrite_presmodule->endcell();
2474                 $kiriwrite_presmodule->endrow();
2475
2476                 $kiriwrite_presmodule->startrow();
2477                 $kiriwrite_presmodule->addcell("tablecell1");
2478                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{pagedescription});
2479                 $kiriwrite_presmodule->endcell();
2480                 $kiriwrite_presmodule->addcell("tablecell2");
2481                 $kiriwrite_presmodule->addinputbox("pagedescription", { Size => 64, MaxLength => 512, Value => $data_description });
2482                 $kiriwrite_presmodule->endcell();
2483                 $kiriwrite_presmodule->endrow();
2484
2485                 $kiriwrite_presmodule->startrow();
2486                 $kiriwrite_presmodule->addcell("tablecell1");
2487                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{pagesection});
2488                 $kiriwrite_presmodule->endcell();
2489                 $kiriwrite_presmodule->addcell("tablecell2");
2490                 $kiriwrite_presmodule->addinputbox("pagesection", { Size => 64, MaxLength => 256, Value => $data_section });
2491                 $kiriwrite_presmodule->endcell();
2492                 $kiriwrite_presmodule->endrow();
2493
2494                 $kiriwrite_presmodule->startrow();
2495                 $kiriwrite_presmodule->addcell("tablecell1");
2496                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{pagetemplate});
2497                 $kiriwrite_presmodule->endcell();
2498                 $kiriwrite_presmodule->addcell("tablecell2");
2499
2500                 # Check if any template warnings have occured.
2501
2502                 if ($template_warning){
2503
2504                         $kiriwrite_presmodule->addtext($template_warning);
2505                         $kiriwrite_presmodule->addlinebreak();
2506
2507                 }
2508
2509                 $kiriwrite_presmodule->addselectbox("pagetemplate");
2510
2511                 # Process the list of templates, select one if the
2512                 # template filename for the page matches, else give
2513                 # an option for the user to keep the current template
2514                 # filename.
2515
2516                 $template_count = 0;
2517
2518                 foreach $template_file (keys %template_list){
2519
2520                         if ($template_list{$template_count}{Selected}){
2521
2522                                 $kiriwrite_presmodule->addoption($template_list{$template_count}{Name} . " (" . $template_list{$template_count}{Filename} . ")", { Value => $template_list{$template_count}{Filename}, Selected => 1 });
2523
2524                         } else {
2525
2526                                 $kiriwrite_presmodule->addoption($template_list{$template_count}{Name} . " (" . $template_list{$template_count}{Filename} . ")", { Value => $template_list{$template_count}{Filename} });
2527
2528                         }
2529
2530                         $template_count++;
2531
2532                 }
2533
2534                 if ($data_template eq "!none"){
2535
2536                         $kiriwrite_presmodule->addoption($kiriwrite_lang->{pages}->{usenotemplate}, { Value => "!none", Selected => 1 });
2537                         $template_found = 1;
2538
2539                 } else {
2540
2541                         $kiriwrite_presmodule->addoption($kiriwrite_lang->{pages}->{usenotemplate}, { Value => "!none" });
2542
2543                 }
2544
2545                 if ($template_found eq 0 && $data_template ne "!none"){
2546
2547                         # The template with the filename given was not found.
2548
2549                         $kiriwrite_presmodule->addoption(kiriwrite_language($kiriwrite_lang->{pages}->{keeptemplatefilename}, $data_template), { Value => $data_template, Selected => 1, Style => "warningoption" });
2550
2551                 }
2552
2553                 # Disconnect from the template database.
2554
2555                 $kiriwrite_dbmodule->disconnecttemplate();
2556
2557                 # Disconnect from the database server.
2558
2559                 $kiriwrite_dbmodule->disconnect();
2560
2561                 $kiriwrite_presmodule->endselectbox();
2562
2563                 $kiriwrite_presmodule->endcell();
2564                 $kiriwrite_presmodule->endrow();
2565
2566                 $kiriwrite_presmodule->startrow();
2567                 $kiriwrite_presmodule->addcell("tablecell1");
2568                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{pagefilename});
2569                 $kiriwrite_presmodule->endcell();
2570                 $kiriwrite_presmodule->addcell("tablecell2");
2571                 $kiriwrite_presmodule->addinputbox("pagefilename", { Size => 64, MaxLength => 256, Value => $data_filename });
2572                 $kiriwrite_presmodule->endcell();
2573                 $kiriwrite_presmodule->endrow();
2574
2575                 $kiriwrite_presmodule->startrow();
2576                 $kiriwrite_presmodule->addcell("tablecell1");
2577                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{pagecontent});
2578                 $kiriwrite_presmodule->endcell();
2579                 $kiriwrite_presmodule->addcell("tablecell2");
2580                 $kiriwrite_presmodule->addtextbox("pagecontent", { Columns => $kiriwrite_config{"display_textareacols"}, Rows => $kiriwrite_config{"display_textarearows"},  Value => $data_content });
2581                 $kiriwrite_presmodule->addlinebreak();
2582                 $kiriwrite_presmodule->addlinebreak();
2583                 $kiriwrite_presmodule->startbox("datalist");
2584                 $kiriwrite_presmodule->addboldtext($kiriwrite_lang->{common}->{tags});
2585                 $kiriwrite_presmodule->addlinebreak();
2586                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{common}->{pagetitle});
2587                 $kiriwrite_presmodule->addlinebreak();
2588                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{common}->{pagename});
2589                 $kiriwrite_presmodule->addlinebreak();
2590                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{common}->{pagedescription});
2591                 $kiriwrite_presmodule->addlinebreak();
2592                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{common}->{pagesection});
2593                 $kiriwrite_presmodule->addlinebreak();
2594                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{common}->{pageautosection});
2595                 $kiriwrite_presmodule->addlinebreak();
2596                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{common}->{pageautotitle});
2597                 $kiriwrite_presmodule->addlinebreak();
2598                 $kiriwrite_presmodule->endbox();
2599                 $kiriwrite_presmodule->endcell();
2600                 $kiriwrite_presmodule->endrow();
2601
2602                 $kiriwrite_presmodule->startrow();
2603                 $kiriwrite_presmodule->addcell("tablecell1");
2604                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{pagesettings});
2605                 $kiriwrite_presmodule->endcell();
2606                 $kiriwrite_presmodule->addcell("tablecell2");
2607
2608                 # Check if the page settings value is set to a
2609                 # certain number and select that option based
2610                 # on the number else set the value to 0.
2611
2612                 if ($data_settings eq 1){
2613                         $kiriwrite_presmodule->addradiobox("pagesettings", { Description => $kiriwrite_lang->{pages}->{usepageandsection}, Value => "1", Selected => 1, LineBreak => 1});
2614                 } else {
2615                         $kiriwrite_presmodule->addradiobox("pagesettings", { Description => $kiriwrite_lang->{pages}->{usepageandsection}, Value => "1", LineBreak => 1});
2616                 }
2617
2618                 if ($data_settings eq 2){
2619                         $kiriwrite_presmodule->addradiobox("pagesettings", { Description => $kiriwrite_lang->{pages}->{usepagename}, Value => "2", Selected => 1, LineBreak => 1});
2620                 } else {
2621                         $kiriwrite_presmodule->addradiobox("pagesettings", { Description => $kiriwrite_lang->{pages}->{usepagename}, Value => "2", LineBreak => 1});
2622                 }
2623
2624                 if ($data_settings eq 3){
2625                         $kiriwrite_presmodule->addradiobox("pagesettings", { Description => $kiriwrite_lang->{pages}->{usesectionname}, Value => "3", Selected => 1, LineBreak => 1});
2626                 } else {
2627                         $kiriwrite_presmodule->addradiobox("pagesettings", { Description => $kiriwrite_lang->{pages}->{usesectionname}, Value => "3", LineBreak => 1});
2628                 }
2629
2630                 if ($data_settings eq 0 || ($data_settings ne 1 && $data_settings ne 2 && $data_settings ne 3)){
2631                         $kiriwrite_presmodule->addradiobox("pagesettings", { Description => $kiriwrite_lang->{pages}->{nopagesection}, Value => "0", Selected => 1, LineBreak => 1});
2632                 } else {
2633                         $kiriwrite_presmodule->addradiobox("pagesettings", { Description => $kiriwrite_lang->{pages}->{nopagesection}, Value => "0", LineBreak => 1});
2634                 }
2635
2636                 $kiriwrite_presmodule->endcell();
2637                 $kiriwrite_presmodule->endrow();
2638                 $kiriwrite_presmodule->endtable();
2639
2640                 $kiriwrite_presmodule->startbox();
2641                 $kiriwrite_presmodule->addlinebreak();
2642                 $kiriwrite_presmodule->addsubmit($kiriwrite_lang->{pages}->{editpagebutton});
2643                 $kiriwrite_presmodule->addtext(" | ");
2644                 $kiriwrite_presmodule->addreset($kiriwrite_lang->{common}->{restorecurrent});
2645                 $kiriwrite_presmodule->addtext(" | ");
2646                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $database, { Text => kiriwrite_language($kiriwrite_lang->{pages}->{returnpagelist}, $database_name) } );
2647                 $kiriwrite_presmodule->endbox();
2648
2649                 $kiriwrite_presmodule->endform();
2650
2651                 return $kiriwrite_presmodule->grab();
2652
2653         } else {
2654
2655                 # The confirm value is a value other than '0' and '1' so
2656                 # return an error.
2657
2658                 kiriwrite_error("invalidvalue");
2659
2660         }
2661
2662 }
2663
2664 sub kiriwrite_page_multidelete{
2665 #################################################################################
2666 # kiriwrite_page_multidelete: Delete mulitple pages from the database.          #
2667 #                                                                               #
2668 # Usage:                                                                        #
2669 #                                                                               #
2670 # kiriwrite_page_multidelete(database, confirm, filelist);                      #
2671 #                                                                               #
2672 # database      Specifies the database to delete multiple pages from.           #
2673 # confirm       Confirms the action to delete the selected pages from the       #
2674 #               database.                                                       #
2675 # filelist      The list of files to delete from the selected database.         #
2676 #################################################################################
2677
2678         # Get the information passed to the subroutine.
2679
2680         my ($database, $confirm, @filelist) = @_;
2681
2682         # Check if the database name is blank and return an error if
2683         # it is.
2684
2685         if (!$database){
2686
2687                 # The database name is blank so return an error.
2688
2689                 kiriwrite_error("databasenameblank");
2690
2691         }
2692
2693         # Check if the file list array has any values and return
2694         # an error if it doesn't.
2695
2696         if (!@filelist){
2697
2698                 # The page list really is blank so return
2699                 # an error.
2700
2701                 kiriwrite_error("nopagesselected");
2702         }
2703
2704         # Check if the database filename is valid and return an error if
2705         # it isn't.
2706
2707         my $pagedatabase_filename_check = kiriwrite_variablecheck($database, "filename", 0, 1);
2708
2709         if ($pagedatabase_filename_check eq 1){
2710
2711                 # The database filename is blank, so return an error.
2712
2713                 kiriwrite_error("blankdatabasepageadd");
2714
2715         } elsif ($pagedatabase_filename_check eq 2){
2716
2717                 # The database filename is invalid, so return an error.
2718
2719                 kiriwrite_error("databasefilenameinvalid");
2720
2721         }
2722
2723         # Check the length the database name and return an error if it's
2724         # too long.
2725
2726         my $pagedatabase_length_check   = kiriwrite_variablecheck($database, "maxlength", 32, 1);
2727
2728         if ($pagedatabase_length_check eq 1){
2729
2730                 # The database name is too long, so return an error.
2731
2732                 kiriwrite_error("databasefilenametoolong");
2733
2734         }
2735
2736         # Check if the confirm value is blank and if it is, then
2737         # set it to 0.
2738
2739         if (!$confirm){
2740
2741                 # The confirm value is blank so set the confirm value
2742                 # to 0.
2743
2744                 $confirm = 0;
2745
2746         }
2747
2748         if ($confirm eq 1){
2749
2750                 # The action to delete multiple pages from the database has
2751                 # been confirmed.
2752
2753                 # Connect to the database server.
2754
2755                 $kiriwrite_dbmodule->connect();
2756
2757                 # Check if any errors occured while connecting to the database server.
2758
2759                 if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
2760
2761                         # A database connection error has occured so return
2762                         # an error.
2763
2764                         kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
2765
2766                 }
2767
2768                 # Select the database.
2769
2770                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $database });
2771
2772                 # Check if any errors occured while selecting the database.
2773
2774                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
2775
2776                         # The database does not exist, so return an error.
2777
2778                         kiriwrite_error("databasemissingfile");
2779
2780                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
2781
2782                         # The database has invalid permissions set, so return
2783                         # an error.
2784
2785                         kiriwrite_error("databaseinvalidpermissions");
2786
2787                 }
2788
2789                 # Check if the database has read and write permissions.
2790
2791                 my $database_permissions = $kiriwrite_dbmodule->dbpermissions($database, 1, 1);
2792
2793                 if ($database_permissions eq 1){
2794
2795                         # The database permissions are invalid so return an error.
2796
2797                         kiriwrite_error("databaseinvalidpermissions");
2798
2799                 }
2800
2801                 # Get information about the database.
2802
2803                 my %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
2804
2805                 # Check if any errors had occured while getting the database
2806                 # information.
2807
2808                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
2809
2810                         # A database error has occured so return an error and
2811                         # also the extended error information.
2812
2813                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
2814
2815                 };
2816
2817                 my $database_name       = $database_info{"DatabaseName"};
2818
2819                 # Define some variables for later.
2820
2821                 my @database_page;
2822                 my %page_info;
2823                 my $filelist_filename;
2824                 my %deleted_list;
2825                 my $page;
2826                 my $page_name;
2827                 my $page_found = 0;
2828                 my $page_count = 0;
2829
2830                 tie (%deleted_list, 'Tie::IxHash');
2831
2832                 my $deleted_list = "";
2833
2834                 foreach $filelist_filename (@filelist){
2835
2836                         # Get the page information.
2837
2838                         %page_info = $kiriwrite_dbmodule->getpageinfo({ PageFilename => $filelist_filename });
2839
2840                         # Check if any errors occured.
2841
2842                         if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
2843
2844                                 # A database error has occured so return an error and
2845                                 # also the extended error information.
2846
2847                                 kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
2848
2849                         } elsif ($kiriwrite_dbmodule->geterror eq "PageDoesNotExist"){
2850
2851                                 # The page does not exist, so process the next page.
2852
2853                                 next;
2854
2855                         }
2856
2857                         # Add the page to the list of deleted pages.
2858
2859                         $deleted_list{$page_count}{Filename}    = $page_info{"PageFilename"};
2860                         $deleted_list{$page_count}{Name}        = $page_info{"PageName"};
2861
2862                         # Delete the page.
2863
2864                         $kiriwrite_dbmodule->deletepage({ PageFilename => $filelist_filename });
2865
2866                         # Check if any errors occured while deleting the page from the database.
2867
2868                         if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
2869
2870                                 # A database error has occured so return an error and
2871                                 # also the extended error information.
2872
2873                                 kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
2874
2875                         } elsif ($kiriwrite_dbmodule->geterror eq "PageDoesNotExist"){
2876
2877                                 # The page does not exist, so process the next page.
2878
2879                                 next;
2880
2881                         }
2882
2883                         $page_found = 0;
2884                         $page_count++;
2885
2886                 }
2887
2888                 # Disconnect from the database server.
2889
2890                 $kiriwrite_dbmodule->disconnect();
2891
2892                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{selectedpagesdeleted}, { Style => "pageheader" });
2893                 $kiriwrite_presmodule->addlinebreak();
2894                 $kiriwrite_presmodule->addlinebreak();
2895                 $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{pages}->{selectedpagesdeletedmessage}, $database_name));
2896                 $kiriwrite_presmodule->addlinebreak();
2897                 $kiriwrite_presmodule->addlinebreak();
2898                 $kiriwrite_presmodule->startbox("datalist");
2899
2900                 foreach $page (keys %deleted_list){
2901
2902                         if (!$deleted_list{$page}{Name}){
2903                                 $kiriwrite_presmodule->additalictext($kiriwrite_lang->{blank}->{noname});
2904                                 $kiriwrite_presmodule->addtext(" (" . $deleted_list{$page}{Filename} . ")");
2905
2906                         } else {
2907                                 $kiriwrite_presmodule->addtext($deleted_list{$page}{Name} . " (" . $deleted_list{$page}{Filename} . ")");
2908                         }
2909
2910                         $kiriwrite_presmodule->addlinebreak();
2911                 }
2912
2913                 $kiriwrite_presmodule->endbox();
2914                 $kiriwrite_presmodule->addlinebreak();
2915                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $database, { Text => kiriwrite_language($kiriwrite_lang->{pages}->{returnpagelist}, $database_name)});
2916
2917                 return $kiriwrite_presmodule->grab();
2918
2919         } elsif ($confirm eq 0){
2920
2921                 # The action to delete multiple pages from the database has
2922                 # not been confirmed, so write a form asking the user to confirm
2923                 # the deletion of those pages.
2924
2925                 # Connect to the database server.
2926
2927                 $kiriwrite_dbmodule->connect();
2928
2929                 # Check if any errors occured while connecting to the database server.
2930
2931                 if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
2932
2933                         # A database connection error has occured so return
2934                         # an error.
2935
2936                         kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
2937
2938                 }
2939
2940                 # Select the database.
2941
2942                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $database });
2943
2944                 # Check if any errors occured while selecting the database.
2945
2946                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
2947
2948                         # The database does not exist, so return an error.
2949
2950                         kiriwrite_error("databasemissingfile");
2951
2952                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
2953
2954                         # The database has invalid permissions set, so return
2955                         # an error.
2956
2957                         kiriwrite_error("databaseinvalidpermissions");
2958
2959                 }
2960
2961                 # Check if the database has read and write permissions.
2962
2963                 my $database_permissions = $kiriwrite_dbmodule->dbpermissions($database, 1, 1);
2964
2965                 if ($database_permissions eq 1){
2966
2967                         # The database permissions are invalid so return an error.
2968
2969                         kiriwrite_error("databaseinvalidpermissions");
2970
2971                 }
2972
2973                 # Get information about the database.
2974
2975                 my %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
2976
2977                 # Check if any errors had occured while getting the database
2978                 # information.
2979
2980                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
2981
2982                         # A database error has occured so return an error and
2983                         # also the extended error information.
2984
2985                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
2986
2987                 };
2988
2989                 my $database_name       = $database_info{"DatabaseName"};
2990
2991                 # Define some variables for later.
2992
2993                 my %page_info;
2994                 my %delete_list;
2995                 my $pagename;
2996                 my $page = "";
2997                 my $filelist_filename;
2998                 my $filelist_filename_sql;
2999                 my $pageseek = 0;
3000
3001                 tie(%delete_list, 'Tie::IxHash');
3002
3003                 # Process each filename given.
3004
3005                 foreach $filelist_filename (@filelist){
3006
3007                         # Get the page information.
3008
3009                         %page_info = $kiriwrite_dbmodule->getpageinfo({ PageFilename => $filelist_filename });
3010
3011                         # Check if any errors occured.
3012
3013                         if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
3014
3015                                 # A database error has occured so return an error and
3016                                 # also the extended error information.
3017
3018                                 kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
3019
3020                         } elsif ($kiriwrite_dbmodule->geterror eq "PageDoesNotExist"){
3021
3022                                 # The page does not exist, so process the next page.
3023
3024                                 next;
3025
3026                         }
3027
3028                         # Add the page file name and name to the list
3029                         # of pages to delete.
3030
3031                         $delete_list{$pageseek}{Filename}       = $page_info{"PageFilename"};
3032                         $delete_list{$pageseek}{Name}           = $page_info{"PageName"};
3033
3034                         # Increment the page seek counter and reset the
3035                         # page found value.
3036
3037                         $pageseek++;
3038
3039                 }
3040
3041                 # Disconnect from the database server.
3042
3043                 $kiriwrite_dbmodule->disconnect();
3044
3045                 # Check if any files were selected and return
3046                 # an error if there wasn't.
3047
3048                 if ($pageseek eq 0){
3049
3050                         # No pages were selected so return an error.
3051
3052                         kiriwrite_error("nopagesselected");
3053
3054                 }
3055
3056                 # Write the form for displaying pages.
3057
3058                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{deletemultiplepages}, { Style => "pageheader" });
3059                 $kiriwrite_presmodule->startform($kiriwrite_env{"script_filename"}, "POST");
3060                 $kiriwrite_presmodule->startbox();
3061                 $kiriwrite_presmodule->addhiddendata("mode", "page");
3062                 $kiriwrite_presmodule->addhiddendata("action", "multidelete");
3063                 $kiriwrite_presmodule->addhiddendata("database", $database);
3064                 $kiriwrite_presmodule->addhiddendata("confirm", "1");
3065                 $kiriwrite_presmodule->addhiddendata("count", $pageseek);
3066
3067                 $pageseek = 1;
3068
3069                 foreach $page (keys %delete_list){
3070
3071                         $kiriwrite_presmodule->addhiddendata("name[" . $pageseek . "]", "on");
3072                         $kiriwrite_presmodule->addhiddendata("id[" . $pageseek . "]", $delete_list{$page}{Filename});
3073
3074                         $pageseek++;
3075
3076                 }
3077
3078                 $kiriwrite_presmodule->addlinebreak();
3079                 $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{pages}->{deletemultiplemessage}, $database_name));
3080                 $kiriwrite_presmodule->addlinebreak();
3081                 $kiriwrite_presmodule->addlinebreak();
3082                 $kiriwrite_presmodule->startbox("datalist");
3083
3084                 foreach $page (keys %delete_list){
3085
3086                         if (!$delete_list{$page}{Name}){
3087                                 $kiriwrite_presmodule->additalictext($kiriwrite_lang->{blank}->{noname});
3088                                 $kiriwrite_presmodule->addtext(" (" . $delete_list{$page}{Filename} . ")");
3089                         } else {
3090                                 $kiriwrite_presmodule->addtext($delete_list{$page}{Name} . " (" . $delete_list{$page}{Filename} . ")");
3091                         }
3092                         $kiriwrite_presmodule->addlinebreak();
3093
3094                 }
3095
3096                 $kiriwrite_presmodule->endbox();
3097                 $kiriwrite_presmodule->addlinebreak();
3098                 $kiriwrite_presmodule->addsubmit($kiriwrite_lang->{pages}->{deletepagesbutton});
3099                 $kiriwrite_presmodule->addtext(" | ");
3100                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $database, { Text => kiriwrite_language($kiriwrite_lang->{pages}->{deletepagesreturnlink}, $database_name)});
3101                 $kiriwrite_presmodule->endbox();
3102                 $kiriwrite_presmodule->endform();
3103
3104                 return $kiriwrite_presmodule->grab();
3105
3106         } else {
3107
3108                 # A confirm value other than 0 or 1 is given, so
3109                 # return an error.
3110
3111                 kiriwrite_error("invaildvalue");
3112
3113         }
3114
3115 }
3116
3117 sub kiriwrite_page_multimove{
3118 #################################################################################
3119 # kiriwrite_page_multimove: Move several pages from one database to another     #
3120 # database.                                                                     #
3121 #                                                                               #
3122 # Usage:                                                                        #
3123 #                                                                               #
3124 # kiriwrite_page_multimove(database, newdatabase, confirm, filelist);           #
3125 #                                                                               #
3126 # database      Specifies the database to move the selected pages from.         #
3127 # newdatabase   Specifies the database to move the selected pages to.           #
3128 # confirm       Confirms the action to move the pages from one database to      #
3129 #               another.                                                        #
3130 # filelist      Specifies the list of pages to move.                            #
3131 #################################################################################
3132
3133         # Get the values that were passed to the subroutine.
3134
3135         my ($database, $newdatabase, $confirm, @filelist) = @_;
3136
3137         # Check if the database filename is valid and return
3138         # an error if it isn't.
3139
3140         my $newpagedatabase_filename_check = kiriwrite_variablecheck($database, "filename", 0, 1);
3141
3142         if ($newpagedatabase_filename_check eq 1){
3143
3144                 # The database filename is blank, so return an error.
3145
3146                 kiriwrite_error("blankdatabasepageadd");
3147
3148         } elsif ($newpagedatabase_filename_check eq 2){
3149
3150                 # The database filename is invalid, so return an error.
3151
3152                 kiriwrite_error("databasefilenameinvalid");
3153
3154         }
3155
3156         # Check if the file list is blank and return an error
3157         # if it is.
3158
3159         if (!@filelist){
3160
3161                 # The file list really is blank so return
3162                 # an error.
3163
3164                 kiriwrite_error("nopagesselected");
3165
3166         }
3167
3168         # Check if the confirm value is blank and if it is then
3169         # set the confirm value to 0.
3170
3171         if (!$confirm){
3172
3173                 $confirm = 0;
3174
3175         }
3176
3177         if ($confirm eq 1){
3178
3179                 # The action to move several pages from one database
3180                 # to another has been confirmed.
3181
3182                 # Check if the database that the pages are moving from
3183                 # is the same as the database the pages are moving to.
3184                 # Return an error if it is.
3185
3186                 if ($database eq $newdatabase){
3187
3188                         # The database that the pages are moving from
3189                         # and the database the pages are moving to
3190                         # is the same, so return an error.
3191
3192                         kiriwrite_error("databasemovesame");
3193
3194                 }
3195
3196                 # Check if the new database filename is valid and return an error if
3197                 # it isn't.
3198
3199                 my $newpagedatabase_filename_check = kiriwrite_variablecheck($newdatabase, "filename", 0, 1);
3200
3201                 if ($newpagedatabase_filename_check eq 1){
3202
3203                         # The database filename is blank, so return an error.
3204
3205                         kiriwrite_error("blankdatabasepageadd");
3206
3207                 } elsif ($newpagedatabase_filename_check eq 2){
3208
3209                         # The database filename is invalid, so return an error.
3210
3211                         kiriwrite_error("databasefilenameinvalid");
3212
3213                 }
3214
3215                 # Connect to the database server.
3216
3217                 $kiriwrite_dbmodule->connect();
3218
3219                 # Check if any errors occured while connecting to the database server.
3220
3221                 if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
3222
3223                         # A database connection error has occured so return
3224                         # an error.
3225
3226                         kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
3227
3228                 }
3229
3230                 # Select the database the pages are going to be moved from.
3231
3232                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $database });
3233
3234                 # Check if any errors had occured while selecting the database.
3235
3236                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
3237
3238                         # The database does not exist, so return an error.
3239
3240                         kiriwrite_error("oldmovedatabasedoesnotexist");
3241
3242                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
3243
3244                         # The database has invalid permissions set, so return
3245                         # an error.
3246
3247                         kiriwrite_error("oldmovedatabasefileinvalidpermissions");
3248
3249                 }
3250
3251                 # Check if the database has read and write permissions.
3252
3253                 my $database_permissions = $kiriwrite_dbmodule->dbpermissions($database, 1, 1);
3254
3255                 if ($database_permissions eq 1){
3256
3257                         # The database permissions are invalid so return an error.
3258
3259                         kiriwrite_error("oldmovedatabasefileinvalidpermissions");
3260
3261                 }
3262
3263                 # Select the database the pages are going to be moved to.
3264
3265                 $kiriwrite_dbmodule->selectseconddb({ DatabaseName => $newdatabase });
3266
3267                 # Check if any errors had occured while selecting the database.
3268
3269                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
3270
3271                         # The database does not exist, so return an error.
3272
3273                         kiriwrite_error("newmovedatabasedoesnotexist");
3274
3275                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
3276
3277                         # The database has invalid permissions set, so return
3278                         # an error.
3279
3280                         kiriwrite_error("newmovedatabasefileinvalidpermissions");
3281
3282                 }
3283
3284                 # Check if the database has read and write permissions.
3285
3286                 $database_permissions = $kiriwrite_dbmodule->dbpermissions($newdatabase, 1, 1);
3287
3288                 if ($database_permissions eq 1){
3289
3290                         # The database permissions are invalid so return an error.
3291
3292                         kiriwrite_error("newmovedatabasefileinvalidpermissions");
3293
3294                 }
3295
3296                 # Define some values for later.
3297
3298                 my %moved_list;
3299                 my %warning_list;
3300                 my %page_info;
3301
3302                 my $filename;
3303
3304                 my $olddatabase_name;
3305                 my $newdatabase_name;
3306
3307                 my $page;
3308                 my $warning;
3309
3310                 my $page_found = 0;
3311                 my $move_count = 0;
3312                 my $warning_count = 0;
3313
3314                 tie(%moved_list, 'Tie::IxHash');
3315                 tie(%warning_list, 'Tie::IxHash');
3316
3317                 # Get information about the database that the selected pages are moving from.
3318
3319                 my %olddatabase_info = $kiriwrite_dbmodule->getdatabaseinfo();
3320
3321                 # Check if any errors had occured while getting the database
3322                 # information.
3323
3324                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
3325
3326                         # A database error has occured so return an error and
3327                         # also the extended error information.
3328
3329                         kiriwrite_error("oldmovedatabasedatabaseerror", $kiriwrite_dbmodule->geterror(1));
3330
3331                 };
3332
3333                 $olddatabase_name = $olddatabase_info{"DatabaseName"};
3334
3335                 # Get information about the database that the selected pages are moving to.
3336
3337                 my %newdatabase_info = $kiriwrite_dbmodule->getseconddatabaseinfo();
3338
3339                 # Check if any errors had occured while getting the database
3340                 # information.
3341
3342                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
3343
3344                         # A database error has occured so return an error and
3345                         # also the extended error information.
3346
3347                         kiriwrite_error("newmovedatabasedatabaseerror", $kiriwrite_dbmodule->geterror(1));
3348
3349                 };
3350
3351                 $newdatabase_name = $newdatabase_info{"DatabaseName"};
3352
3353                 # Get each file in the old database, get the page values,
3354                 # put them into the new database and delete the pages
3355                 # from the old database.
3356
3357                 foreach $filename (@filelist){
3358
3359                         # Get the page information.
3360
3361                         %page_info = $kiriwrite_dbmodule->getpageinfo({ PageFilename => $filename });
3362
3363                         # Check if any errors occured.
3364
3365                         if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
3366
3367                                 # A database error has occured so write a warning message and
3368                                 # also the extended error information.
3369
3370                                 $warning_list{$warning_count}{Message} = kiriwrite_language($kiriwrite_lang->{pages}->{databasepageerror}, $filename, $kiriwrite_dbmodule->geterror(1));
3371                                 $warning_count++;
3372                                 next;
3373
3374                         } elsif ($kiriwrite_dbmodule->geterror eq "PageDoesNotExist"){
3375
3376                                 # The page does not exist, so process the next page.
3377
3378                                 $warning_list{$warning_count}{Message} = kiriwrite_language($kiriwrite_lang->{pages}->{pagedoesnotexist}, $filename);
3379                                 $warning_count++;
3380                                 next;
3381
3382                         }
3383
3384                         # Move the selected page.
3385
3386                         $kiriwrite_dbmodule->movepage({ PageFilename => $filename });
3387
3388                         # Check if any errors occured while moving the page.
3389
3390                         if ($kiriwrite_dbmodule->geterror eq "OldDatabaseError"){
3391
3392                                 # A database error has occured while moving the pages from
3393                                 # the old database, so write a warning message.
3394
3395                                 $warning_list{$warning_count}{Message} = kiriwrite_language($kiriwrite_lang->{pages}->{databasemovefrompageerror}, $filename, $kiriwrite_dbmodule->geterror(1));
3396                                 $warning_count++;
3397                                 next;
3398
3399                         } elsif ($kiriwrite_dbmodule->geterror eq "NewDatabaseError"){
3400
3401                                 # A database error has occured while moving the pages to
3402                                 # the new database, so write a warning message.
3403
3404                                 $warning_list{$warning_count}{Message} = kiriwrite_language($kiriwrite_lang->{pages}->{databasemovetopageerror}, $filename, $kiriwrite_dbmodule->geterror(1));
3405                                 $warning_count++;
3406                                 next;
3407
3408                         } elsif ($kiriwrite_dbmodule->geterror eq "PageDoesNotExist"){
3409
3410                                 # The page with the filename given in the database that
3411                                 # the page is to be moved from doesn't exist so write
3412                                 # a warning message.
3413
3414                                 $warning_list{$warning_count}{Message} = kiriwrite_language($kiriwrite_lang->{pages}->{databasemovefrompagenotexist}, $filename);
3415                                 $warning_count++;
3416                                 next;
3417
3418                         } elsif ($kiriwrite_dbmodule->geterror eq "PageAlreadyExists"){
3419
3420                                 # The page with the filename given in the database that
3421                                 # the page is to be moved to already exists so write a
3422                                 # warning message.
3423
3424                                 $warning_list{$warning_count}{Message} = kiriwrite_language($kiriwrite_lang->{pages}->{databasemovetopageexists}, $filename);
3425                                 $warning_count++;
3426                                 next;
3427
3428                         }
3429
3430                         $moved_list{$move_count}{Filename}      = $page_info{"PageFilename"};
3431                         $moved_list{$move_count}{Name}          = $page_info{"PageName"};
3432
3433                         $move_count++;
3434
3435                 }
3436
3437                 # Disconnect from the database server.
3438
3439                 $kiriwrite_dbmodule->disconnect();
3440
3441                 # Write out a message saying that the pages were moved (if any)
3442                 # to the new database (and any warnings given).
3443
3444                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{movepages}, { Style => "pageheader" });
3445                 $kiriwrite_presmodule->addlinebreak();
3446                 $kiriwrite_presmodule->addlinebreak();
3447
3448                 if (%moved_list){
3449
3450                         $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{pages}->{movedpagesmessage}, $olddatabase_name, $newdatabase_name));
3451                         $kiriwrite_presmodule->addlinebreak();
3452                         $kiriwrite_presmodule->addlinebreak();
3453
3454                         $kiriwrite_presmodule->startbox("datalist");
3455                         foreach $page (keys %moved_list){
3456                                 if (!$moved_list{$page}{Name}){
3457                                         $kiriwrite_presmodule->additalictext($kiriwrite_lang->{blank}->{noname});
3458                                         $kiriwrite_presmodule->addtext(" (" . $moved_list{$page}{Filename} . ")");
3459                                 } else {
3460                                         $kiriwrite_presmodule->addtext($moved_list{$page}{Name} . " (" . $moved_list{$page}{Filename} . ")");
3461                                 }
3462
3463                                 $kiriwrite_presmodule->addlinebreak();
3464                         }
3465                         $kiriwrite_presmodule->endbox();
3466
3467                 } else {
3468
3469                         $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{pages}->{nopagesmoved}, $olddatabase_name, $newdatabase_name));
3470                         $kiriwrite_presmodule->addlinebreak();
3471                         $kiriwrite_presmodule->addlinebreak();
3472
3473                 }
3474
3475                 if (%warning_list){
3476
3477                         $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{errormessages});
3478                         $kiriwrite_presmodule->addlinebreak();
3479                         $kiriwrite_presmodule->addlinebreak();
3480                         $kiriwrite_presmodule->startbox("datalist");
3481                         foreach $warning (keys %warning_list){
3482                                 $kiriwrite_presmodule->addtext($warning_list{$warning}{Message});
3483                                 $kiriwrite_presmodule->addlinebreak();
3484                         }
3485                         $kiriwrite_presmodule->endbox();
3486
3487                 }
3488
3489                 $kiriwrite_presmodule->addlinebreak();
3490                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $database, { Text => kiriwrite_language($kiriwrite_lang->{pages}->{returnpagelist}, $olddatabase_name)});
3491                 $kiriwrite_presmodule->addtext(" | ");
3492                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $newdatabase, { Text => kiriwrite_language($kiriwrite_lang->{pages}->{viewpagelist}, $newdatabase_name)});
3493
3494                 return $kiriwrite_presmodule->grab();
3495
3496         } elsif ($confirm eq 0) {
3497
3498                 # The action to move several pages from one database
3499                 # to another has not been confirmed so write a form.
3500
3501                 # Connect to the database server.
3502
3503                 $kiriwrite_dbmodule->connect();
3504
3505                 # Check if any errors occured while connecting to the database server.
3506
3507                 if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
3508
3509                         # A database connection error has occured so return
3510                         # an error.
3511
3512                         kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
3513
3514                 }
3515
3516                 # Select the database.
3517
3518                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $database });
3519
3520                 # Check if any errors occured while selecting the database.
3521
3522                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
3523
3524                         # The database does not exist, so return an error.
3525
3526                         kiriwrite_error("databasemissingfile");
3527
3528                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
3529
3530                         # The database has invalid permissions set, so return
3531                         # an error.
3532
3533                         kiriwrite_error("databaseinvalidpermissions");
3534
3535                 }
3536
3537                 # Check if the database has read and write permissions.
3538
3539                 my $database_permissions = $kiriwrite_dbmodule->dbpermissions($database, 1, 1);
3540
3541                 if ($database_permissions eq 1){
3542
3543                         # The database permissions are invalid so return an error.
3544
3545                         kiriwrite_error("databaseinvalidpermissions");
3546
3547                 }
3548
3549                 # Get information about the database.
3550
3551                 my %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
3552
3553                 # Check if any errors had occured while getting the database
3554                 # information.
3555
3556                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
3557
3558                         # A database error has occured so return an error and
3559                         # also the extended error information.
3560
3561                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
3562
3563                 };
3564
3565                 my $database_name       = $database_info{"DatabaseName"};
3566
3567                 # Define some values for later.
3568
3569                 my %db_list;
3570                 my %move_list;
3571                 my %page_info;
3572                 my $page;
3573                 my $data_file;
3574                 my $db_name;
3575                 my $filename;
3576                 my $filelist_filename;
3577                 my $pagename;
3578                 my $pageseek    = 0;
3579                 my $dbseek      = 0;
3580
3581                 # Process each filename given.
3582
3583                 tie (%move_list, 'Tie::IxHash');
3584                 tie (%db_list, 'Tie::IxHash');
3585
3586                 foreach $filelist_filename (@filelist){
3587
3588                         # Get the page information.
3589
3590                         %page_info = $kiriwrite_dbmodule->getpageinfo({ PageFilename => $filelist_filename });
3591
3592                         # Check if any errors occured.
3593
3594                         if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
3595
3596                                 # A database error has occured so return an error and
3597                                 # also the extended error information.
3598
3599                                 kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
3600
3601                         } elsif ($kiriwrite_dbmodule->geterror eq "PageDoesNotExist"){
3602
3603                                 # The page does not exist, so process the next page.
3604
3605                                 next;
3606
3607                         }
3608
3609                         # Add the page name and file name to the list of
3610                         # pages to move.
3611
3612                         $move_list{$pageseek}{Filename} = $page_info{"PageFilename"};
3613                         $move_list{$pageseek}{Name}     = $page_info{"PageName"};
3614
3615                         # Increment the page seek counter and reset the
3616                         # page found value.
3617
3618                         $pageseek++;
3619
3620                 }
3621
3622                 # Check if any pages exust and return an error if
3623                 # there wasn't.
3624
3625                 if ($pageseek eq 0){
3626
3627                         # None of the selected pages exist, so return
3628                         # an error.
3629
3630                         kiriwrite_error("nopagesselected");
3631
3632                 }
3633
3634                 # Get the list of databases.
3635
3636                 my @database_list       = $kiriwrite_dbmodule->getdblist();
3637
3638                 # Check if any errors occured while trying to get the list of databases.
3639
3640                 if ($kiriwrite_dbmodule->geterror eq "DataDirMissing"){
3641
3642                         # The database directory is missing so return an error.
3643
3644                         kiriwrite_error("datadirectorymissing");
3645
3646                 } elsif ($kiriwrite_dbmodule->geterror eq "DataDirInvalidPermissions"){
3647
3648                         # The database directory has invalid permissions set so return
3649                         # an error.
3650
3651                         kiriwrite_error("datadirectoryinvalidpermissions");
3652
3653                 }
3654
3655                 # Get the information about each database (the short name and friendly name).
3656
3657                 foreach $data_file (@database_list){
3658
3659                         $kiriwrite_dbmodule->selectdb({ DatabaseName => $data_file });
3660
3661                         # Check if any errors occured while selecting the database.
3662
3663                         if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
3664
3665                                 # The database does not exist, so process the next
3666                                 # database.
3667
3668                                 next;
3669
3670                         } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
3671
3672                                 # The database has invalid permissions set, so process
3673                                 # the next database.
3674
3675                                 next;
3676
3677                         }
3678
3679                         # Get the database information.
3680
3681                         %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
3682
3683                         # Check if any errors had occured while getting the database
3684                         # information.
3685
3686                         if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
3687
3688                                 # A database error has occured so process the next
3689                                 # database.
3690
3691                                 next;
3692
3693                         };
3694
3695                         # Check if the database name is undefined and if it is
3696                         # then set it blank.
3697
3698                         if (!$database_name){
3699                                 $database_name = "";
3700                         }
3701
3702                         # Append the database to the list of databases available.
3703
3704                         $db_list{$dbseek}{Filename}     = $data_file;
3705                         $db_list{$dbseek}{Name}         = $database_info{"DatabaseName"};
3706
3707                         $dbseek++;
3708
3709                 }
3710
3711                 # Disconnect from the database server.
3712
3713                 $kiriwrite_dbmodule->disconnect();
3714
3715                 # Write out the form.
3716
3717                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{movepages}, { Style => "pageheader" });
3718                 $kiriwrite_presmodule->startform($kiriwrite_env{"script_filename"}, "POST");
3719                 $kiriwrite_presmodule->startbox();
3720                 $kiriwrite_presmodule->addhiddendata("mode", "page");
3721                 $kiriwrite_presmodule->addhiddendata("action", "multimove");
3722                 $kiriwrite_presmodule->addhiddendata("database", $database);
3723                 $kiriwrite_presmodule->addhiddendata("count", $pageseek);
3724                 $kiriwrite_presmodule->addhiddendata("confirm", "1");
3725
3726                 # Write the page form data.
3727
3728                 $pageseek = 1;
3729
3730                 foreach $page (keys %move_list){
3731                         $kiriwrite_presmodule->addhiddendata("name[" . $pageseek . "]", "on");
3732                         $kiriwrite_presmodule->addhiddendata("id[" . $pageseek . "]", $move_list{$page}{Filename});
3733                         $pageseek++;
3734                 }
3735
3736                 $kiriwrite_presmodule->addlinebreak();
3737                 $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{pages}->{movepagesmessage}, $database_name));
3738                 $kiriwrite_presmodule->addlinebreak();
3739                 $kiriwrite_presmodule->addlinebreak();
3740                 $kiriwrite_presmodule->startbox("datalist");
3741
3742                 foreach $page (keys %move_list){
3743                         if (!$move_list{$page}{Name}){
3744                                 $kiriwrite_presmodule->additalictext($kiriwrite_lang->{blank}->{noname});
3745                                 $kiriwrite_presmodule->addtext(" (" . $move_list{$page}{Filename} . ")");
3746                         } else {
3747                                 $kiriwrite_presmodule->addtext($move_list{$page}{Name} . " (" . $move_list{$page}{Filename} . ")");
3748                         }
3749                         $kiriwrite_presmodule->addlinebreak();
3750                 }
3751
3752                 $kiriwrite_presmodule->endbox();
3753                 $kiriwrite_presmodule->addlinebreak();
3754                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{movepagesto});
3755
3756                 $kiriwrite_presmodule->addselectbox("newdatabase");
3757
3758                 foreach $db_name (keys %db_list){
3759                         $kiriwrite_presmodule->addoption($db_list{$db_name}{Name} . " (" . $db_list{$db_name}{Filename} . ")", { Value => $db_list{$db_name}{Filename}});
3760                 }
3761
3762                 $kiriwrite_presmodule->endselectbox();
3763                 $kiriwrite_presmodule->addlinebreak();
3764                 $kiriwrite_presmodule->addlinebreak();
3765                 $kiriwrite_presmodule->addsubmit($kiriwrite_lang->{pages}->{movepagesbutton});
3766                 $kiriwrite_presmodule->addtext(" | ");
3767                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $database, { Text => kiriwrite_language($kiriwrite_lang->{pages}->{returnpagelist}, $database_name)});
3768                 $kiriwrite_presmodule->endbox();
3769                 $kiriwrite_presmodule->endform();
3770
3771                 return $kiriwrite_presmodule->grab();
3772
3773         } else {
3774
3775                 # The confirm value is other than 0 or 1, so return
3776                 # an error.
3777
3778                 kiriwrite_error("invalidvariable");
3779
3780         }
3781
3782
3783 }
3784
3785
3786 sub kiriwrite_page_multicopy{
3787 #################################################################################
3788 # kiriwrite_page_multicopy: Copy several pages from one database to another     #
3789 # database.                                                                     #
3790 #                                                                               #
3791 # Usage:                                                                        #
3792 #                                                                               #
3793 # kiriwrite_page_multicopy(database, newdatabase, confirm, filelist);           #
3794 #                                                                               #
3795 # database      Specifies the database to copy the selected pages from.         #
3796 # newdatabase   Specifies the database to copy the selected page to.            #
3797 # confirm       Confirms the action to copy the pages.                          #
3798 # filelist      A list of filenames to copy in an array.                        #
3799 #################################################################################
3800
3801         # Get the values that were passed to the subroutine.
3802
3803         my ($database, $newdatabase, $confirm, @filelist) = @_;
3804
3805         # Check if the file list is blank and return an error
3806         # if it is.
3807
3808         if (!@filelist){
3809
3810                 # The file list really is blank so return
3811                 # an error.
3812
3813                 kiriwrite_error("nopagesselected");
3814
3815         }
3816
3817         # Check if the confirm value is blank and if it is then
3818         # set the confirm value to 0.
3819
3820         if (!$confirm){
3821
3822                 $confirm = 0;
3823
3824         }
3825
3826         # Check if the database filename is valid and return an error if
3827         # it isn't.
3828
3829         my $pagedatabase_filename_check = kiriwrite_variablecheck($database, "filename", 0, 1);
3830
3831         if ($pagedatabase_filename_check eq 1){
3832
3833                 # The database filename is blank, so return an error.
3834
3835                 kiriwrite_error("blankdatabasepageadd");
3836
3837         } elsif ($pagedatabase_filename_check eq 2){
3838
3839                 # The database filename is invalid, so return an error.
3840
3841                 kiriwrite_error("databasefilenameinvalid");
3842
3843         }
3844
3845         if ($confirm eq 1){
3846
3847                 # The action to copy several pages from one database
3848                 # to another has been confirmed.
3849
3850                 # Check if the database that the pages are copied from
3851                 # is the same as the database the pages are copied to.
3852                 # Return an error if it is.
3853
3854                 if ($database eq $newdatabase){
3855
3856                         # The database that the pages are being copied from
3857                         # and the database that the pages are copied to
3858                         # is the same, so return an error.
3859
3860                         kiriwrite_error("databasecopysame");
3861
3862                 }
3863
3864                 # Check if the new database filename is valid and return an error if
3865                 # it isn't.
3866
3867                 my $pagedatabase_filename_check = kiriwrite_variablecheck($newdatabase, "filename", 0, 1);
3868
3869                 if ($pagedatabase_filename_check eq 1){
3870
3871                         # The database filename is blank, so return an error.
3872
3873                         kiriwrite_error("blankdatabasepageadd");
3874
3875                 } elsif ($pagedatabase_filename_check eq 2){
3876
3877                         # The database filename is invalid, so return an error.
3878
3879                         kiriwrite_error("databasefilenameinvalid");
3880
3881                 }
3882
3883                 # Connect to the database server.
3884
3885                 $kiriwrite_dbmodule->connect();
3886
3887                 # Check if any errors occured while connecting to the database server.
3888
3889                 if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
3890
3891                         # A database connection error has occured so return
3892                         # an error.
3893
3894                         kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
3895
3896                 }
3897
3898                 # Select the database the pages are going to be copied from.
3899
3900                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $database });
3901
3902                 # Check if any errors had occured while selecting the database.
3903
3904                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
3905
3906                         # The database does not exist, so return an error.
3907
3908                         kiriwrite_error("oldcopydatabasedoesnotexist");
3909
3910                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
3911
3912                         # The database has invalid permissions set, so return
3913                         # an error.
3914
3915                         kiriwrite_error("oldcopydatabasefileinvalidpermissions");
3916
3917                 }
3918
3919                 # Select the database the pages are going to be copied to.
3920
3921                 $kiriwrite_dbmodule->selectseconddb({ DatabaseName => $newdatabase });
3922
3923                 # Check if any errors had occured while selecting the database.
3924
3925                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
3926
3927                         # The database does not exist, so return an error.
3928
3929                         kiriwrite_error("newcopydatabasedoesnotexist");
3930
3931                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
3932
3933                         # The database has invalid permissions set, so return
3934                         # an error.
3935
3936                         kiriwrite_error("newcopydatabasefileinvalidpermissions");
3937
3938                 }
3939
3940                 # Check if the database has read and write permissions.
3941
3942                 my $database_permissions = $kiriwrite_dbmodule->dbpermissions($newdatabase, 1, 1);
3943
3944                 if ($database_permissions eq 1){
3945
3946                         # The database permissions are invalid so return an error.
3947
3948                         kiriwrite_error("newcopydatabasefileinvalidpermissions");
3949
3950                 }
3951
3952                 # Define some values for later.
3953
3954                 my %copied_list;
3955                 my %warning_list;
3956                 my %page_info;
3957
3958                 my @olddatabase_info;
3959                 my @olddatabase_page;
3960                 my @newdatabase_info;
3961                 my @newdatabase_page;
3962
3963                 my $filename;
3964
3965                 my $olddatabase_name;
3966                 my $newdatabase_name;
3967
3968                 my $page;
3969                 my $warning;
3970                 my $page_filename;
3971                 my $page_name;
3972                 my $page_description;
3973                 my $page_section;
3974                 my $page_template;
3975                 my $page_data;
3976                 my $page_settings;
3977                 my $page_lastmodified;
3978
3979                 my $page_seek = 0;
3980                 my $warning_count = 0;
3981
3982                 my $page_found = 0;
3983
3984                 tie(%copied_list, 'Tie::IxHash');
3985                 tie(%warning_list, 'Tie::IxHash');
3986
3987                 # Get information about the database that the selected pages are moving from.
3988
3989                 my %olddatabase_info = $kiriwrite_dbmodule->getdatabaseinfo();
3990
3991                 # Check if any errors had occured while getting the database
3992                 # information.
3993
3994                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
3995
3996                         # A database error has occured so return an error and
3997                         # also the extended error information.
3998
3999                         kiriwrite_error("oldcopydatabasedatabaseerror", $kiriwrite_dbmodule->geterror(1));
4000
4001                 };
4002
4003                 $olddatabase_name = $olddatabase_info{"DatabaseName"};
4004
4005                 # Get information about the database that the selected pages are moving to.
4006
4007                 my %newdatabase_info = $kiriwrite_dbmodule->getseconddatabaseinfo();
4008
4009                 # Check if any errors had occured while getting the database
4010                 # information.
4011
4012                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
4013
4014                         # A database error has occured so return an error and
4015                         # also the extended error information.
4016
4017                         kiriwrite_error("newcopydatabasedatabaseerror", $kiriwrite_dbmodule->geterror(1));
4018
4019                 };
4020
4021                 $newdatabase_name = $newdatabase_info{"DatabaseName"};
4022
4023                 # Check if the database filename is valid and return an error if
4024                 # it isn't.
4025
4026                 my $newpagedatabase_filename_check = kiriwrite_variablecheck($newdatabase, "filename", 0, 1);
4027
4028                 if ($newpagedatabase_filename_check eq 1){
4029
4030                         # The database filename is blank, so return an error.
4031
4032                         kiriwrite_error("blankdatabasepageadd");
4033
4034                 } elsif ($newpagedatabase_filename_check eq 2){
4035
4036                         # The database filename is invalid, so return an error.
4037
4038                         kiriwrite_error("databasefilenameinvalid");
4039
4040                 }
4041
4042                 foreach $filename (@filelist){
4043
4044                         # Get the page information.
4045
4046                         %page_info = $kiriwrite_dbmodule->getpageinfo({ PageFilename => $filename });
4047
4048                         # Check if any errors occured.
4049
4050                         if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
4051
4052                                 # A database error has occured so return an error and
4053                                 # also the extended error information.
4054
4055                                 $warning_list{$warning_count}{Message} = kiriwrite_language($kiriwrite_lang->{pages}->{databasepageerror}, $filename, $kiriwrite_dbmodule->geterror(1));
4056                                 $warning_count++;
4057                                 next;
4058
4059                         } elsif ($kiriwrite_dbmodule->geterror eq "PageDoesNotExist"){
4060
4061                                 # The page does not exist, so process the next page.
4062
4063                                 $warning_list{$warning_count}{Message} = kiriwrite_language($kiriwrite_lang->{pages}->{databasecopyfrompageerror}, $filename);
4064                                 $warning_count++;
4065                                 next;
4066
4067                         }
4068
4069                         $kiriwrite_dbmodule->copypage({ PageFilename => $filename });
4070
4071                         # Check if any errors occured while copying the page.
4072
4073                         if ($kiriwrite_dbmodule->geterror eq "OldDatabaseError"){
4074
4075                                 # A database error has occured while copying the pages from
4076                                 # the old database, so write a warning message.
4077
4078                                 $warning_list{$warning_count}{Message} = kiriwrite_language($kiriwrite_lang->{pages}->{databasecopyfromdatabaseerror}, $filename,  $kiriwrite_dbmodule->geterror(1));
4079                                 $warning_count++;
4080                                 next;
4081
4082                         } elsif ($kiriwrite_dbmodule->geterror eq "NewDatabaseError"){
4083
4084                                 # A database error has occured while copying the pages to
4085                                 # the new database, so write a warning message.
4086
4087                                 $warning_list{$warning_count}{Message} = kiriwrite_language($kiriwrite_lang->{pages}->{databasecopytodatabaseerror}, $filename, $kiriwrite_dbmodule->geterror(1));
4088                                 $warning_count++;
4089                                 next;
4090
4091                         } elsif ($kiriwrite_dbmodule->geterror eq "PageDoesNotExist"){
4092
4093                                 # The page with the filename given in the database that
4094                                 # the page is to be copied from doesn't exist so write
4095                                 # a warning message.
4096
4097                                 $warning_list{$warning_count}{Message} = kiriwrite_language($kiriwrite_lang->{pages}->{databasecopyfrompagenotexist}, $filename);
4098                                 $warning_count++;
4099                                 next;
4100
4101                         } elsif ($kiriwrite_dbmodule->geterror eq "PageAlreadyExists"){
4102
4103                                 # The page with the filename given in the database that
4104                                 # the page is to be copied to already exists so write a
4105                                 # warning message.
4106
4107                                 $warning_list{$warning_count}{Message} = kiriwrite_language($kiriwrite_lang->{pages}->{databasecopytopageexists}, $filename);
4108                                 $warning_count++;
4109                                 next;
4110
4111                         }
4112
4113                         # Append the copied page (filename and name) to the list of
4114                         # copied pages.
4115
4116                         $copied_list{$page_seek}{Filename}      = $filename;
4117                         $copied_list{$page_seek}{Name}          = $page_info{"PageName"};
4118                         $page_seek++;
4119
4120                 }
4121
4122                 # Disconnect from the database server.
4123
4124                 $kiriwrite_dbmodule->disconnect();
4125
4126                 # Write out a message saying that the pages were moved (if any)
4127                 # to the new database (and any warnings given).
4128
4129                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{copypages}, { Style => "pageheader" });
4130                 $kiriwrite_presmodule->addlinebreak();
4131                 $kiriwrite_presmodule->addlinebreak();
4132
4133                 if (%copied_list){
4134
4135                         $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{pages}->{copypagesresultmessage}, $olddatabase_name, $newdatabase_name));
4136                         $kiriwrite_presmodule->addlinebreak();
4137                         $kiriwrite_presmodule->addlinebreak();
4138                         $kiriwrite_presmodule->startbox("datalist");
4139                         foreach $page (keys %copied_list){
4140                                 if (!$copied_list{$page}{Name}){
4141                                         $kiriwrite_presmodule->additalictext($kiriwrite_lang->{blank}->{noname});
4142                                         $kiriwrite_presmodule->addtext(" (" . $copied_list{$page}{Filename} . ")");
4143                                 } else {
4144                                         $kiriwrite_presmodule->addtext($copied_list{$page}{Name} . " (" . $copied_list{$page}{Filename} . ")");
4145                                 }
4146                                 $kiriwrite_presmodule->addlinebreak();
4147                         }
4148                         $kiriwrite_presmodule->endbox();
4149
4150                 } else {
4151
4152                         $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{pages}->{nopagescopied}, $olddatabase_name, $newdatabase_name));
4153
4154                 }
4155
4156                 if (%warning_list){
4157
4158                         $kiriwrite_presmodule->addlinebreak();
4159                         $kiriwrite_presmodule->addlinebreak();
4160                         $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{copypageswarnings});
4161                         $kiriwrite_presmodule->addlinebreak();
4162                         $kiriwrite_presmodule->addlinebreak();
4163                         $kiriwrite_presmodule->startbox("datalist");
4164                         foreach $warning (keys %warning_list){
4165                                 $kiriwrite_presmodule->addtext($warning_list{$warning}{Message});
4166                                                         $kiriwrite_presmodule->addlinebreak();
4167                         }
4168                         $kiriwrite_presmodule->endbox();
4169
4170                 }
4171
4172                 $kiriwrite_presmodule->addlinebreak();
4173                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $database, { Text => kiriwrite_language($kiriwrite_lang->{pages}->{returnpagelist}, $olddatabase_name)});
4174                 $kiriwrite_presmodule->addtext(" | ");
4175                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $newdatabase, { Text => kiriwrite_language($kiriwrite_lang->{pages}->{viewpagelist}, $newdatabase_name)});
4176
4177                 return $kiriwrite_presmodule->grab();
4178
4179         } elsif ($confirm eq 0) {
4180
4181                 # The action to copy several pages from one database
4182                 # to another has not been confirmed so write a form.
4183
4184                 # Connect to the database server.
4185
4186                 $kiriwrite_dbmodule->connect();
4187
4188                 # Check if any errors occured while connecting to the database server.
4189
4190                 if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
4191
4192                         # A database connection error has occured so return
4193                         # an error.
4194
4195                         kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
4196
4197                 }
4198
4199                 # Select the database to copy the pages from.
4200
4201                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $database });
4202
4203                 # Check if any errors occured while selecting the database.
4204
4205                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
4206
4207                         # The database does not exist, so return an error.
4208
4209                         kiriwrite_error("databasemissingfile");
4210
4211                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
4212
4213                         # The database has invalid permissions set, so return
4214                         # an error.
4215
4216                         kiriwrite_error("databaseinvalidpermissions");
4217
4218                 }
4219
4220                 # Get information about the database.
4221
4222                 my %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
4223
4224                 # Check if any errors had occured while getting the database
4225                 # information.
4226
4227                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
4228
4229                         # A database error has occured so return an error and
4230                         # also the extended error information.
4231
4232                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
4233
4234                 };
4235
4236                 my $database_name       = $database_info{"DatabaseName"};
4237
4238                 # Define some values for later.
4239
4240                 my %page_info;
4241                 my %copy_list;
4242                 my %db_list;
4243                 my @page_info;
4244                 my $page;
4245                 my $data_file;
4246                 my $dbname;
4247                 my $filename;
4248                 my $pageseek    = 0;
4249                 my $dbseek      = 0;
4250                 my $pagefound   = 0;
4251
4252                 tie(%copy_list, 'Tie::IxHash');
4253                 tie(%db_list, 'Tie::IxHash');
4254
4255                 # Process each filename given.
4256
4257                 foreach $filename (@filelist){
4258
4259                         # Get the page information.
4260
4261                         %page_info = $kiriwrite_dbmodule->getpageinfo({ PageFilename => $filename });
4262
4263                         # Check if any errors occured.
4264
4265                         if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
4266
4267                                 # A database error has occured so return an error and
4268                                 # also the extended error information.
4269
4270                                 kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
4271
4272                         } elsif ($kiriwrite_dbmodule->geterror eq "PageDoesNotExist"){
4273
4274                                 # The page does not exist, so process the next page.
4275
4276                                 next;
4277
4278                         }
4279
4280                         # Add the page name and file name to the list of
4281                         # pages to move.
4282
4283                         $copy_list{$pageseek}{Filename} = $page_info{"PageFilename"};
4284                         $copy_list{$pageseek}{Name}     = $page_info{"PageName"};
4285
4286                         # Increment the page seek counter.
4287
4288                         $pageseek++;
4289
4290                 }
4291
4292                 # Check if any pages exust and return an error if
4293                 # there wasn't.
4294
4295                 if ($pageseek eq 0){
4296
4297                         # None of the selected pages exist, so return
4298                         # an error.
4299
4300                         kiriwrite_error("nopagesselected");
4301
4302                 }
4303
4304                 # Get the database filenames and names.
4305
4306                 my @database_list       = $kiriwrite_dbmodule->getdblist();
4307
4308                 # Check if any errors occured while trying to get the list of databases.
4309
4310                 if ($kiriwrite_dbmodule->geterror eq "DataDirMissing"){
4311
4312                         # The database directory is missing so return an error.
4313
4314                         kiriwrite_error("datadirectorymissing");
4315
4316                 } elsif ($kiriwrite_dbmodule->geterror eq "DataDirInvalidPermissions"){
4317
4318                         # The database directory has invalid permissions set so return
4319                         # an error.
4320
4321                         kiriwrite_error("datadirectoryinvalidpermissions");
4322
4323                 }
4324
4325                 # Process each database to get the database name.
4326
4327                 foreach $data_file (@database_list){
4328
4329                         $kiriwrite_dbmodule->selectdb({ DatabaseName => $data_file });
4330
4331                         # Check if any errors occured while selecting the database.
4332
4333                         if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
4334
4335                                 # The database does not exist, so process the next
4336                                 # database.
4337
4338                                 next;
4339
4340                         } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
4341
4342                                 # The database has invalid permissions set, so process
4343                                 # the next database.
4344
4345                                 next;
4346
4347                         }
4348
4349                         # Get the database information.
4350
4351                         %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
4352
4353                         # Check if any errors had occured while getting the database
4354                         # information.
4355
4356                         if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
4357
4358                                 # A database error has occured so process the next
4359                                 # database.
4360
4361                                 next;
4362
4363                         };
4364
4365                         # Check if the database name is undefined and if it is
4366                         # then set it blank.
4367
4368                         if (!$database_name){
4369                                 $database_name = "";
4370                         }
4371
4372                         # Append the database filename and name to the list of databases
4373                         # to move the pages to.
4374
4375                         $db_list{$dbseek}{Filename}     = $data_file;
4376                         $db_list{$dbseek}{Name}         = $database_info{"DatabaseName"};
4377
4378                         $dbseek++;
4379
4380                 }
4381
4382                 # Disconnect from the database server.
4383
4384                 $kiriwrite_dbmodule->disconnect();
4385
4386                 # Write out the form.
4387
4388                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{copypages}, { Style => "pageheader" });
4389                 $kiriwrite_presmodule->startform($kiriwrite_env{"script_filename"}, "POST");
4390                 $kiriwrite_presmodule->startbox();
4391                 $kiriwrite_presmodule->addhiddendata("mode", "page");
4392                 $kiriwrite_presmodule->addhiddendata("action", "multicopy");
4393                 $kiriwrite_presmodule->addhiddendata("database", $database);
4394                 $kiriwrite_presmodule->addhiddendata("count", $pageseek);
4395                 $kiriwrite_presmodule->addhiddendata("confirm", 1);
4396
4397                 $pageseek = 1;
4398
4399                 foreach $page (keys %copy_list){
4400                         $kiriwrite_presmodule->addhiddendata("name[" . $pageseek . "]", "on");
4401                         $kiriwrite_presmodule->addhiddendata("id[" . $pageseek . "]", $copy_list{$page}{Filename});
4402                         $pageseek++;
4403                 }
4404
4405                 $kiriwrite_presmodule->addlinebreak();
4406                 $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{pages}->{copypagesmessage}, $database_name));
4407
4408                 $kiriwrite_presmodule->addlinebreak();
4409                 $kiriwrite_presmodule->addlinebreak();
4410
4411                 $kiriwrite_presmodule->startbox("datalist");
4412
4413                 foreach $page (keys %copy_list){
4414                         if (!$copy_list{$page}{Name}){
4415                                 $kiriwrite_presmodule->additalictext($kiriwrite_lang->{blank}->{noname});
4416                                 $kiriwrite_presmodule->addtext(" (" . $copy_list{$page}{Filename} . ")");
4417                         } else {
4418                                 $kiriwrite_presmodule->addtext($copy_list{$page}{Name} . " (" . $copy_list{$page}{Filename} . ")");
4419                         }
4420                         $kiriwrite_presmodule->addlinebreak();
4421                 }
4422
4423                 $kiriwrite_presmodule->endbox();
4424
4425                 $kiriwrite_presmodule->addlinebreak();
4426
4427                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{copypagesto});
4428                 $kiriwrite_presmodule->addselectbox("newdatabase");
4429
4430                 foreach $dbname (keys %db_list){
4431                         $kiriwrite_presmodule->addoption($db_list{$dbname}{Name} . " (" . $db_list{$dbname}{Filename} . ")", { Value => $db_list{$dbname}{Filename}});
4432                 }
4433
4434                 $kiriwrite_presmodule->endselectbox();
4435
4436                 $kiriwrite_presmodule->addlinebreak();
4437                 $kiriwrite_presmodule->addlinebreak();
4438                 $kiriwrite_presmodule->addsubmit($kiriwrite_lang->{pages}->{copypagesbutton});
4439                 $kiriwrite_presmodule->addtext(" | ");
4440                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $database, { Text => kiriwrite_language($kiriwrite_lang->{pages}->{returnpagelist}, $database_name) });
4441
4442                 $kiriwrite_presmodule->endbox();
4443                 $kiriwrite_presmodule->endform();
4444
4445                 return $kiriwrite_presmodule->grab();
4446
4447         } else {
4448
4449                 # The confirm value is other than 0 or 1, so return
4450                 # an error.
4451
4452                 kiriwrite_error("invalidvariable");
4453
4454         }
4455
4456 }
4457
4458 sub kiriwrite_page_multiedit{
4459 #################################################################################
4460 # kiriwrite_page_multiedit: Edit several pages from a database.                 #
4461 #                                                                               #
4462 # Usage:                                                                        #
4463 #                                                                               #
4464 # kiriwrite_page_multiedit(database, newsection, altersection, newtemplate,     #
4465 #                               altertemplate, newsettings, altersettings       #
4466 #                               confirm, filelist);                             #
4467 #                                                                               #
4468 # database      Specifies the database to edit the pages from.                  #
4469 # newsection    Specifies the new section name to use on the selected pages.    #
4470 # altersection  Specifies if the section name should be altered.                #
4471 # newtemplate   Specifies the new template filename to use on the selected      #
4472 #               pages.                                                          #
4473 # altertemplate Specifies if the template filename should be altered.           #
4474 # newsettings   Specifies the new settings to use on the selected pages.        #
4475 # altersettings Specifies if the settings should be altered.                    #
4476 # confirm       Confirms the action to edit the selected pages.                 #
4477 # filelist      The list of file names to edit.                                 #
4478 #################################################################################
4479
4480         # Get the values that were passed to the subroutine.
4481
4482         my ($database, $newsection, $altersection, $newtemplate, $altertemplate, $newsettings, $altersettings, $confirm, @filelist) = @_;
4483
4484         # Check if the file list is blank and return an error
4485         # if it is.
4486
4487         if (!@filelist){
4488
4489                 # The file list really is blank so return
4490                 # an error.
4491
4492                 kiriwrite_error("nopagesselected");
4493
4494         }
4495
4496         # Check if certain values are undefined and define them if
4497         # they are.
4498
4499         if (!$altersection){
4500
4501                 # The alter section value is blank, so set it to
4502                 # off.
4503
4504                 $altersection   = "off";
4505
4506         }
4507
4508         if (!$altertemplate){
4509
4510                 # The alter template value is blank, so set it to
4511                 # off.
4512
4513                 $altertemplate  = "off";
4514
4515         }
4516
4517         if (!$altersettings){
4518
4519                 # The alter settings value is blank, so set it to
4520                 # off.
4521
4522                 $altersettings  = "off";
4523
4524         }
4525
4526         # Check if the database filename is valid and return an error if
4527         # it isn't.
4528
4529         my $pagedatabase_filename_check = kiriwrite_variablecheck($database, "filename", 0, 1);
4530
4531         if ($pagedatabase_filename_check eq 1){
4532
4533                 # The database filename is blank, so return an error.
4534
4535                 kiriwrite_error("blankdatabasepageadd");
4536
4537         } elsif ($pagedatabase_filename_check eq 2){
4538
4539                 # The database filename is invalid, so return an error.
4540
4541                 kiriwrite_error("databasefilenameinvalid");
4542
4543         }
4544
4545         # Check if the confirm value is blank and if it is then
4546         # set the confirm value to 0.
4547
4548         if (!$confirm){
4549
4550                 $confirm = 0;
4551
4552         }
4553
4554         if ($confirm eq 1){
4555
4556                 # The action to edit the template has been confirmed so
4557                 # edit the selected pages.
4558
4559                 # Check the values recieved at UTF8 compliant before
4560                 # converting.
4561
4562                 kiriwrite_variablecheck($newsection, "utf8", 0, 0);
4563                 kiriwrite_variablecheck($newtemplate, "utf8", 0, 0);
4564                 kiriwrite_variablecheck($newsettings, "utf8", 0, 0);
4565
4566                 # Convert the values into proper UTF8 values.
4567
4568                 $newsection     = kiriwrite_utf8convert($newsection);
4569                 $newtemplate    = kiriwrite_utf8convert($newtemplate);
4570                 $newsettings    = kiriwrite_utf8convert($newsettings);
4571
4572                 # Check the length of the variables.
4573
4574                 kiriwrite_variablecheck($altersection, "maxlength", 3, 0);
4575                 kiriwrite_variablecheck($altertemplate, "maxlength", 3, 0);
4576                 kiriwrite_variablecheck($altersettings, "maxlength", 3, 0);
4577                 my $newsection_maxlength_check  = kiriwrite_variablecheck($newsection, "maxlength", 256, 1);
4578                 my $newtemplate_maxlength_check = kiriwrite_variablecheck($newtemplate, "maxlength", 256, 1);
4579                 my $newtemplate_filename_check  = kiriwrite_variablecheck($newtemplate, "filename", 0, 1);
4580                 my $newsettings_maxlength_check = kiriwrite_variablecheck($newsettings, "maxlength", 1, 1);
4581                 my $newsettings_settings_check  = kiriwrite_variablecheck($newsettings, "pagesetting", 0, 1);
4582
4583                 # Check the values and return an error if needed.
4584
4585                 if ($newsection_maxlength_check eq 1 && $altersection eq "on"){
4586
4587                         # The new section name is too long, so return an
4588                         # error.
4589
4590                         kiriwrite_error("pagesectiontoolong");
4591
4592                 }
4593
4594                 if ($newtemplate_maxlength_check eq 1 && $altertemplate eq "on"){
4595
4596                         # The new template name is too long, so return an
4597                         # error.
4598
4599                         kiriwrite_error("templatefilenametoolong");
4600
4601                 }
4602
4603                 # Check if the template filename is set to !skip or !none
4604                 # and skip this check if it is.
4605
4606                 if ($newtemplate eq "!skip" || $newtemplate eq "!none"){
4607
4608                         # Skip this check as the template filename is
4609                         # !skip or !none.
4610
4611                 } else {
4612                         if ($newtemplate_filename_check eq 1 && $altertemplate eq "on" || $newtemplate_filename_check eq 2 && $altertemplate eq "on"){
4613
4614                                 # The new template filename is invalid, so return
4615                                 # an error.
4616
4617                                 kiriwrite_error("templatefilenameinvalid");
4618
4619                         }
4620                 }
4621
4622                 if ($newsettings_maxlength_check eq 1 && $altertemplate eq "on"){
4623
4624                         # The new settings value is too long, so return
4625                         # an error.
4626
4627                         kiriwrite_error("pagesettingstoolong");
4628
4629                 }
4630
4631                 if ($newsettings_settings_check eq 1 && $altersettings eq "on"){
4632
4633                         # The new settings value is invalid, so return
4634                         # an error.
4635
4636                         kiriwrite_error("pagesettingsinvalid");
4637
4638                 }
4639
4640                 # Define some values for later.
4641
4642                 my %database_info;
4643                 my %edited_list;
4644                 my %warning_list;
4645                 my %page_info;
4646                 my $page;
4647                 my $warning;
4648                 my $filename;
4649                 my $page_name;
4650                 my $pagefound = 0;
4651                 my $pageedited = 0;
4652                 my $warning_count = 0;
4653
4654                 tie(%edited_list, 'Tie::IxHash');
4655                 tie(%warning_list, 'Tie::IxHash');
4656
4657                 # Check if the template filename is !skip and
4658                 # set the alter template value to off if it
4659                 # is.
4660
4661                 if ($newtemplate eq "!skip"){
4662
4663                         $altertemplate = "off";
4664
4665                 }
4666
4667                 # Check if all values are not selected and return
4668                 # an error if they are.
4669
4670                 if ($altersection ne "on" && $altertemplate ne "on" && $altersettings ne "on"){
4671
4672                         # All values are not selected so return
4673                         # an error.
4674
4675                         kiriwrite_error("noeditvaluesselected");
4676
4677                 }
4678
4679                 # Connect to the database server.
4680
4681                 $kiriwrite_dbmodule->connect();
4682
4683                 # Check if any errors occured while connecting to the database server.
4684
4685                 if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
4686
4687                         # A database connection error has occured so return
4688                         # an error.
4689
4690                         kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
4691
4692                 }
4693
4694                 # Select the database.
4695
4696                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $database });
4697
4698                 # Check if any errors occured while selecting the database.
4699
4700                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
4701
4702                         # The database does not exist, so return an error.
4703
4704                         kiriwrite_error("databasemissingfile");
4705
4706                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
4707
4708                         # The database has invalid permissions set, so return
4709                         # an error.
4710
4711                         kiriwrite_error("databaseinvalidpermissions");
4712
4713                 }
4714
4715                 # Check if the database has read and write permissions.
4716
4717                 my $database_permissions = $kiriwrite_dbmodule->dbpermissions($database, 1, 1);
4718
4719                 if ($database_permissions eq 1){
4720
4721                         # The database permissions are invalid so return an error.
4722
4723                         kiriwrite_error("databaseinvalidpermissions");
4724
4725                 }
4726
4727                 # Get information about the database.
4728
4729                 %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
4730
4731                 # Check if any errors had occured while getting the database
4732                 # information.
4733
4734                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
4735
4736                         # A database error has occured so return an error and
4737                         # also the extended error information.
4738
4739                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
4740
4741                 };
4742
4743                 my $database_name = $database_info{"DatabaseName"};
4744
4745                 # Edit the selected pages.
4746
4747                 foreach $filename (@filelist){
4748
4749                         # Get the page information.
4750
4751                         %page_info = $kiriwrite_dbmodule->getpageinfo({ PageFilename => $filename });
4752
4753                         # Check if any errors occured.
4754
4755                         if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
4756
4757                                 # A database error has occured so write a warning message.
4758
4759                                 $warning_list{$warning_count}{Message} = kiriwrite_language($kiriwrite_lang->{pages}->{databasepageerror}, $filename, $kiriwrite_dbmodule->geterror(1));
4760
4761                         } elsif ($kiriwrite_dbmodule->geterror eq "PageDoesNotExist"){
4762
4763                                 # The page does not exist, so write a warning message.
4764
4765                                 $warning_list{$warning_count}{Message} = kiriwrite_language($kiriwrite_lang->{pages}->{databasepagedoesnotexist}, $filename);
4766                                 $warning_count++;
4767                                 next;
4768
4769                         }
4770
4771                         # Check if the page section should be altered.
4772
4773                         if ($altersection eq "on"){
4774
4775                                 # Change the section name.
4776
4777                                 $page_info{"PageSection"} = $newsection;
4778
4779                         }
4780
4781                         # Check if the page template should be altered.
4782
4783                         if ($altertemplate eq "on"){
4784
4785                                 # Change the page template filename.
4786
4787                                 $page_info{"PageTemplate"} = $newtemplate;
4788
4789                         }
4790
4791                         # Check if the page settings should be altered.
4792
4793                         if ($altersettings eq "on"){
4794
4795                                 # Change the page settings value.
4796
4797                                 $page_info{"PageSettings"} = $newsettings;
4798
4799                         }
4800
4801                         # Edit the selected page.
4802
4803                         $kiriwrite_dbmodule->editpage({ PageFilename => $page_info{"PageFilename"}, PageNewFilename => $page_info{"PageFilename"}, PageNewName => $page_info{"PageName"}, PageNewDescription => $page_info{"PageDescription"}, PageNewSection => $page_info{"PageSection"}, PageNewTemplate => $page_info{"PageTemplate"}, PageNewContent => $page_info{"PageContent"}, PageNewSettings => $page_info{"PageSettings"} });
4804
4805                         # Check if any errors occured while editing the page.
4806
4807                         if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
4808
4809                                 # A database error has occured so write a warning message
4810                                 # with the extended error information.
4811
4812                                 $warning_list{$warning_count}{Message} = kiriwrite_language($kiriwrite_lang->{pages}->{databasepageerror}, $filename, $kiriwrite_dbmodule->geterror(1));
4813                                 $warning_count++;
4814                                 next;
4815
4816                         } elsif ($kiriwrite_dbmodule->geterror eq "PageDoesNotExist"){
4817
4818                                 # The pages does not exist in the database.
4819
4820                                 $warning_list{$warning_count}{Message} = kiriwrite_language($kiriwrite_lang->{pages}->{databasepagedoesnotexist}, $filename);
4821                                 $warning_count++;
4822                                 next;
4823
4824                         } elsif ($kiriwrite_dbmodule->geterror eq "PageExists"){
4825
4826                                 # A page already exists with the new filename.
4827
4828                                 kiriwrite_error("pagefilenameexists");
4829
4830                         }
4831
4832                         # The page has been edited so write a message saying that the page
4833                         # has been edited.
4834
4835                         $edited_list{$pageedited}{Filename}     = $page_info{"PageFilename"};
4836                         $edited_list{$pageedited}{Name}         = $page_info{"PageName"};
4837
4838                         # Increment the counter of edited pages.
4839
4840                         $pageedited++;
4841
4842                 }
4843
4844                 # Disconnect from the database server.
4845
4846                 $kiriwrite_dbmodule->disconnect();
4847
4848                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{multiedit}, { Style => "pageheader" });
4849                 $kiriwrite_presmodule->addlinebreak();
4850                 $kiriwrite_presmodule->addlinebreak();
4851
4852                 # Check if the counter of edited pages is 0 and if it is
4853                 # then write a message saying that no pages were edited
4854                 # else write a message listing all of the pages edited.
4855
4856                 if ($pageedited eq 0){
4857
4858                         $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{pages}->{nopagesedited}, $database_name));
4859
4860                 } else {
4861
4862                         # Write out the message saying that the selected pages
4863                         # were edited.
4864
4865                         $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{pages}->{pagesedited}, $database_name));
4866                         $kiriwrite_presmodule->addlinebreak();
4867                         $kiriwrite_presmodule->addlinebreak();
4868                         $kiriwrite_presmodule->startbox("datalist");
4869
4870                         foreach $page (keys %edited_list){
4871
4872                                 # Check if the page name is not blank.
4873
4874                                 if (!$edited_list{$page}{Name}){
4875
4876                                         $kiriwrite_presmodule->additalictext($kiriwrite_lang->{blank}->{noname});
4877                                         $kiriwrite_presmodule->addtext(" (" . $edited_list{$page}{Filename} . ")");
4878
4879                                 } else {
4880
4881                                         $kiriwrite_presmodule->addtext($edited_list{$page}{Name});
4882                                         $kiriwrite_presmodule->addtext(" (" . $edited_list{$page}{Filename} . ")");
4883
4884                                 }
4885
4886                                 $kiriwrite_presmodule->addlinebreak();
4887                         }
4888
4889                         $kiriwrite_presmodule->endbox();
4890
4891                 }
4892
4893                 # Check if any warnings have occured and write a message
4894                 # if any warnings did occur.
4895
4896                 if (%warning_list){
4897
4898                         # One or several warnings have occured so
4899                         # write a message.
4900
4901                         $kiriwrite_presmodule->addlinebreak();
4902                         $kiriwrite_presmodule->addlinebreak();
4903                         $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{editedpageswarnings});
4904                         $kiriwrite_presmodule->addlinebreak();
4905                         $kiriwrite_presmodule->addlinebreak();
4906                         $kiriwrite_presmodule->startbox("datalist");
4907                         foreach $warning (keys %warning_list) {
4908                                 $kiriwrite_presmodule->addtext($warning_list{$warning}{Message});
4909                                 $kiriwrite_presmodule->addlinebreak();
4910                         }
4911                         $kiriwrite_presmodule->endbox();
4912
4913                 }
4914
4915                 # Write a link going back to the page list for
4916                 # the selected database.
4917
4918                 $kiriwrite_presmodule->addlinebreak();
4919                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $database, { Text => kiriwrite_language($kiriwrite_lang->{pages}->{returnpagelist}, $database_name) });
4920
4921                 return $kiriwrite_presmodule->grab();
4922
4923         } elsif ($confirm eq 0){
4924
4925                 # The action to edit the template has not been confirmed
4926                 # so write a form out instead.
4927
4928                 # Connect to the database server.
4929
4930                 $kiriwrite_dbmodule->connect();
4931
4932                 # Check if any errors occured while connecting to the database server.
4933
4934                 if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
4935
4936                         # A database connection error has occured so return
4937                         # an error.
4938
4939                         kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
4940
4941                 }
4942
4943                 # Select the database.
4944
4945                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $database });
4946
4947                 # Check if any errors occured while selecting the database.
4948
4949                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
4950
4951                         # The database does not exist, so return an error.
4952
4953                         kiriwrite_error("databasemissingfile");
4954
4955                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
4956
4957                         # The database has invalid permissions set, so return
4958                         # an error.
4959
4960                         kiriwrite_error("databaseinvalidpermissions");
4961
4962                 }
4963
4964                 # Check if the database has read and write permissions.
4965
4966                 my $database_permissions = $kiriwrite_dbmodule->dbpermissions($database, 1, 1);
4967
4968                 if ($database_permissions eq 1){
4969
4970                         # The database permissions are invalid so return an error.
4971
4972                         kiriwrite_error("databaseinvalidpermissions");
4973
4974                 }
4975
4976                 # Get information about the database.
4977
4978                 my %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
4979
4980                 # Check if any errors had occured while getting the database
4981                 # information.
4982
4983                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
4984
4985                         # A database error has occured so return an error and
4986                         # also the extended error information.
4987
4988                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
4989
4990                 };
4991
4992                 my $database_name       = $database_info{"DatabaseName"};
4993
4994                 # Define some variables for later.
4995
4996                 my %edit_list;
4997                 my %template_list;
4998                 my %template_info;
4999                 my %page_info;
5000                 my @templates_list;
5001                 my @filenames;
5002                 my $filelist_filename;
5003                 my $filename;
5004                 my $page;
5005                 my $pageseek = 0;
5006                 my $page_name;
5007                 my $page_filename;
5008                 my $template;
5009                 my $template_filename;
5010                 my $template_warning;
5011                 my $templateseek = 0;
5012
5013                 tie(%edit_list, 'Tie::IxHash');
5014                 tie(%template_list, 'Tie::IxHash');
5015
5016                 # Get the information about each page that is going
5017                 # to be edited.
5018
5019                 foreach $filelist_filename (@filelist){
5020
5021                         %page_info = $kiriwrite_dbmodule->getpageinfo({ PageFilename => $filelist_filename });
5022
5023                         # Check if any errors occured.
5024
5025                         if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
5026
5027                                 # A database error has occured so return an error and
5028                                 # also the extended error information.
5029
5030                                 kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
5031
5032                         } elsif ($kiriwrite_dbmodule->geterror eq "PageDoesNotExist"){
5033
5034                                 # The page does not exist, so process the next page.
5035
5036                                 next;
5037
5038                         }
5039
5040                         # Add the page name and file name to the list of
5041                         # pages to edit.
5042
5043                         $edit_list{$pageseek}{Filename} = $page_info{"PageFilename"};
5044                         $edit_list{$pageseek}{Name}     = $page_info{"PageName"};
5045
5046                         # Increment the page seek counter and reset the
5047                         # page found value.
5048
5049                         $pageseek++;
5050
5051                 }
5052
5053                 # Check if any pages were found in the database and return
5054                 # an error if not.
5055
5056                 if ($pageseek eq 0){
5057
5058                         # No pages were found so return an error.
5059
5060                         kiriwrite_error("nopagesselected");
5061
5062                 }
5063
5064                 # Connect to the template database.
5065
5066                 $kiriwrite_dbmodule->connecttemplate();
5067
5068                 # Check if any errors had occured.
5069
5070                 if ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseDoesNotExist"){
5071
5072                         # The template database does not exist so write a warning
5073                         # message.
5074
5075                         $template_warning = $kiriwrite_lang->{pages}->{templatedatabasenotexistmultieditkeep};
5076
5077                 } elsif ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseInvalidPermissionsSet"){
5078
5079                         # The template database has invalid permissions set so
5080                         # return an error.
5081
5082                         $template_warning = $kiriwrite_lang->{pages}->{templatedatabasepermissionsinvalidmultieditkeep};
5083
5084                 }
5085
5086                 if (!$template_warning){
5087
5088                         # Get the list of templates available.
5089
5090                         @templates_list = $kiriwrite_dbmodule->gettemplatelist();
5091
5092                         # Check if any errors had occured.
5093
5094                         if ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseError"){
5095
5096                                 # A database error occured while getting the list
5097                                 # of templates so write a warning message with the
5098                                 # extended error information.
5099
5100                                 $template_warning = kiriwrite_language($kiriwrite_lang->{pages}->{templatedatabaseerrormultieditkeep}, $kiriwrite_dbmodule->geterror(1));
5101
5102                         }
5103
5104                         if (!$template_warning){
5105
5106                                 foreach $template_filename (@templates_list){
5107
5108                                         # Get the template data.
5109
5110                                         %template_info = $kiriwrite_dbmodule->gettemplateinfo({ TemplateFilename => $template_filename });
5111
5112                                         # Check if any error occured while getting the template information.
5113
5114                                         if ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseError"){
5115
5116                                                 # A database error has occured, so write a warning message with
5117                                                 # the extended error information.
5118
5119                                                 $template_warning = kiriwrite_language($kiriwrite_lang->{pages}->{templatedatabaseerrormultieditkeep}, $kiriwrite_dbmodule->geterror(1));
5120
5121                                         } elsif ($kiriwrite_dbmodule->geterror eq "TemplateDoesNotExist"){
5122
5123                                                 # The template does not exist, so process the next page.
5124
5125                                                 next;
5126
5127                                         }
5128
5129                                         # Add the template to the list of templates.
5130
5131                                         $template_list{$templateseek}{Filename} = $template_info{"TemplateFilename"};
5132                                         $template_list{$templateseek}{Name}     = $template_info{"TemplateName"};
5133
5134                                         $templateseek++;
5135
5136                                 }
5137
5138                         }
5139
5140                 }
5141
5142                 # Disconnect from the template database.
5143
5144                 $kiriwrite_dbmodule->disconnecttemplate();
5145
5146                 # Disconnect from the database server.
5147
5148                 $kiriwrite_dbmodule->disconnect();
5149
5150                 # Write a form for editing the selected pages.
5151
5152                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{multiedit}, { Style => "pageheader" });
5153                 $kiriwrite_presmodule->addlinebreak();
5154                 $kiriwrite_presmodule->addlinebreak();
5155                 $kiriwrite_presmodule->startform($kiriwrite_env{"script_filename"}, "POST");
5156                 $kiriwrite_presmodule->startbox();
5157                 $kiriwrite_presmodule->addhiddendata("mode", "page");
5158                 $kiriwrite_presmodule->addhiddendata("action", "multiedit");
5159                 $kiriwrite_presmodule->addhiddendata("database", $database);
5160                 $kiriwrite_presmodule->addhiddendata("count", $pageseek);
5161                 $kiriwrite_presmodule->addhiddendata("confirm", 1);
5162
5163                 $pageseek = 1;
5164
5165                 foreach $page (keys %edit_list){
5166                         $kiriwrite_presmodule->addhiddendata("name[" . $pageseek . "]", "on");
5167                         $kiriwrite_presmodule->addhiddendata("id[" . $pageseek  . "]", $edit_list{$page}{Filename});
5168                         $pageseek++;
5169                 }
5170
5171                 $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{pages}->{multieditmessage}, $database_name));
5172                 $kiriwrite_presmodule->addlinebreak();
5173                 $kiriwrite_presmodule->addlinebreak();
5174                 $kiriwrite_presmodule->startbox("datalist");
5175
5176                 foreach $page (keys %edit_list){
5177                         if (!$edit_list{$page}{Name}){
5178                                 $kiriwrite_presmodule->additalictext("No Name");
5179                                 $kiriwrite_presmodule->addtext(" (" . $edit_list{$page}{Filename} . ")");
5180                         } else {
5181                                 $kiriwrite_presmodule->addtext($edit_list{$page}{Name} . " (" . $edit_list{$page}{Filename} . ")");
5182                         }
5183
5184                         $kiriwrite_presmodule->addlinebreak();
5185                 }
5186
5187                 $kiriwrite_presmodule->endbox();
5188                 $kiriwrite_presmodule->addlinebreak();
5189                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{multieditmessagevalues});
5190                 $kiriwrite_presmodule->addlinebreak();
5191                 $kiriwrite_presmodule->addlinebreak();
5192                 $kiriwrite_presmodule->starttable("", { CellPadding => 5, CellSpacing => 0 });
5193
5194                 $kiriwrite_presmodule->startheader();
5195                 $kiriwrite_presmodule->addheader($kiriwrite_lang->{common}->{alter}, { Style => "tablecellheader" });
5196                 $kiriwrite_presmodule->addheader($kiriwrite_lang->{common}->{setting}, { Style => "tablecellheader" });
5197                 $kiriwrite_presmodule->addheader($kiriwrite_lang->{common}->{value}, { Style => "tablecellheader" });
5198                 $kiriwrite_presmodule->endheader();
5199
5200                 $kiriwrite_presmodule->startrow();
5201                 $kiriwrite_presmodule->addcell("tablecell1");
5202                 $kiriwrite_presmodule->addcheckbox("altersection");
5203                 $kiriwrite_presmodule->endcell();
5204                 $kiriwrite_presmodule->addcell("tablecell1");
5205                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{pagesection});
5206                 $kiriwrite_presmodule->endcell();
5207                 $kiriwrite_presmodule->addcell("tablecell1");
5208                 $kiriwrite_presmodule->addinputbox("newsection", { Size => 64, MaxLength => 256 });
5209                 $kiriwrite_presmodule->endcell();
5210                 $kiriwrite_presmodule->endrow();
5211
5212                 $kiriwrite_presmodule->startrow();
5213                 $kiriwrite_presmodule->addcell("tablecell2");
5214                 $kiriwrite_presmodule->addcheckbox("altertemplate");
5215                 $kiriwrite_presmodule->endcell();
5216                 $kiriwrite_presmodule->addcell("tablecell2");
5217                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{pagetemplate});
5218                 $kiriwrite_presmodule->endcell();
5219
5220                 $kiriwrite_presmodule->addcell("tablecell2");
5221
5222                 if ($template_warning){
5223
5224                         $kiriwrite_presmodule->addhiddendata("newtemplate", "!skip");
5225                         $kiriwrite_presmodule->addtext($template_warning);
5226
5227                 } else {
5228
5229                         $kiriwrite_presmodule->addselectbox("newtemplate");
5230
5231                         foreach $template (keys %template_list){
5232
5233                                 $kiriwrite_presmodule->addoption($template_list{$template}{Name} . " (" . $template_list{$template}{Filename} . ")", { Value => $template_list{$template}{Filename}});
5234
5235                         }
5236
5237                         $kiriwrite_presmodule->addoption($kiriwrite_lang->{pages}->{usenotemplate}, { Value => "!none", Selected => 1 });
5238                         $kiriwrite_presmodule->endselectbox();
5239                 }
5240
5241                 $kiriwrite_presmodule->endcell();
5242                 $kiriwrite_presmodule->endrow();
5243
5244                 $kiriwrite_presmodule->startrow();
5245                 $kiriwrite_presmodule->addcell("tablecell1");
5246                 $kiriwrite_presmodule->addcheckbox("altersettings");
5247                 $kiriwrite_presmodule->endcell();
5248                 $kiriwrite_presmodule->addcell("tablecell1");
5249                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{pages}->{pagesettings});
5250                 $kiriwrite_presmodule->endcell();
5251                 $kiriwrite_presmodule->addcell("tablecell1");
5252                 $kiriwrite_presmodule->addradiobox("newsettings", { Description => $kiriwrite_lang->{pages}->{usepageandsection}, Value => 1 , Selected => 1});
5253                 $kiriwrite_presmodule->addlinebreak();
5254                 $kiriwrite_presmodule->addradiobox("newsettings", { Description => $kiriwrite_lang->{pages}->{usepagename}, Value => 2 });
5255                 $kiriwrite_presmodule->addlinebreak();
5256                 $kiriwrite_presmodule->addradiobox("newsettings", { Description => $kiriwrite_lang->{pages}->{usesectionname}, Value => 3 });
5257                 $kiriwrite_presmodule->addlinebreak();
5258                 $kiriwrite_presmodule->addradiobox("newsettings", { Description => $kiriwrite_lang->{pages}->{nopagesection}, Value => 0 });
5259                 $kiriwrite_presmodule->endcell();
5260                 $kiriwrite_presmodule->endrow();
5261
5262                 $kiriwrite_presmodule->endtable();
5263                 $kiriwrite_presmodule->addlinebreak();
5264                 $kiriwrite_presmodule->addsubmit($kiriwrite_lang->{pages}->{editpagesbutton});
5265                 $kiriwrite_presmodule->addtext(" | ");
5266                 $kiriwrite_presmodule->addreset($kiriwrite_lang->{common}->{clearvalues});
5267                 $kiriwrite_presmodule->addtext(" | ");
5268                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $database, { Text => kiriwrite_language($kiriwrite_lang->{pages}->{returnpagelist}, $database_name) });
5269                 $kiriwrite_presmodule->endbox();
5270                 $kiriwrite_presmodule->endform();
5271
5272                 return $kiriwrite_presmodule->grab();
5273
5274         } else {
5275
5276                 # The confirm value is something else other than
5277                 # 1 or 0, so return an error.
5278
5279                 kiriwrite_error("invalidvariable");
5280
5281         }
5282
5283 }
5284
5285 1;