cgi-files/lib/compile.lib

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