cgi-files/Modules/System/Compile.pm

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