cgi-files/lib/compile.lib

   1 #################################################################################
   2 # compile.lib: Kiriwrite Compile Library                                        #
   3 #                                                                               #
   4 # This library is under the same license as the main Kiriwrite script.          #
   5 #################################################################################
   6
   7 # This section of the file is for when the library is called from the main
   8 # Kiriwrite script.
   9
  10 # If the action option is left blank, then print out a form where the list
  11 # of databases to compile are available.
  12
  13 if ($form_data->{'action'}){
  14
  15         my $http_query_action = $form_data->{'action'};
  16
  17         if ($http_query_action eq "compile"){
  18
  19                 # The specified action is to compile the pages, check if the
  20                 # action to compile the page has been confirmed.
  21
  22                 my $http_query_confirm  = $form_data->{'confirm'};
  23                 my $http_query_type     = $form_data->{'type'};
  24
  25                 # If it is blank, set the confirm value to 0.
  26
  27                 if (!$http_query_confirm){
  28
  29                         # The http_query_confirm variable is uninitalised, so place a
  30                         # '0' (meaning an unconfirmed action).
  31
  32                         $http_query_confirm = 0;
  33
  34                 }
  35
  36                 # If the compile type is blank then return an error.
  37
  38                 if (!$http_query_type){
  39
  40                         # Compile type is blank so return an error.
  41
  42                         kiriwrite_error("blankcompiletype");
  43
  44                 }
  45
  46                 if ($http_query_type eq "multiple"){
  47
  48                         if ($http_query_confirm eq 1){
  49
  50                                 # The action to compile the pages has been confirmed so
  51                                 # compile the pages.
  52
  53                                 my $http_query_override         = $form_data->{'enableoverride'};
  54                                 my $http_query_overridetemplate = $form_data->{'overridetemplate'};
  55
  56                                 my @selectedlist = kiriwrite_selectedlist();
  57                                 my $pagedata = kiriwrite_compile_makepages($http_query_type, $http_query_confirm, $http_query_override, $http_query_overridetemplate, @selectedlist);
  58
  59                                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
  60                                 kiriwrite_output_page($kiriwrite_lang->{compile}->{compilepages}, $pagedata, "compile"); # Output the page to browser/console/stdout.
  61                                 exit;                           # End the script.
  62
  63                         } else {
  64
  65                                 # The action to compile the pages has not been confirmed
  66                                 # so write a form asking the user to confirm the action
  67                                 # of compiling the pages.
  68
  69                                 my @selectedlist = kiriwrite_selectedlist();
  70                                 my $pagedata = kiriwrite_compile_makepages($http_query_type, $http_query_confirm, "", "", @selectedlist);
  71
  72                                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
  73                                 kiriwrite_output_page($kiriwrite_lang->{compile}->{compileselecteddatabases}, $pagedata, "compile"); # Output the page to browser/console/stdout.
  74                                 exit;                           # End the script.
  75
  76                         }
  77
  78                 } elsif ($http_query_type eq "single"){
  79
  80                         my $http_query_database = $form_data->{'database'};
  81                         my @selectedlist;
  82                         $selectedlist[0] = $http_query_database;
  83                         my $pagedata = kiriwrite_compile_makepages($http_query_type, $http_query_confirm, "", "", @selectedlist);
  84
  85                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
  86                         kiriwrite_output_page($kiriwrite_lang->{compile}->{compiledatabase}, $pagedata, "compile");
  87                         exit;                           # End the script.
  88
  89                 } else {
  90
  91                         kiriwrite_error("invalidcompiletype");
  92
  93                 }
  94
  95         } elsif ($http_query_action eq "all"){
  96
  97                 # The selected action is to compile all of the databases
  98                 # in the database directory. Check if the action to
  99                 # compile all of the databases has been confirmed.
 100
 101                 my $http_query_confirm = $form_data->{'confirm'};
 102
 103                 if (!$http_query_confirm){
 104
 105                         # The http_query_confirm variable is uninitalised, so place a
 106                         # '0' (meaning an unconfirmed action).
 107
 108                         $http_query_confirm = 0;
 109
 110                 }
 111
 112                 if ($http_query_confirm eq 1){
 113
 114                         # The action to compile all the databases has been confirmed.
 115
 116                 }
 117
 118                 my $pagedata = kiriwrite_compile_all();
 119
 120                 kiriwrite_output_header;                        # Output the header to browser/console/stdout.
 121                 kiriwrite_output_page($kiriwrite_lang->{compile}->{compilealldatabases}, $pagedata, "compile");
 122                 exit;
 123
 124         } elsif ($http_query_action eq "clean") {
 125
 126                 # The selected action is to clean the output directory.
 127                 # Check if the action to clean the output directory
 128                 # has been confirmed.
 129
 130                 my $http_query_confirm = $form_data->{'confirm'};
 131
 132                 if (!$http_query_confirm){
 133
 134                         # The http_query_confirm variable is uninitalised, so place a
 135                         # '0' (meaning an unconfirmed action).
 136
 137                         $http_query_confirm = 0;
 138
 139                 }
 140
 141                 if ($http_query_confirm eq 1){
 142
 143                         # The action to clean the output directory has been confirmed.
 144
 145                         my $pagedata = kiriwrite_compile_clean($http_query_confirm);
 146
 147                         kiriwrite_output_header;                # Output the header to browser/console/stdout.
 148                         kiriwrite_output_page($kiriwrite_lang->{compile}->{cleanoutputdirectory}, $pagedata, "compile");        # Output the page to browser/console/stdout.
 149                         exit;                                   # End the script.
 150
 151                 }
 152
 153                 # The action to clean the output directory is not
 154                 # confirmed, so write a page asking the user
 155                 # to confirm cleaning the output directory.
 156
 157                 my $pagedata = kiriwrite_compile_clean();
 158
 159                 kiriwrite_output_header;                # Output the header to browser/console/stdout.
 160                 kiriwrite_output_page($kiriwrite_lang->{compile}->{cleanoutputdirectory}, $pagedata, "compile");        # Output the page to browser/console/stdout.
 161                 exit;                                   # End the script.
 162
 163         } else {
 164
 165                 # The action specified was something else other than those
 166                 # above, so return an error.
 167
 168                 kiriwrite_error("invalidaction");
 169
 170         }
 171 }
 172
 173 my $pagedata = kiriwrite_compile_list();
 174
 175 kiriwrite_output_header;                # Output the header to browser/console/stdout.
 176 kiriwrite_output_page($kiriwrite_lang->{compile}->{compilepages}, $pagedata, "compile");        # Output the page to browser/console/stdout.
 177 exit;                                   # End the script.
 178
 179 #################################################################################
 180 # Begin list of relevant subroutines.                                           #
 181 #################################################################################
 182
 183 sub kiriwrite_compile_makepages{
 184 #################################################################################
 185 # kiriwrite_compile_makepages: Compile the selected pages and place them in the #
 186 # specified output directory.                                                   #
 187 #                                                                               #
 188 # Usage:                                                                        #
 189 #                                                                               #
 190 # kiriwrite_compile_makepages(type, selectedlist, override, overridetemplate,   #
 191 #                               confirm);                                       #
 192 #                                                                               #
 193 # type                  Specifies if single or multiple databases are to be     #
 194 #                       compiled.                                               #
 195 # confirm               Specifies if the action to compile the databases should #
 196 #                       really be done.                                         #
 197 # override              Specifies if the template should be overriden.          #
 198 # overridetemplate      Specifies the name of the template to override with.    #
 199 # selectedlist          Specifies the databases to compile from as an array.    #
 200 #################################################################################
 201
 202         # Get the values that have been passed to the subroutine.
 203
 204         my ($type, $confirm, $override, $override_template, @selectedlist) = @_;
 205
 206         # Check if the confirm value is more than one
 207         # character long.
 208
 209         kiriwrite_variablecheck($confirm, "maxlength", 1, 0);
 210
 211         # Check if the value for enabling the override feature
 212         # is "on" or blank and if it is something else then
 213         # return an error.
 214
 215         if ($override eq "on"){
 216         } elsif (!$override){
 217         } else {
 218
 219                 # The override value is invalid so return an error.
 220
 221                 kiriwrite_error("overridetemplatevalueinvalid");
 222
 223         }
 224
 225         # Check if the override template filename is valid and
 226         # return an error if it isn't.
 227
 228         kiriwrite_variablecheck($override_template, "utf8", 0, 0);
 229         $override_template      = kiriwrite_utf8convert($override_template);
 230         $kiriwrite_overridetemplatefilename_length_check        = kiriwrite_variablecheck($override_template, "maxlength", 64, 1);
 231         $kiriwrite_overridetemplatefilename_filename_check      = kiriwrite_variablecheck($override_template, "filename", "", 1);
 232
 233         if ($kiriwrite_overridetemplatefilename_length_check eq 1){
 234
 235                 # The override template filename given is too long
 236                 # so return an error.
 237
 238                 kiriwrite_error("overridetemplatetoolong");
 239
 240         }
 241
 242         if ($kiriwrite_overridetemplatefilename_filename_check eq 2 && $override_template ne "!none"){
 243
 244                 # The override template filename is invalid so
 245                 # return an error.
 246
 247                 kiriwrite_error("overridetemplateinvalid");
 248
 249         }
 250
 251         # Check if the confirm value is blank and if it
 252         # is then set the confirm value to 0.
 253
 254         if (!$confirm){
 255
 256                 # The confirm value is blank, so set the
 257                 # confirm value to 0.
 258
 259                 $confirm = 0;
 260
 261         }
 262
 263         # Check if there are any databases selected
 264         # and return an error if there isn't.
 265
 266         if (!@selectedlist){
 267
 268                 # There are no databases in the array
 269                 # so return an error.
 270
 271                 kiriwrite_error("nodatabaseselected");
 272
 273         }
 274
 275         # Check if the type given is no more than
 276         # 7 characters long.
 277
 278         my $type_maxlength_check = kiriwrite_variablecheck($type, "maxlength", 8, 1);
 279
 280         if ($type_maxlength_check eq 1){
 281
 282                 # The type length given is too long so
 283                 # return an error.
 284
 285                 kiriwrite_error("variabletoolong");
 286
 287         }
 288
 289         # Check if the action to compile the databases
 290         # has been confirmed.
 291
 292         if ($confirm eq 1){
 293
 294                 # The action to compile the datavases has
 295                 # been confirmed.
 296
 297                 # Define some variables for later.
 298
 299                 my %database_info;
 300                 my %filter_info;
 301                 my %template_info;
 302                 my %page_info;
 303                 my %templatefiles;
 304                 my @page_filenames;
 305                 my @databaseinfo;
 306                 my @databasepages;
 307                 my @filterslist;
 308                 my @findfilter;
 309                 my @replacefilter;
 310                 my @templateslist;
 311                 my @pagedirectories;
 312                 my @database_filters;
 313                 my $warning_count               = 0;
 314                 my $error_count                 = 0;
 315                 my $pages_count                 = 0;
 316                 my $filter;
 317                 my $filters_count               = 0;
 318                 my $filters_find_blank_warning  = 0;
 319                 my $filter_find;
 320                 my $filter_replace;
 321                 my $database;
 322                 my $database_name;
 323                 my $page_filename;
 324                 my $page_filename_check;
 325                 my $page_filename_char          = "";
 326                 my $page_filename_directory;
 327                 my $page_filename_length        = 0;
 328                 my $page_filename_seek          = 0;
 329                 my $page_filename_dircount      = 0;
 330                 my $page_filename_exists        = 0;
 331                 my $page_filename_permissions   = 0;
 332                 my $page_directory_name;
 333                 my $page_directory_path;
 334                 my $page_name;
 335                 my $page_description;
 336                 my $page_section;
 337                 my $page_template;
 338                 my $page_content;
 339                 my $page_settings;
 340                 my $page_lastmodified;
 341                 my $page_title;
 342                 my $page_final;
 343                 my $page_autosection;
 344                 my $page_autotitle;
 345                 my $page;
 346                 my $database_filename_check     = 0;
 347                 my $database_maxlength_check    = 0;
 348                 my $output_exists               = 0;
 349                 my $output_permissions          = 0;
 350                 my $filters_exists              = 0;
 351                 my $filters_permissions         = 0;
 352                 my $filters_skip                = 0;
 353                 my $template;
 354                 my $templates_skip              = 0;
 355                 my $information_prefix          = $kiriwrite_lang->{compile}->{informationprefix};
 356                 my $error_prefix                = $kiriwrite_lang->{compile}->{errorprefix};
 357                 my $warning_prefix              = $kiriwrite_lang->{compile}->{warningprefix};
 358                 my $filehandle_page;
 359
 360                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{compile}->{compiledatabases}, { Style => "pageheader" });
 361                 $kiriwrite_presmodule->addlinebreak();
 362                 $kiriwrite_presmodule->addlinebreak();
 363                 $kiriwrite_presmodule->startbox("datalist");
 364
 365                 # Check if the output directory exists and has
 366                 # valid permissions set.
 367
 368                 $output_exists          = kiriwrite_fileexists($kiriwrite_config{'directory_data_output'});
 369
 370                 if ($output_exists ne 0){
 371
 372                         # The output directory does not exist so
 373                         # return an error.
 374
 375                         kiriwrite_error("outputdirectorymissing");
 376
 377                 }
 378
 379                 $output_permissions     = kiriwrite_filepermissions($kiriwrite_config{'directory_data_output'}, 1, 1);
 380
 381                 if ($output_permissions ne 0){
 382
 383                         # The output directory has invalid
 384                         # permissions set so return an error.
 385
 386                         kiriwrite_error("outputdirectoryinvalidpermissions");
 387
 388                 }
 389
 390                 # Connect to the database server.
 391
 392                 $kiriwrite_dbmodule->connect();
 393
 394                 # Check if any errors occured while connecting to the database server.
 395
 396                 if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
 397
 398                         # A database connection error has occured so return
 399                         # an error.
 400
 401                         kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
 402
 403                 }
 404
 405                 # Connect to the filter database.
 406
 407                 $kiriwrite_dbmodule->connectfilter();
 408
 409                 # Check if any error has occured while connecting to the filter
 410                 # database.
 411
 412                 if ($kiriwrite_dbmodule->geterror eq "FilterDatabaseDoesNotExist"){
 413
 414                         # The filter database does not exist so write a warning message.
 415
 416                         $kiriwrite_presmodule->addtext($warning_prefix . $kiriwrite_lang->{compile}->{filterdatabasemissing});
 417                         $kiriwrite_presmodule->addlinebreak();
 418                         $filters_skip = 1;
 419                         $warning_count++;
 420
 421                 } elsif ($kiriwrite_dbmodule->geterror eq "FilterDatabaseInvalidPermissionsSet"){
 422
 423                         # The filter database has invalid permissions set so write a
 424                         # an error message.
 425
 426                         $kiriwrite_presmodule->addtext($error_prefix . $kiriwrite_lang->{compile}->{filterdatabasepermissions});
 427                         $kiriwrite_presmodule->addlinebreak();
 428                         $filters_skip = 1;
 429                         $error_count++;
 430
 431                 }
 432
 433                 # Load the filter database (if the filters skip
 434                 # value isn't set to 1).
 435
 436                 if ($filters_skip eq 0){
 437
 438                         # Get the list of available filters.
 439
 440                         @database_filters       = $kiriwrite_dbmodule->getfilterlist();
 441
 442                         # Check if any errors occured while getting the list of filters.
 443
 444                         if ($kiriwrite_dbmodule->geterror eq "FilterDatabaseError"){
 445
 446                                 # A database error has occured with the filter database.
 447
 448                                 $kiriwrite_presmodule->addtext($error_prefix . kiriwrite_language($kiriwrite_lang->{compile}->{filterdatabaseerror}, $kiriwrite_dbmodule->geterror(1)));
 449                                 $kiriwrite_presmodule->addlinebreak();
 450                                 $error_count++;
 451
 452                         }
 453
 454                         # Check if the filters skip value is set to 0
 455                         # before executing the query.
 456
 457                         if ($filters_skip eq 0){
 458
 459                                 foreach $filter (@database_filters){
 460
 461                                         # Get the filter information.
 462
 463                                         %filter_info = $kiriwrite_dbmodule->getfilterinfo({ FilterID => $filter, Reduced => 1 });
 464
 465                                         # Check if any errors occured while getting the filter information.
 466
 467                                         if ($kiriwrite_dbmodule->geterror eq "FilterDatabaseError"){
 468
 469                                                 # A database error occured while using the filter database.
 470
 471                                                 $kiriwrite_presmodule->addtext($error_prefix . kiriwrite_language($kiriwrite_lang->{compile}->{filterdatabaseerror}, $kiriwrite_dbmodule->geterror(1)));
 472                                                 $kiriwrite_presmodule->addlinebreak();
 473                                                 $error_count++;
 474                                                 next;
 475
 476                                         } elsif ($kiriwrite_dbmodule->geterror eq "FilterDoesNotExist"){
 477
 478                                                 # The filter does not exist so process the next filter.
 479
 480                                                 next;
 481
 482                                         }
 483
 484                                         # Check if the find filter is blank and
 485                                         # if it is then write a warning message.
 486
 487                                         if (!$filter_info{"FilterFind"}){
 488
 489                                                 if ($filters_find_blank_warning ne 1){
 490
 491                                                         $kiriwrite_presmodule->addtext($warning_prefix . $kiriwrite_lang->{compile}->{findfilterblank});
 492                                                         $kiriwrite_presmodule->addlinebreak();
 493                                                         $filters_find_blank_warning = 1;
 494                                                 }
 495                                                 next;
 496
 497                                         } else {
 498
 499                                                 # Add each find and replace filter.
 500
 501                                                 $findfilter[$filters_count]     = $filter_info{"FilterFind"};
 502                                                 $replacefilter[$filters_count]  = $filter_info{"FilterReplace"};
 503
 504                                         }
 505
 506                                         $filters_count++;
 507
 508                                 }
 509
 510                                 $kiriwrite_presmodule->addtext($information_prefix . $kiriwrite_lang->{compile}->{finishfilterdatabase});
 511                                 $kiriwrite_presmodule->addlinebreak();
 512
 513                         }
 514
 515                 }
 516
 517                 # Disconnect from the filter database.
 518
 519                 $kiriwrite_dbmodule->disconnectfilter();
 520
 521                 # Connect to the template database.
 522
 523                 $kiriwrite_dbmodule->connecttemplate();
 524
 525                 # Check if any errors occured while connecting to the template database.
 526
 527                 if ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseDoesNotExist"){
 528
 529                         # The template database does not exist so set the template
 530                         # warning message.
 531
 532                         $kiriwrite_presmodule->addtext($warning_prefix . $kiriwrite_lang->{compile}->{templatedatabasemissing});
 533                         $kiriwrite_presmodule->addlinebreak();
 534                         $templates_skip = 1;
 535                         $warning_count++;
 536
 537                 } elsif ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseInvalidPermissionsSet"){
 538
 539                         # The template database has invalid permissions set so write
 540                         # the template warning message.
 541
 542                         $kiriwrite_presmodule->addtext($error_prefix . $kiriwrite_lang->{compile}->{templatedatabasepermissions});
 543                         $kiriwrite_presmodule->addlinebreak();
 544                         $templates_skip = 1;
 545                         $error_count++;
 546
 547                 }
 548
 549                 # Check if the template skip value isn't set and if it isn't
 550                 # then get the list of templates.
 551
 552                 if (!$templates_skip){
 553
 554                         @templateslist = $kiriwrite_dbmodule->gettemplatelist();
 555
 556                         # Check if any errors had occured.
 557
 558                         if ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseError"){
 559
 560                                 # A database error occured while getting the list
 561                                 # of templates so return a warning message with the
 562                                 # extended error information.
 563
 564                                 $kiriwrite_presmodule->addtext($error_prefix . kiriwrite_language($kiriwrite_lang->{compile}->{templatedatabaseerror}, $kiriwrite_dbmodule->geterror(1)));
 565                                 $templates_skip = 1;
 566                                 $error_count++;
 567
 568                         }
 569
 570                         # Check if the template skip value isn't set and if it isn't
 571                         # then process each template.
 572
 573                         if (!$templates_skip){
 574
 575                                 # Process each template.
 576
 577                                 foreach $template (@templateslist){
 578
 579                                         # Get information about the template.
 580
 581                                         %template_info = $kiriwrite_dbmodule->gettemplateinfo({ TemplateFilename => $template });
 582
 583                                         # Check if any error occured while getting the template information.
 584
 585                                         if ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseError"){
 586
 587                                                 # A database error has occured, so return an error.
 588
 589                                                 $kiriwrite_presmodule->addtext($error_prefix . kiriwrite_language($kiriwrite_lang->{compile}->{templatedatabaseerror}, $kiriwrite_dbmodule->geterror(1)));
 590                                                 $error_count++;
 591
 592                                         } elsif ($kiriwrite_dbmodule->geterror eq "TemplateDoesNotExist"){
 593
 594                                                 # The template does not exist, so process the next template.
 595
 596                                                 next;
 597
 598                                         }
 599
 600                                         # Place each template file into the hash.
 601
 602                                         $templatefiles{$template_info{"TemplateFilename"}}{template}    = $template_info{"TemplateLayout"};
 603                                         $templatefiles{$template_info{"TemplateFilename"}}{valid}       = 1;
 604
 605                                 }
 606
 607                                 $kiriwrite_presmodule->addtext($information_prefix . $kiriwrite_lang->{compile}->{finishtemplatedatabase});
 608                                 $kiriwrite_presmodule->addlinebreak();
 609
 610                         }
 611
 612                 }
 613
 614                 # Disconnect from the template database.
 615
 616                 $kiriwrite_dbmodule->disconnecttemplate();
 617
 618                 # Process each database.
 619
 620                 foreach $database (@selectedlist){
 621
 622                         # Check if the database filename and length
 623                         # are valid.
 624
 625                         $kiriwrite_presmodule->addhorizontalline();
 626
 627                         $database_filename_check        = kiriwrite_variablecheck($database, "page_filename", "", 1);
 628                         $database_maxlength_check       = kiriwrite_variablecheck($database, "maxlength", 32, 1);
 629
 630                         if ($database_filename_check ne 0){
 631
 632                                 # The database filename is invalid, so process
 633                                 # the next database.
 634
 635                                 $kiriwrite_presmodule->addtext($error_prefix . kiriwrite_language($kiriwrite_lang->{compile}->{databasefilenameinvalidcharacters}, $database));
 636                                 $kiriwrite_presmodule->addlinebreak();
 637                                 $error_count++;
 638                                 next;
 639
 640                         }
 641
 642                         if ($database_maxlength_check ne 0){
 643
 644                                 # The database file is too long, so process the
 645                                 # next database.
 646
 647                                 $kiriwrite_presmodule->addtext($error_prefix . kiriwrite_language($kiriwrite_lang->{compile}->{databasefilenametoolong}, $database));
 648                                 $kiriwrite_presmodule->addlinebreak();
 649                                 $error_count++;
 650                                 next;
 651
 652                         }
 653
 654                         # Select the database.
 655
 656                         $kiriwrite_dbmodule->selectdb({ DatabaseName => $database });
 657
 658                         # Check if any errors had occured while selecting the database.
 659
 660                         if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
 661
 662                                 # The database does not exist, so write a warning message.
 663
 664                                 $kiriwrite_presmodule->addtext($warning_prefix . kiriwrite_language($kiriwrite_lang->{compile}->{databasemissing}, $database));
 665                                 $kiriwrite_presmodule->addlinebreak();
 666                                 $warning_count++;
 667                                 next;
 668
 669                         } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
 670
 671                                 # The database has invalid permissions set, so write
 672                                 # an error message.
 673
 674                                 $kiriwrite_presmodule->addtext($error_prefix . kiriwrite_language($kiriwrite_lang->{compile}->{databaseinvalidpermissions}, $database));
 675                                 $kiriwrite_presmodule->addlinebreak();
 676                                 $error_count++;
 677                                 next;
 678
 679                         }
 680
 681                         # Get information about the database.
 682
 683                         my %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
 684
 685                         # Check if any error occured while getting the database information.
 686
 687                         if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
 688
 689                                 # A database error has occured so write an error.
 690
 691                                 $kiriwrite_presmodule->addtext($error_prefix . kiriwrite_language($kiriwrite_lang->{compile}->{databaseerror}, $database, $kiriwrite_dbmodule->geterror(1)));
 692                                 $kiriwrite_presmodule->addlinebreak();
 693                                 $error_count++;
 694                                 next;
 695
 696                         };
 697
 698                         # Get the database name.
 699
 700                         $database_name = $database_info{"DatabaseName"};
 701
 702                         $kiriwrite_presmodule->addtext($information_prefix . kiriwrite_language($kiriwrite_lang->{compile}->{compilingpages}, $database_name));
 703                         $kiriwrite_presmodule->addlinebreak();
 704
 705                         # Get the list of pages in the database.
 706
 707                         @databasepages = $kiriwrite_dbmodule->getpagelist();
 708
 709                         # Check if any errors occured while getting the list of pages.
 710
 711                         if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
 712
 713                                 # A database error has occured so return an error and
 714                                 # also the extended error information.
 715
 716                                 $kiriwrite_presmodule->addtext($error_prefix . kiriwrite_language($kiriwrite_lang->{compile}->{databasepageerror}, $database, $kiriwrite_dbmodule->geterror(1)));
 717                                 $kiriwrite_presmodule->addlinebreak();
 718                                 $error_count++;
 719                                 next;
 720
 721                         }
 722
 723                         foreach $page (@databasepages) {
 724
 725                                 # Get information about the page.
 726
 727                                 %page_info = $kiriwrite_dbmodule->getpageinfo({ PageFilename => $page });
 728
 729                                 $page_filename          = $page_info{"PageFilename"};
 730                                 $page_name              = $page_info{"PageName"};
 731                                 $page_description       = $page_info{"PageDescription"};
 732                                 $page_section           = $page_info{"PageSection"};
 733                                 $page_template          = $page_info{"PageTemplate"};
 734                                 $page_content           = $page_info{"PageContent"};
 735                                 $page_settings          = $page_info{"PageSettings"};
 736                                 $page_lastmodified      = $page_info{"PageLastModified"};
 737
 738                                 # Check if the filename is valid.
 739
 740                                 $page_filename_check = kiriwrite_variablecheck($page_filename, "page_filename", 0, 1);
 741
 742                                 if ($page_filename_check ne 0){
 743
 744                                         # The file name is not valid so write a
 745                                         # error and process the next page.
 746
 747                                         $kiriwrite_presmodule->addtext($error_prefix . kiriwrite_language($kiriwrite_lang->{compile}->{invalidpagefilename}, $page_name));
 748                                         $kiriwrite_presmodule->addlinebreak();
 749                                         $error_count++;
 750                                         next;
 751
 752                                 }
 753
 754                                 # Check if the template with the filename does not exist
 755                                 # in the template files hash and write a message and
 756                                 # process the next page.
 757
 758                                 if ($override eq "on"){
 759
 760                                         $page_template = $override_template;
 761
 762                                 }
 763
 764                                 if (!$templatefiles{$page_template}{valid} && $page_template ne "!none" && $templates_skip eq 0){
 765
 766                                         $kiriwrite_presmodule->addtext($error_prefix . kiriwrite_language($kiriwrite_lang->{compile}->{templatefilemissing}, $page_template, $page_name, $page_filename));
 767                                         $kiriwrite_presmodule->addlinebreak();
 768                                         $error_count++;
 769                                         next;
 770
 771                                         $page_final = $page_content;
 772
 773                                 } elsif ($page_template eq "!none"){
 774
 775                                         $page_final = $page_content;
 776
 777                                 } else {
 778
 779                                         $page_final = $templatefiles{$page_template}{template};
 780
 781                                         if (!$page_final){
 782                                                 $page_final = "";
 783                                         }
 784
 785                                         $page_final =~ s/<kiriwrite:pagecontent>/$page_content/g;
 786
 787                                 }
 788
 789                                 # Create the combined page title (if needed).
 790
 791                                 if ($page_settings eq 0 || $page_settings > 3){
 792
 793                                         # Don't use page name or section name.
 794
 795                                         $page_final =~ s/<kiriwrite:pagetitle>//g;
 796
 797                                 } elsif ($page_settings eq 1){
 798
 799                                         # Use the page name and section name.
 800
 801                                         $page_autotitle = "(" . $page_section . " - " . $page_name . ")";
 802                                         $page_title = $page_section . " - " . $page_name;
 803                                         $page_final =~ s/<kiriwrite:pagetitle>/$page_title/g;
 804
 805                                 } elsif ($page_settings eq 2){
 806
 807                                         # Use the page name only.
 808
 809                                         $page_autotitle = "(" . $page_name . ")";
 810                                         $page_final =~ s/<kiriwrite:pagetitle>/$page_name/g;
 811
 812                                 } elsif ($page_settings eq 3){
 813
 814                                         # Use the section name only.
 815
 816                                         if ($page_section){
 817                                                 $page_autotitle = "(" . $page_section . ")";
 818                                         }
 819                                         $page_final =~ s/<kiriwrite:pagetitle>/$page_section/g;
 820
 821                                 }
 822
 823                                 # Check if the section name is not blank and
 824                                 # place brackets inbetween if it is.
 825
 826                                 if ($page_section){
 827
 828                                         $page_autosection = "(" . $page_section . ")";
 829
 830                                 }
 831
 832                                 # Replace each <kiriwrite> value with the apporiate page
 833                                 # values.
 834
 835                                 $page_final =~ s/<kiriwrite:pagename>/$page_name/g;
 836                                 $page_final =~ s/<kiriwrite:pagedescription>/$page_description/g;
 837                                 $page_final =~ s/<kiriwrite:pagesection>/$page_section/g;
 838                                 $page_final =~ s/<kiriwrite:autosection>/$page_autosection/g;
 839                                 $page_final =~ s/<kiriwrite:autotitle>/$page_autotitle/g;
 840
 841                                 # Process the filters on the page data.
 842
 843                                 if ($filters_skip eq 0){
 844
 845                                         $filters_count = 0;
 846
 847                                         foreach $filter_find (@findfilter){
 848
 849                                                 # Get the replace filter and process each
 850                                                 # filter on the page.
 851
 852                                                 $filter_replace = $replacefilter[$filters_count];
 853                                                 $page_final =~ s/$filter_find/$filter_replace/g;
 854                                                 $filters_count++;
 855
 856                                         }
 857
 858                                 }
 859
 860                                 # Process the page filename and check what directories
 861                                 # need to be created.
 862
 863                                 $page_filename_length = int(length($page_filename));
 864
 865                                 do {
 866
 867                                         $page_filename_char = substr($page_filename, $page_filename_seek, 1);
 868
 869                                         # Check if a forward slash appears and add it to
 870                                         # the list of directories array.
 871
 872                                         if ($page_filename_char eq '/'){
 873
 874                                                 # Append the directory name to the list of
 875                                                 # directories array.
 876
 877                                                 $pagedirectories[$page_filename_dircount] = $page_filename_directory;
 878                                                 $page_filename_directory        = "";
 879                                                 $page_filename_char             = "";
 880                                                 $page_filename_dircount++;
 881
 882                                         } else {
 883
 884                                                 # Append the character to the directory/filename.
 885
 886                                                 $page_filename_directory = $page_filename_directory . $page_filename_char;
 887
 888                                         }
 889
 890                                         $page_filename_seek++;
 891
 892                                 } until ($page_filename_length eq $page_filename_seek);
 893
 894                                 foreach $page_directory_name (@pagedirectories){
 895
 896                                         # Check if the directory name is undefined and if it
 897                                         # is then set it blank.
 898
 899                                         if (!$page_directory_name){
 900                                                 $page_directory_name = "";
 901                                         }
 902
 903                                         if (!$page_directory_path){
 904                                                 $page_directory_path = "";
 905                                         }
 906
 907                                         # Check if the directory exists and create
 908                                         # the directory if it doesn't exist.
 909
 910                                         $page_directory_path = $page_directory_path . '/' . $page_directory_name;
 911
 912                                         mkdir($kiriwrite_config{"directory_data_output"} . '/' . $page_directory_path);
 913
 914                                 }
 915
 916                                 # Check if the file already exists and if it does then check
 917                                 # the permissions of the file and return an error if the
 918                                 # permissions set are invalid.
 919
 920                                 $page_filename_exists = kiriwrite_fileexists($kiriwrite_config{"directory_data_output"} . '/' . $page_filename);
 921
 922                                 if ($page_filename_exists eq 0){
 923
 924                                         # The page filename exists, so check if the permissions given are
 925                                         # valid.
 926
 927                                         $page_filename_permissions = kiriwrite_filepermissions($kiriwrite_config{"directory_data_output"} . '/' . $page_filename, 1, 1);
 928
 929                                         if ($page_filename_permissions eq 1){
 930
 931                                                 # The file has invalid permissions set.
 932
 933                                                 $kiriwrite_presmodule->addtext($error_prefix . kiriwrite_language($kiriwrite_lang->{compile}->{pageinvalidpermissions}, $page_filename));
 934                                                 $kiriwrite_presmodule->addlinebreak();
 935                                                 $error_count++;
 936
 937                                                 # Reset certain values.
 938
 939                                                 $page_autotitle = "";
 940                                                 $page_autosection = "";
 941                                                 $page_filename_seek = 0;
 942                                                 $page_filename_dircount = 0;
 943
 944                                                 $page_filename_directory = "";
 945                                                 $page_directory_path = "";
 946                                                 $page_directory_name = "";
 947                                                 @pagedirectories = ();
 948
 949                                                 next;
 950
 951                                         }
 952
 953                                 }
 954
 955                                 # Reset certain values.
 956
 957                                 $page_autotitle = "";
 958                                 $page_autosection = "";
 959                                 $page_filename_seek = 0;
 960                                 $page_filename_dircount = 0;
 961
 962                                 $page_filename_directory = "";
 963                                 $page_directory_path = "";
 964                                 $page_directory_name = "";
 965                                 @pagedirectories = ();
 966
 967                                 # Write the file to the output directory.
 968
 969                                 ($page_filename) = $page_filename =~ m/^(.*)$/g;
 970                                 ($kiriwrite_config{"directory_data_output"}) = $kiriwrite_config{"directory_data_output"} =~ m/^(.*)$/g;
 971
 972                                 open($filehandle_page, "> ",  $kiriwrite_config{"directory_data_output"} . '/' . $page_filename) or ($kiriwrite_presmodule->addtext($error_prefix . kiriwrite_language($kiriwrite_lang->{compile}->{pagenotwritten}, $page_filename, $!)), $kiriwrite_presmodule->addlinebreak(), $error_count++, next);
 973
 974                                 if (!$page_final){
 975
 976                                         $page_final = "";
 977
 978                                 }
 979
 980                                 binmode $filehandle_page, ':utf8';
 981                                 print $filehandle_page $page_final;
 982                                 close($filehandle_page);
 983
 984                                 # Write a message saying the page has been compiled. Check
 985                                 # to see if the page name is blank and write a message
 986                                 # saying there's no page name.
 987
 988                                 if (!$page_name){
 989                                         $kiriwrite_presmodule->addtext($information_prefix . ' ');
 990                                         $kiriwrite_presmodule->additalictext($kiriwrite_lang->{blank}->{noname} . ' ');
 991                                         $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{compile}->{compiledpageblankname}, $page_filename));
 992                                 } else {
 993                                         $kiriwrite_presmodule->addtext($information_prefix . kiriwrite_language($kiriwrite_lang->{compile}->{compiledpage}, $page_name, $page_filename));
 994                                 }
 995
 996
 997                                 $kiriwrite_presmodule->addlinebreak();
 998                                 $pages_count++;
 999
