cgi-files/Modules/System/Compile.pm

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