cgi-files/lib/compile.lib

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