cgi-files/Modules/System/Page.pm

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