1000                         }
1001
1002                         # Write a message saying that the database has
1003                         # been processed.
1004
1005                         $kiriwrite_presmodule->addtext($information_prefix . kiriwrite_language($kiriwrite_lang->{compile}->{databasefinish}, $database_name));
1006                         $kiriwrite_presmodule->addlinebreak();
1007
1008                 }
1009
1010                 # Disconnect from the database server.
1011
1012                 $kiriwrite_dbmodule->disconnect();
1013
1014                 $kiriwrite_presmodule->addhorizontalline();
1015                 $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{compile}->{compileresults}, $pages_count, $error_count, $warning_count));
1016                 $kiriwrite_presmodule->endbox();
1017                 $kiriwrite_presmodule->addlinebreak();
1018                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=compile", { Text => $kiriwrite_lang->{compile}->{returncompilelist} });
1019
1020                 return $kiriwrite_presmodule->grab();
1021
1022         } elsif ($confirm eq 0){
1023
1024                 # The action to compile the databases has
1025                 # not been confirmed so check what type
1026                 # is being used.
1027
1028                 # Get the list of templates for overwriting the
1029                 # template if needed.
1030
1031                 my $templateoverride_skip       = 0;
1032                 my $templatedbwarning           = "";
1033                 my @template_list;
1034                 my $template_filename;
1035                 my %template_info;
1036                 my %template_dblist;
1037                 tie(%template_dblist, "Tie::IxHash");
1038
1039                 if ($type eq "single"){
1040
1041                         # The type is a single database selected so
1042                         # process that database.
1043
1044                         # Define some variables for later.
1045
1046                         my %database_info;
1047                         my $database_filename_check;
1048                         my $database_maxlength_check;
1049                         my $databasefilename;
1050                         my $database_name;
1051
1052                         # Check that the database name and length are
1053                         # valid and return an error if they aren't.
1054
1055                         $databasefilename = $selectedlist[0];
1056
1057                         # Connect to the database server.
1058
1059                         $kiriwrite_dbmodule->connect();
1060
1061                         # Check if any errors occured while connecting to the database server.
1062
1063                         if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
1064
1065                                 # A database connection error has occured so return
1066                                 # an error.
1067
1068                                 kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
1069
1070                         }
1071
1072                         # Select the database.
1073
1074                         $kiriwrite_dbmodule->selectdb({ DatabaseName => $databasefilename });
1075
1076                         # Check if any errors had occured while selecting the database.
1077
1078                         if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
1079
1080                                 # The database does not exist, so return an error.
1081
1082                                 kiriwrite_error("databasemissingfile");
1083
1084                         } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
1085
1086                                 # The database has invalid permissions set, so return
1087                                 # an error.
1088
1089                                 kiriwrite_error("databaseinvalidpermissions");
1090
1091                         }
1092
1093                         # Get information about the database.
1094
1095                         %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
1096
1097                         # Check if any error occured while getting the database information.
1098
1099                         if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
1100
1101                                 # A database error has occured so return an error and
1102                                 # also the extended error information.
1103
1104                                 kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
1105
1106                         };
1107
1108                         $database_name = $database_info{"DatabaseName"};
1109
1110                         $kiriwrite_dbmodule->connecttemplate();
1111
1112                         # Check if any errors occured while connecting to the
1113                         # template database.
1114
1115                         if ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseDoesNotExist"){
1116
1117                                 # The template database does not exist so skip processing
1118                                 # the list of templates in the template database.
1119
1120                                 $templateoverride_skip = 1;
1121                                 $templatedbwarning = $kiriwrite_lang->{compile}->{templatedbmissing};
1122
1123                         } elsif ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseInvalidPermissionsSet"){
1124
1125                                 # The template database has invalid permissions set so
1126                                 # skip processing the list of templates in the
1127                                 # template database.
1128
1129                                 $templateoverride_skip = 1;
1130                                 $templatedbwarning = $kiriwrite_lang->{compile}->{templatedbinvalidpermissions};
1131
1132                         }
1133
1134                         # Get the list of available templates if no errors had
1135                         # occured.
1136
1137                         if ($templateoverride_skip ne 1){
1138
1139                                 @template_list = $kiriwrite_dbmodule->gettemplatelist();
1140
1141                                 # Check if any errors occured while getting the list of templates.
1142
1143                                 if ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseError"){
1144
1145                                         # A template database error has occured so skip processing the
1146                                         # list of templates in the template database.
1147
1148                                         $templateoverride_skip = 1;
1149                                         $templatedbwarning = $kiriwrite_lang->{compile}->{templatedberror};
1150
1151                                 }
1152
1153                                 if ($templateoverride_skip ne 1){
1154
1155                                         foreach $template_file (@template_list){
1156
1157                                                 %template_info = $kiriwrite_dbmodule->gettemplateinfo({ TemplateFilename => $template_file });
1158
1159                                                 if ($kiriwrite_dbmodule->geterror eq "TemplateDoesNotExist"){
1160
1161                                                         next;
1162
1163                                                 } elsif ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseError"){
1164
1165                                                         next;
1166
1167                                                 }
1168
1169                                                 $template_dblist{$template_file} = $template_info{"TemplateName"};
1170
1171                                         }
1172
1173                                 }
1174
1175                         }
1176
1177                         # Disconnect from the template database and database server.
1178
1179                         $kiriwrite_dbmodule->disconnecttemplate();
1180                         $kiriwrite_dbmodule->disconnect();
1181
1182                         # Write out a form asking the user to confirm if the
1183                         # user wants to compile the selected database.
1184
1185                         $kiriwrite_presmodule->addtext($kiriwrite_lang->{compile}->{compiledatabase}, { Style => "pageheader" });
1186                         $kiriwrite_presmodule->startform($kiriwrite_env{"script_filename"}, "POST");
1187                         $kiriwrite_presmodule->startbox();
1188                         $kiriwrite_presmodule->addhiddendata("mode", "compile");
1189                         $kiriwrite_presmodule->addhiddendata("action", "compile");
1190                         $kiriwrite_presmodule->addhiddendata("type", "multiple");
1191                         $kiriwrite_presmodule->addhiddendata("id[1]", $databasefilename);
1192                         $kiriwrite_presmodule->addhiddendata("name[1]", "on");
1193                         $kiriwrite_presmodule->addhiddendata("confirm", 1);
1194                         $kiriwrite_presmodule->addlinebreak();
1195                         $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{compile}->{compiledatabasemessage}, $database_name));
1196                         $kiriwrite_presmodule->addlinebreak();
1197                         $kiriwrite_presmodule->addlinebreak();
1198
1199                         if ($templateoverride_skip eq 1){
1200
1201                                 # Add message saying why template can't be overridden.
1202                                 $kiriwrite_presmodule->addtext($templatedbwarning);
1203
1204                         } else {
1205
1206                                 # Add overwrite template data.
1207                                 $kiriwrite_presmodule->addcheckbox("enableoverride", { OptionDescription => $kiriwrite_lang->{compile}->{overridetemplate}, LineBreak => 1 });
1208                                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{compile}->{replacecurrenttemplate});
1209                                 $kiriwrite_presmodule->addselectbox("overridetemplate");
1210
1211                                 foreach $template_file (keys %template_dblist){
1212
1213                                         $kiriwrite_presmodule->addoption($template_dblist{$template_file} . " (" . $template_file . ")", { Value => $template_file });
1214
1215                                 }
1216
1217                                 $kiriwrite_presmodule->addoption($kiriwrite_lang->{compile}->{dontusetemplate}, { Value => "!none" });
1218                                 $kiriwrite_presmodule->endselectbox();
1219
1220                         }
1221
1222                         $kiriwrite_presmodule->addlinebreak();
1223                         $kiriwrite_presmodule->addlinebreak();
1224                         $kiriwrite_presmodule->addsubmit($kiriwrite_lang->{compile}->{compiledatabasebutton});
1225                         $kiriwrite_presmodule->addtext(" | ");
1226                         $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=compile", { Text => $kiriwrite_lang->{compile}->{returncompilelist} });
1227                         $kiriwrite_presmodule->endbox();
1228                         $kiriwrite_presmodule->endform();
1229
1230                         return $kiriwrite_presmodule->grab();
1231
1232                 } elsif ($type eq "multiple"){
1233
1234                         # The type is multiple databases selected
1235                         # so process each database.
1236
1237                         # Define some variables for later.
1238
1239                         my %database_list;
1240                         my $databasename;
1241                         my $database;
1242                         my $database_filename_check;
1243                         my $database_maxlength_check;
1244                         my $database_count = 0;
1245                         my $database_info_name;
1246
1247                         # Connect to the database server.
1248
1249                         $kiriwrite_dbmodule->connect();
1250
1251                         # Check if any errors occured while connecting to the database server.
1252
1253                         if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
1254
1255                                 # A database connection error has occured so return
1256                                 # an error.
1257
1258                                 kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
1259
1260                         }
1261
1262                         foreach $databasename (@selectedlist){
1263
1264                                 # Check if the database is in the database
1265                                 # directory and skip it if it isn't.
1266
1267                                 $database_filename_check        = kiriwrite_variablecheck($databasename, "filename", "", 1);
1268                                 $database_maxlength_check       = kiriwrite_variablecheck($databasename, "maxlength", 32, 1);
1269
1270                                 if ($database_filename_check ne 0 || $database_maxlength_check ne 0){
1271
1272                                         # The database filename given is invalid or
1273                                         # the database filename given is too long
1274                                         # so process the next database.
1275
1276                                         next;
1277
1278                                 }
1279
1280                                 # Select the database to add the page to.
1281
1282                                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $databasename });
1283
1284                                 # Check if any errors had occured while selecting the database.
1285
1286                                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
1287
1288                                         # The database does not exist, so process the next database.
1289
1290                                         next;
1291
1292                                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
1293
1294                                         # The database has invalid permissions set, so process
1295                                         # the next database.
1296
1297                                         next;
1298
1299                                 }
1300
1301                                 # Get information about the database.
1302
1303                                 my %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
1304
1305                                 # Check if any error occured while getting the database information.
1306
1307                                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
1308
1309                                         # A database error has occured so process the next
1310                                         # database.
1311
1312                                         next;
1313
1314                                 };
1315
1316                                 $database_list{$database_count}{Name}           = $database_info{"DatabaseName"};
1317                                 $database_list{$database_count}{Filename}       = $databasename;
1318
1319                                 $database_count++;
1320
1321                         }
1322
1323                         # Check if any databases are available to be compiled.
1324
1325                         if ($database_count eq 0){
1326
1327                                 # No databases are available to be compiled.
1328
1329                                 kiriwrite_error("nodatabaseselected");
1330
1331                         }
1332
1333                         # Write out the form for compiling the database.
1334
1335                         $kiriwrite_presmodule->addtext($kiriwrite_lang->{compile}->{compileselecteddatabases}, { Style => "pageheader" });
1336                         $kiriwrite_presmodule->addlinebreak();
1337                         $kiriwrite_presmodule->addlinebreak();
1338                         $kiriwrite_presmodule->startform($kiriwrite_env{"script_filename"}, "POST");
1339                         $kiriwrite_presmodule->startbox();
1340                         $kiriwrite_presmodule->addhiddendata("mode", "compile");
1341                         $kiriwrite_presmodule->addhiddendata("action", "compile");
1342                         $kiriwrite_presmodule->addhiddendata("type", "multiple");
1343                         $kiriwrite_presmodule->addhiddendata("count", $database_count);
1344                         $kiriwrite_presmodule->addhiddendata("confirm", 1);
1345                         $kiriwrite_presmodule->addtext($kiriwrite_lang->{compile}->{compileselecteddatabasesmessage});
1346                         $kiriwrite_presmodule->addlinebreak();
1347                         $kiriwrite_presmodule->addlinebreak();
1348                         $kiriwrite_presmodule->startbox("datalist");
1349
1350                         $database_count = 0;
1351
1352                         # write out the list of databases to compile.
1353
1354                         foreach $database (keys %database_list){
1355
1356                                 $database_count++;
1357
1358                                 $kiriwrite_presmodule->addhiddendata("id[" . $database_count . "]", $database_list{$database}{Filename});
1359                                 $kiriwrite_presmodule->addhiddendata("name[" . $database_count . "]", "on");
1360
1361                                 # Check if the database name is undefined and if it is
1362                                 # then write a message saying the database name is blank.
1363
1364                                 if (!$database_list{$database}{Name}){
1365                                         $kiriwrite_presmodule->additalictext($kiriwrite_lang->{compile}->{blankdatabasename});
1366                                 } else {
1367                                         $kiriwrite_presmodule->addtext($database_list{$database}{Name});
1368                                 }
1369
1370                                 $kiriwrite_presmodule->addlinebreak();
1371
1372                         }
1373
1374                         $kiriwrite_presmodule->endbox();
1375
1376                         $kiriwrite_presmodule->addlinebreak();
1377
1378                         $kiriwrite_dbmodule->connecttemplate();
1379
1380                         # Check if any errors occured while connecting to the
1381                         # template database.
1382
1383                         if ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseDoesNotExist"){
1384
1385                                 # The template database does not exist so skip processing
1386                                 # the list of templates in the template database.
1387
1388                                 $templateoverride_skip = 1;
1389                                 $templatedbwarning = $kiriwrite_lang->{compile}->{templatedbmissing};
1390
1391                         } elsif ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseInvalidPermissionsSet"){
1392
1393                                 # The template database has invalid permissions set so
1394                                 # skip processing the list of templates in the
1395                                 # template database.
1396
1397                                 $templateoverride_skip = 1;
1398                                 $templatedbwarning = $kiriwrite_lang->{compile}->{templatedbinvalidpermissions};
1399
1400                         }
1401
1402                         # Get the list of available templates if no errors had
1403                         # occured.
1404
1405                         if ($templateoverride_skip ne 1){
1406
1407                                 @template_list = $kiriwrite_dbmodule->gettemplatelist();
1408
1409                                 # Check if any errors occured while getting the list of templates.
1410
1411                                 if ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseError"){
1412
1413                                         # A template database error has occured so skip processing the
1414                                         # list of templates in the template database.
1415
1416                                         $templateoverride_skip = 1;
1417                                         $templatedbwarning = $kiriwrite_lang->{compile}->{templatedberror};
1418
1419                                 }
1420
1421                                 if ($templateoverride_skip ne 1){
1422
1423                                         foreach $template_file (@template_list){
1424
1425                                                 %template_info = $kiriwrite_dbmodule->gettemplateinfo({ TemplateFilename => $template_file });
1426
1427                                                 if ($kiriwrite_dbmodule->geterror eq "TemplateDoesNotExist"){
1428
1429                                                         next;
1430
1431                                                 } elsif ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseError"){
1432
1433                                                         next;
1434
1435                                                 }
1436
1437                                                 $template_dblist{$template_file} = $template_info{"TemplateName"};
1438
1439                                         }
1440
1441                                 }
1442
1443                         }
1444
1445                         if ($templateoverride_skip eq 1){
1446
1447                                 # Add message saying why template can't be overridden.
1448                                 $kiriwrite_presmodule->addtext($templatedbwarning);
1449
1450                         } else {
1451
1452                                 # Add overwrite template data.
1453                                 $kiriwrite_presmodule->addcheckbox("enableoverride", { OptionDescription => $kiriwrite_lang->{compile}->{overridetemplate}, LineBreak => 1 });
1454                                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{compile}->{replacecurrenttemplate});
1455                                 $kiriwrite_presmodule->addselectbox("overridetemplate");
1456
1457                                 foreach $template_file (keys %template_dblist){
1458
1459                                         $kiriwrite_presmodule->addoption($template_dblist{$template_file} . " (" . $template_file . ")", { Value => $template_file });
1460
1461                                 }
1462
1463                                 $kiriwrite_presmodule->addoption($kiriwrite_lang->{compile}->{dontusetemplate}, { Value => "!none" });
1464                                 $kiriwrite_presmodule->endselectbox();
1465
1466                         }
1467
1468                         # Disconnect from the template database and database server.
1469
1470                         $kiriwrite_dbmodule->disconnecttemplate();
1471                         $kiriwrite_dbmodule->disconnect();
1472
1473                         $kiriwrite_presmodule->addlinebreak();
1474                         $kiriwrite_presmodule->addlinebreak();
1475                         $kiriwrite_presmodule->addsubmit($kiriwrite_lang->{compile}->{compileselecteddatabasesbutton});
1476                         $kiriwrite_presmodule->addtext(" | ");
1477                         $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=compile", { Text => $kiriwrite_lang->{compile}->{returncompilelist} });
1478                         $kiriwrite_presmodule->endbox();
1479                         $kiriwrite_presmodule->endform();
1480
1481                         return $kiriwrite_presmodule->grab();
1482
1483                 } else {
1484
1485                         # The type is something else other than
1486                         # single or multiple, so return an error.
1487
1488                         kiriwrite_error("invalidvariable");
1489
1490                 }
1491
1492         } else {
1493
1494                 # The confirm value is neither 0 or 1, so
1495                 # return an error.
1496
1497                 kiriwrite_error("invalidvariable");
1498
1499         }
1500
1501 }
1502
1503 sub kiriwrite_compile_all{
1504 #################################################################################
1505 # kiriwrite_compile_all: Compile all of the databases in the database           #
1506 # directory.                                                                    #
1507 #                                                                               #
1508 # Usage:                                                                        #
1509 #                                                                               #
1510 # kiriwrite_compile_all();                                                      #
1511 #################################################################################
1512
1513         # Connect to the database server.
1514
1515         $kiriwrite_dbmodule->connect();
1516
1517         # Check if any errors occured while connecting to the database server.
1518
1519         if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
1520
1521                 # A database connection error has occured so return
1522                 # an error.
1523
1524                 kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
1525
1526         }
1527
1528         # Get the list of available databases.
1529
1530         my @database_list = $kiriwrite_dbmodule->getdblist();
1531
1532         # Check if any errors occured while getting the databases.
1533
1534         if ($kiriwrite_dbmodule->geterror eq "DataDirMissing"){
1535
1536                 # The database directory is missing so return an error.
1537
1538                 kiriwrite_error("datadirectorymissing");
1539
1540         } elsif ($kiriwrite_dbmodule->geterror eq "DataDirInvalidPermissions"){
1541
1542                 # The database directory has invalid permissions set so return
1543                 # an error.
1544
1545                 kiriwrite_error("datadirectoryinvalidpermissions");
1546
1547         }
1548
1549         # Define some variables for later.
1550
1551         my $database;
1552         my $database_name_filename_check;
1553         my $database_count              = 0;
1554
1555         # Check the list of databases to compile to see if it is blank,
1556         # if it is then return an error.
1557
1558         if (!@database_list){
1559
1560                 # The list of database is blank so return an error.
1561
1562                 kiriwrite_error("nodatabasesavailable");
1563
1564         }
1565
1566         # Write out a form for confirming the action to compile all of the databases.
1567
1568         $kiriwrite_presmodule->addtext($kiriwrite_lang->{compile}->{compilealldatabases}, { Style => "pageheader" });
1569         $kiriwrite_presmodule->addlinebreak();
1570         $kiriwrite_presmodule->addlinebreak();
1571
1572         $kiriwrite_presmodule->startform($kiriwrite_env{"script_filename"}, "POST");
1573         $kiriwrite_presmodule->startbox();
1574         $kiriwrite_presmodule->addhiddendata("mode", "compile");
1575         $kiriwrite_presmodule->addhiddendata("action", "compile");
1576         $kiriwrite_presmodule->addhiddendata("type", "multiple");
1577
1578         $kiriwrite_presmodule->addtext($kiriwrite_lang->{compile}->{compilealldatabasesmessage});
1579         $kiriwrite_presmodule->addlinebreak();
1580         $kiriwrite_presmodule->addlinebreak();
1581
1582         foreach $database (@database_list){
1583
1584                 # Check if the database filename is blank.
1585
1586                 if ($database eq ""){
1587
1588                         # The database filename is blank so process
1589                         # the next database.
1590
1591                         next;
1592
1593                 }
1594
1595                 # Check if the database filename is valid before
1596                 # using the database.
1597
1598                 $database_name_filename_check   = kiriwrite_variablecheck($database, "filename", 0, 1);
1599
1600                 if ($database_name_filename_check ne 0){
1601
1602                         # The database filename is invalid so process
1603                         # the next database.
1604
1605                         next;
1606
1607                 }
1608
1609                 $database_count++;
1610                 $kiriwrite_presmodule->addhiddendata("id[" . $database_count . "]", $database);
1611                 $kiriwrite_presmodule->addhiddendata("name[" . $database_count . "]", "on");
1612
1613         }
1614
1615         $kiriwrite_presmodule->addhiddendata("count", $database_count);
1616
1617         my $templateoverride_skip       = 0;
1618         my $templatedbwarning           = "";
1619         my @template_list;
1620         my $template_filename;
1621         my %template_info;
1622         my %template_dblist;
1623         tie(%template_dblist, "Tie::IxHash");
1624
1625         $kiriwrite_dbmodule->connecttemplate();
1626
1627         # Check if any errors occured while connecting to the
1628         # template database.
1629
1630         if ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseDoesNotExist"){
1631
1632                 # The template database does not exist so skip processing
1633                 # the list of templates in the template database.
1634
1635                 $templateoverride_skip = 1;
1636                 $templatedbwarning = $kiriwrite_lang->{compile}->{templatedbmissing};
1637
1638         } elsif ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseInvalidPermissionsSet"){
1639
1640                 # The template database has invalid permissions set so
1641                 # skip processing the list of templates in the
1642                 # template database.
1643
1644                 $templateoverride_skip = 1;
1645                 $templatedbwarning = $kiriwrite_lang->{compile}->{templatedbinvalidpermissions};
1646
1647         }
1648
1649         # Get the list of available templates if no errors had
1650         # occured.
1651
1652         if ($templateoverride_skip ne 1){
1653
1654                 @template_list = $kiriwrite_dbmodule->gettemplatelist();
1655
1656                 # Check if any errors occured while getting the list of templates.
1657
1658                 if ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseError"){
1659
1660                         # A template database error has occured so skip processing the
1661                         # list of templates in the template database.
1662
1663                         $templateoverride_skip = 1;
1664                         $templatedbwarning = $kiriwrite_lang->{compile}->{templatedberror};
1665
1666                 }
1667
1668                 if ($templateoverride_skip ne 1){
1669
1670                         foreach $template_file (@template_list){
1671
1672                                 %template_info = $kiriwrite_dbmodule->gettemplateinfo({ TemplateFilename => $template_file });
1673
1674                                 if ($kiriwrite_dbmodule->geterror eq "TemplateDoesNotExist"){
1675
1676                                         next;
1677
1678                                 } elsif ($kiriwrite_dbmodule->geterror eq "TemplateDatabaseError"){
1679
1680                                         next;
1681
1682                                 }
1683
1684                                 $template_dblist{$template_file} = $template_info{"TemplateName"};
1685
1686                         }
1687
1688                 }
1689
1690         }
1691
1692         if ($templateoverride_skip eq 1){
1693
1694                 # Add message saying why template can't be overridden.
1695                 $kiriwrite_presmodule->addtext($templatedbwarning);
1696
1697         } else {
1698
1699                 # Add overwrite template data.
1700                 $kiriwrite_presmodule->addcheckbox("enableoverride", { OptionDescription => $kiriwrite_lang->{compile}->{overridetemplate}, LineBreak => 1 });
1701                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{compile}->{replacecurrenttemplate});
1702                 $kiriwrite_presmodule->addselectbox("overridetemplate");
1703
1704                 foreach $template_file (keys %template_dblist){
1705
1706                         $kiriwrite_presmodule->addoption($template_dblist{$template_file} . " (" . $template_file . ")", { Value => $template_file });
1707
1708                 }
1709
1710                 $kiriwrite_presmodule->addoption($kiriwrite_lang->{compile}->{dontusetemplate}, { Value => "!none" });
1711                 $kiriwrite_presmodule->endselectbox();
1712
1713         }
1714
1715         # Disconnect from the template database and database server.
1716
1717         $kiriwrite_dbmodule->disconnecttemplate();
1718         $kiriwrite_dbmodule->disconnect();
1719
1720         $kiriwrite_presmodule->addlinebreak();
1721         $kiriwrite_presmodule->addlinebreak();
1722
1723         $kiriwrite_presmodule->addhiddendata("confirm", 1);
1724         $kiriwrite_presmodule->addsubmit($kiriwrite_lang->{compile}->{compilealldatabasesbutton});
1725         $kiriwrite_presmodule->addtext(" | ");
1726         $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=compile", { Text => $kiriwrite_lang->{compile}->{returncompilelist} });
1727         $kiriwrite_presmodule->endbox();
1728         $kiriwrite_presmodule->endform();
1729
1730         return $kiriwrite_presmodule->grab();
1731
1732 }
1733
1734
1735 sub kiriwrite_compile_list{
1736 #################################################################################
1737 # kiriwrite_compile_list: Shows a list of databases that can be compiled.       #
1738 #                                                                               #
1739 # Usage:                                                                        #
1740 #                                                                               #
1741 # kiriwrite_compile_list();                                                     #
1742 #################################################################################
1743
1744         # Define the following variables that are going to be used before using
1745         # the foreach function.
1746
1747         my %database_info;
1748         my %database_list;
1749         my $database_count = 0;
1750         my $database_filename = "";
1751         my $database_filename_friendly = "";
1752         my $database_permissions = "";
1753         my $database_name = "";
1754         my $database_description = "";
1755         my $data_file = "";
1756         my @permissions_list;
1757         my @error_list;
1758         my $table_style = 0;
1759         my $table_style_name = "";
1760         my $database;
1761
1762         tie(%database_list, 'Tie::IxHash');
1763
1764         # Connect to the database server.
1765
1766         $kiriwrite_dbmodule->connect();
1767
1768         # Check if any errors occured while connecting to the database server.
1769
1770         if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
1771
1772                 # A database connection error has occured so return
1773                 # an error.
1774
1775                 kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
1776
1777         }
1778
1779         # Get the list of available databases and process any errors that
1780         # might have occured.
1781
1782         my @database_list = $kiriwrite_dbmodule->getdblist();
1783
1784         if ($kiriwrite_dbmodule->geterror eq "DataDirMissing"){
1785
1786                 # The database directory is missing so return an error.
1787
1788                 kiriwrite_error("datadirectorymissing");
1789
1790         } elsif ($kiriwrite_dbmodule->geterror eq "DataDirInvalidPermissions"){
1791
1792                 # The database directory has invalid permissions set so return
1793                 # an error.
1794
1795                 kiriwrite_error("datadirectoryinvalidpermissions");
1796
1797         }
1798
1799         # Begin creating the table for the list of databases.
1800
1801         foreach $data_file (@database_list){
1802
1803                 # Select the database.
1804
1805                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $data_file });
1806
1807                 # Check if any error occured while selecting the database.
1808
1809                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
1810
1811                         # The database does not exist, so process the next
1812                         # database.
1813
1814                         next;
1815
1816                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet") {
1817
1818                         # The database has invalid permissions settings, so
1819                         # add the database to the list of databases with
1820                         # invalid permissions set and process the next
1821                         # database.
1822
1823                         push(@permissions_list, $data_file);
1824                         next;
1825
1826                 }
1827
1828                 # Get information about the database.
1829
1830                 %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
1831
1832                 # Check if any error occured while getting information from the
1833                 # database.
1834
1835                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
1836
1837                         # A database error has occured, add the database and specific
1838                         # error message to the list of databases with errors and
1839                         # process the next database.
1840
1841                         push(@error_list, $data_file . ": " . $kiriwrite_dbmodule->geterror(1));
1842                         next;
1843
1844                 }
1845
1846                 $database_name          = $database_info{"DatabaseName"};
1847                 $database_description   = $database_info{"Description"};
1848
1849                 # Create a friendly name for the database.
1850
1851                 $database_filename_friendly = $data_file;
1852
1853                 # Append the database information to the table.
1854
1855                 $database_list{$database_count}{Filename}       = $database_filename_friendly;
1856                 $database_list{$database_count}{Name}           = $database_name;
1857                 $database_list{$database_count}{Description}    = $database_description;
1858
1859                 $database_count++;
1860
1861         }
1862
1863         # Check if there are no valid databases are if there is no
1864         # valid databases then write a message saying that no
1865         # valid databases are available.
1866
1867         $kiriwrite_presmodule->addtext($kiriwrite_lang->{compile}->{compilepages}, { Style => "pageheader" });
1868         $kiriwrite_presmodule->addlinebreak();
1869         $kiriwrite_presmodule->addlinebreak();
1870
1871         if ($database_count eq 0){
1872
1873                 # There are no databases available for compiling so
1874                 # write a message instead.
1875
1876                 $kiriwrite_presmodule->startbox("errorbox");
1877                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{compile}->{nodatabasesavailable});
1878                 $kiriwrite_presmodule->endbox();
1879
1880         } else {
1881
1882                 $kiriwrite_presmodule->startform($kiriwrite_env{"script_filename"}, "POST");
1883                 $kiriwrite_presmodule->startbox();
1884                 $kiriwrite_presmodule->addhiddendata("mode", "compile");
1885                 $kiriwrite_presmodule->addhiddendata("action", "compile");
1886                 $kiriwrite_presmodule->addhiddendata("type", "multiple");
1887
1888                 $kiriwrite_presmodule->addreset($kiriwrite_lang->{common}->{selectnone});
1889                 $kiriwrite_presmodule->addtext(" | ");
1890                 $kiriwrite_presmodule->addsubmit($kiriwrite_lang->{compile}->{compileselectedbutton});
1891                 $kiriwrite_presmodule->addlinebreak();
1892                 $kiriwrite_presmodule->addlinebreak();
1893                 $kiriwrite_presmodule->addhiddendata("count", $database_count);
1894                 $kiriwrite_presmodule->starttable("", { CellPadding => 5, CellSpacing => 0 });
1895
1896                 $kiriwrite_presmodule->startheader();
1897                 $kiriwrite_presmodule->addheader("", { Style => "tablecellheader" });
1898                 $kiriwrite_presmodule->addheader($kiriwrite_lang->{database}->{databasename}, { Style => "tablecellheader" });
1899                 $kiriwrite_presmodule->addheader($kiriwrite_lang->{database}->{databasedescription}, { Style => "tablecellheader" });
1900                 $kiriwrite_presmodule->addheader($kiriwrite_lang->{common}->{options}, { Style => "tablecellheader" });
1901                 $kiriwrite_presmodule->endheader();
1902
1903                 $database_count = 1;
1904
1905                 foreach $database (keys %database_list){
1906
1907                         # Check the style to be used with.
1908
1909                         if ($table_style eq 0){
1910
1911                                 # Use the first style and set the style value
1912                                 # to use the next style, the next time the
1913                                 # if statement is checked.
1914
1915                                 $table_style_name = "tablecell1";
1916                                 $table_style = 1;
1917
1918                         } else {
1919
1920                                 # Use the second style and set the style
1921                                 # value to use the first style, the next
1922                                 # time if statement is checked.
1923
1924                                 $table_style_name = "tablecell2";
1925                                 $table_style = 0;
1926                         }
1927
1928                         # Add the template to the list of available
1929                         # templates to compile.
1930
1931                         $kiriwrite_presmodule->startrow();
1932                         $kiriwrite_presmodule->addcell($table_style_name);
1933                         $kiriwrite_presmodule->addhiddendata("id[" . $database_count . "]", $database_list{$database}{Filename});
1934                         $kiriwrite_presmodule->addcheckbox("name[" . $database_count . "]");
1935                         $kiriwrite_presmodule->endcell();
1936                         $kiriwrite_presmodule->addcell($table_style_name);
1937
1938                         if (!$database_list{$database}{Name}){
1939                                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=compile&action=compile&type=single&database=" . $database_list{$database}{Filename}, { Text => $kiriwrite_presmodule->additalictext($kiriwrite_lang->{blank}->{noname}) });
1940                         } else {
1941                                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $database_list{$database}{Filename}, { Text => $database_list{$database}{Name} });
1942                         }
1943
1944                         $kiriwrite_presmodule->endcell();
1945                         $kiriwrite_presmodule->addcell($table_style_name);
1946
1947                         if (!$database_list{$database}{Description}){
1948                                 $kiriwrite_presmodule->additalictext($kiriwrite_lang->{blank}->{nodescription});
1949                         } else {
1950                                 $kiriwrite_presmodule->addtext($database_list{$database}{Description});
1951                         }
1952
1953                         $kiriwrite_presmodule->endcell();
1954                         $kiriwrite_presmodule->addcell($table_style_name);
1955                         $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=compile&action=compile&type=single&database=" . $database_list{$database}{Filename}, { Text => $kiriwrite_lang->{options}->{compile} });
1956                         $kiriwrite_presmodule->endcell();
1957                         $kiriwrite_presmodule->endrow();
1958
1959                         $database_count++;
1960
1961                 }
1962
1963                 $kiriwrite_presmodule->endtable();
1964                 $kiriwrite_presmodule->endbox();
1965                 $kiriwrite_presmodule->endform();
1966
1967         }
1968
1969         # Disconnect from the database server.
1970
1971         $kiriwrite_dbmodule->disconnect();
1972
1973         # Check if any databases with problems have appeared and if they
1974         # have, print out a message saying which databases have problems.
1975
1976         if (@permissions_list){
1977
1978                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{databaseinvalidpermissions}, { Style => "smallpageheader" });
1979                 $kiriwrite_presmodule->addlinebreak();
1980                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{databaseinvalidpermissionstext});
1981                 $kiriwrite_presmodule->addlinebreak();
1982
1983                 foreach $database (@permissions_list){
1984
1985                         $kiriwrite_presmodule->addlinebreak();
1986                         $kiriwrite_presmodule->addtext($database);
1987
1988                 }
1989
1990                 $kiriwrite_presmodule->addlinebreak();
1991                 $kiriwrite_presmodule->addlinebreak();
1992
1993         }
1994
1995         if (@error_list){
1996
1997                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{databaseerrors}, { Style => "smallpageheader" });
1998                 $kiriwrite_presmodule->addlinebreak();
1999                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{databaseerrorstext});
2000                 $kiriwrite_presmodule->addlinebreak();
2001
2002                 foreach $database (@error_list){
2003
2004                         $kiriwrite_presmodule->addlinebreak();
2005                         $kiriwrite_presmodule->addtext($database);
2006
2007                 }
2008
2009         }
2010
2011         return $kiriwrite_presmodule->grab();
2012
2013 }
2014
2015 sub kiriwrite_compile_clean{
2016 #################################################################################
2017 # kiriwrite_compile_clean: Deletes the contents of the output directory.        #
2018 #                                                                               #
2019 # Usage:                                                                        #
2020 #                                                                               #
2021 # kiriwrite_compile_clean(confirm);                                             #
2022 #                                                                               #
2023 # confirm       Confirms the deletion of files from the output directory.       #
2024 #################################################################################
2025
2026         # Get the values passed to the subroutine.
2027
2028         my ($confirm) = @_;
2029
2030         # Define some variables for later.
2031
2032         my $file_permissions;
2033         my $output_directory_exists;
2034         my $output_directory_permissions;
2035         my $warning_message;
2036
2037         # Check if the output directory exists.
2038
2039         $output_directory_exists         = kiriwrite_fileexists($kiriwrite_config{"directory_data_output"});
2040
2041         if ($output_directory_exists eq 1){
2042
2043                 # The output directory does not exist so return
2044                 # an error.
2045
2046                 kiriwrite_error("outputdirectorymissing");
2047
2048         }
2049
2050         # Check if the output directory has invalid
2051         # permissions set.
2052
2053         $output_directory_permissions   = kiriwrite_filepermissions($kiriwrite_config{"directory_data_output"});
2054
2055         if ($output_directory_permissions eq 1){
2056
2057                 # The output directory has invalid permissions
2058                 # set, so return an error.
2059
2060                 kiriwrite_error("outputdirectoryinvalidpermissions");
2061
2062         }
2063
2064         if ($confirm) {
2065
2066                 if ($confirm eq 1){
2067
2068                         # The action to clean the output directory has been
2069                         # confirmed.
2070
2071                         # Remove the list of files and directories from the
2072                         # output directory.
2073
2074                         $file_permissions = kiriwrite_compile_clean_helper($kiriwrite_config{"directory_data_output"}, 1);
2075
2076                         $kiriwrite_presmodule->addtext($kiriwrite_lang->{compile}->{cleanoutputdirectory}, { Style => "pageheader" });
2077
2078                         if ($file_permissions eq 1){
2079
2080                                 $kiriwrite_presmodule->addlinebreak();
2081                                 $kiriwrite_presmodule->addlinebreak();
2082                                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{compile}->{somecontentnotremoved});
2083                                 $kiriwrite_presmodule->addlinebreak();
2084                                 $kiriwrite_presmodule->addlinebreak();
2085
2086                         } else {
2087
2088                                 $kiriwrite_presmodule->addlinebreak();
2089                                 $kiriwrite_presmodule->addlinebreak();
2090                                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{compile}->{contentremoved});
2091                                 $kiriwrite_presmodule->addlinebreak();
2092                                 $kiriwrite_presmodule->addlinebreak();
2093
2094                         }
2095
2096                         $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=compile", { Text => $kiriwrite_lang->{compile}->{returncompilelist} });
2097
2098                         return $kiriwrite_presmodule->grab();
2099
2100                 } else {
2101
2102                         # A value other than 1 is set for the confirm value
2103                         # (which it shouldn't be) so return an error.
2104
2105                         kiriwrite_error("invalidvariable");
2106
2107                 }
2108
2109         }
2110
2111         # Print out a form for cleaning the output directory.
2112
2113         $kiriwrite_presmodule->addtext($kiriwrite_lang->{compile}->{cleanoutputdirectory}, { Style => "pageheader" });
2114         $kiriwrite_presmodule->addlinebreak();
2115         $kiriwrite_presmodule->addlinebreak();
2116         $kiriwrite_presmodule->startform($kiriwrite_env{"script_filename"}, "POST");
2117         $kiriwrite_presmodule->startbox();
2118         $kiriwrite_presmodule->addhiddendata("mode", "compile");
2119         $kiriwrite_presmodule->addhiddendata("action", "clean");
2120         $kiriwrite_presmodule->addhiddendata("confirm", 1);
2121         $kiriwrite_presmodule->addtext($kiriwrite_lang->{compile}->{cleanoutputdirectorymessage});
2122         $kiriwrite_presmodule->addlinebreak();
2123         $kiriwrite_presmodule->addlinebreak();
2124         $kiriwrite_presmodule->addsubmit($kiriwrite_lang->{compile}->{cleanoutputdirectorybutton});
2125         $kiriwrite_presmodule->addtext(" | ");
2126         $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=compile", { Text => $kiriwrite_lang->{compile}->{returncompilelist}});
2127         $kiriwrite_presmodule->endbox();
2128         $kiriwrite_presmodule->endform();
2129
2130         return $kiriwrite_presmodule->grab();
2131
2132 }
2133
2134 sub kiriwrite_compile_clean_helper{
2135 #################################################################################
2136 # kiriwrite_compile_clean_helper: Helper for cleaning out the output directory. #
2137 # This command sometimes is called recursively (when a directory is found).     #
2138 #                                                                               #
2139 # Usage:                                                                        #
2140 #                                                                               #
2141 # kiriwrite_compile_clean_helper(directory, removedirectory, [permissions]);    #
2142 #                                                                               #
2143 # directory             Specifies the directory to remove files (and            #
2144 #                       sub-directories) from.                                  #
2145 # keepdirectory         Keeps the directory itself after all files have been    #
2146 #                       removed.                                                #
2147 # permissions           Used recursively for error checking.                    #
2148 #################################################################################
2149
2150         # Get the values passed to the subroutine.
2151
2152         my ($directory, $directory_keep, $permissions) = @_;
2153
2154         # Check if the directory_keep is only one charater long.
2155
2156         my $directory_file = "";
2157         my @directory_list;
2158         my $file_permissions = 0;
2159         my $debug = 0;
2160
2161         # Check if the file permissions value is blank.
2162
2163         if (!$permissions){
2164
2165                 # The file permissions value is blank.
2166
2167                 $permissions = 0;
2168
2169         }
2170
2171         # Open the directory specified, read the contents of
2172         # the directory and then close the directory.
2173
2174         opendir(DIRECTORY, $directory);
2175         @directory_list = readdir(DIRECTORY);
2176         closedir(DIRECTORY);
2177
2178         # Remove each file and directory.
2179
2180         foreach $directory_file (@directory_list){
2181
2182                 # Check if the filename is '.' or '..' and if it
2183                 # is skip those files.
2184
2185                 if ($directory_file eq "." || $directory_file eq ".."){
2186
2187                         # The filename is '.' or '..' so skip processing
2188                         # these files.
2189
2190                 } else {
2191
2192                         # Check if the permissions on the file or directory has
2193                         # valid permissions set.
2194
2195                         $file_permissions = kiriwrite_filepermissions($directory . '/' . $directory_file, 1, 1);
2196
2197                         if ($file_permissions eq 1){
2198
2199                                 # The file or directory has invalid permissions set.
2200
2201                                 $permissions = 1;
2202                                 next;
2203
2204                         }
2205
2206                         # Check if the filename is a directory.
2207
2208                         if (-d $directory . '/' . $directory_file){
2209
2210                                 # The filename is a directory so send the directory name
2211                                 # and this subroutine again (recursively).
2212
2213                                 kiriwrite_compile_clean_helper($directory . '/' . $directory_file, 0, $permissions);
2214
2215                         } else {
2216
2217                                 # The file is not a directory but an actual file so
2218                                 # remove as normal (in terms of the Perl language).
2219
2220                                 ($directory) = $directory =~ m/^(.*)$/g;
2221                                 ($directory_file) = $directory_file =~ m/^(.*)$/g;
2222
2223                                 # Check if the directory is undefined and if it is then
2224                                 # set it to blank.
2225
2226                                 if (!$directory){
2227                                         $directory = "";
2228                                 }
2229
2230                                 if (!$directory_file){
2231                                         $directory_file = "";
2232                                 }
2233
2234                                 unlink($directory . '/' . $directory_file);
2235
2236                         }
2237
2238                 }
2239
2240         }
2241
2242         # Check if the directory should be kept.
2243
2244         if ($directory_keep eq 1){
2245
2246                 # The directory_keep value is set as 1 so the directory
2247                 # specified should be kept.
2248
2249         } elsif ($directory_keep eq 0) {
2250
2251                 # The directory_keep value is set as 0 so remove the
2252                 # directory specified.
2253
2254                 ($directory) = $directory =~ m/^(.*)$/g;
2255                 rmdir($directory);
2256
2257         } else {
2258
2259                 # A value other than 0 or 1 was specified so return
2260                 # an error,
2261
2262                 kiriwrite_error('invalidvalue');
2263
2264         }
2265
2266         return $permissions;
2267
2268 }
2269
2270
2271 1;